Files
led-controller/web/static/sequences.js
T
jimmyandClaude Sonnet 5.5 2543673bd8 feat: sequences v2, bridges, and sim-controller
Rework sequences (engine, seqplay, envelope, API, web UI), add bridge
support, add the host sim-controller and rig simulation tests, and
update docs, presets and project tooling config.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-10 17:47:27 +13:00

2043 lines
78 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Sequences: lanes (parallel preset chains); advance by audio beats or global simulated BPM.
// Debug: in the browser console run setSequenceDebug(true) — session only, not persisted.
/** @type {'beat'|'downbeat'} */
let sequenceSwitchWaitFor = 'beat';
let sequenceDebugEnabled = false;
let sequenceSwitchSaveInFlight = false;
/** When true (simulated BPM / audio off), downbeat is disabled and switch is beat-only. */
let sequenceSwitchSimulatedMode = false;
async function loadSequenceSwitchWaitForFromServer() {
try {
const res = await fetch('/settings', {
cache: 'no-store',
headers: { Accept: 'application/json' },
});
if (!res.ok) return;
const data = await res.json();
const raw = data && data.sequence_switch_wait;
if (raw === 'downbeat' || raw === 'beat') {
sequenceSwitchWaitFor = raw;
} else if (raw === 'phrase') {
sequenceSwitchWaitFor = 'beat';
}
} catch {
/* keep default */
}
}
async function persistSequenceSwitchWaitFor() {
sequenceSwitchSaveInFlight = true;
try {
const res = await fetch('/settings', {
method: 'PUT',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
body: JSON.stringify({ sequence_switch_wait: sequenceSwitchWaitFor }),
});
if (!res.ok) {
console.warn('[sequence] could not save switch wait to server', res.status);
}
} catch (e) {
console.warn('[sequence] could not save switch wait to server', e);
} finally {
sequenceSwitchSaveInFlight = false;
}
}
function getSequenceSwitchWaitFor() {
return sequenceSwitchWaitFor === 'downbeat' ? 'downbeat' : 'beat';
}
async function setSequenceSwitchWaitFor(waitFor) {
if (sequenceSwitchSimulatedMode) {
sequenceSwitchWaitFor = 'beat';
updateSequenceSwitchToggleUI();
return;
}
sequenceSwitchWaitFor = waitFor === 'downbeat' ? 'downbeat' : 'beat';
updateSequenceSwitchToggleUI();
await persistSequenceSwitchWaitFor();
}
function updateSequenceSwitchToggleUI() {
const mode = sequenceSwitchSimulatedMode ? 'beat' : getSequenceSwitchWaitFor();
const ariaLabels = {
beat: 'Switch sequence on beat',
downbeat: 'Switch sequence on downbeat',
};
document.documentElement.classList.toggle(
'simulated-bpm-mode',
sequenceSwitchSimulatedMode,
);
document.querySelectorAll('.seq-switch-toggle-wrap').forEach((wrap) => {
wrap.hidden = sequenceSwitchSimulatedMode;
wrap.setAttribute('aria-hidden', sequenceSwitchSimulatedMode ? 'true' : 'false');
wrap.classList.toggle('nav-slide-toggle-wrap--downbeat', mode === 'downbeat');
});
if (sequenceSwitchSimulatedMode) {
return;
}
document.querySelectorAll('.seq-switch-toggle').forEach((btn) => {
btn.disabled = false;
btn.removeAttribute('aria-disabled');
btn.setAttribute('aria-pressed', mode === 'beat' ? 'false' : 'true');
btn.setAttribute('aria-label', ariaLabels[mode] || ariaLabels.beat);
btn.classList.toggle('seq-switch-toggle--downbeat', mode === 'downbeat');
btn.title =
mode === 'downbeat'
? 'When starting a sequence: wait for downbeat'
: 'When starting a sequence: wait for beat';
});
}
/** @param {boolean} simulated */
function setSequenceSwitchSimulatedMode(simulated) {
const next = !!simulated;
if (next === sequenceSwitchSimulatedMode) {
if (next) updateSequenceSwitchToggleUI();
return;
}
sequenceSwitchSimulatedMode = next;
if (next) {
sequenceSwitchWaitFor = 'beat';
updateSequenceSwitchToggleUI();
void persistSequenceSwitchWaitFor();
return;
}
void loadSequenceSwitchWaitForFromServer().then(() => updateSequenceSwitchToggleUI());
}
async function syncSequenceSwitchSimulatedModeFromStatus() {
try {
const res = await fetch('/api/audio/status', { cache: 'no-store' });
const data = await res.json();
const simulated = !!(data && data.status && data.status.bpm_simulated);
setSequenceSwitchSimulatedMode(simulated);
} catch {
setSequenceSwitchSimulatedMode(true);
}
}
async function initSequenceSwitchToggle() {
await syncSequenceSwitchSimulatedModeFromStatus();
await loadSequenceSwitchWaitForFromServer();
updateSequenceSwitchToggleUI();
document.querySelectorAll('.seq-switch-toggle').forEach((btn) => {
btn.addEventListener('click', () => {
if (sequenceSwitchSimulatedMode) return;
void setSequenceSwitchWaitFor(getSequenceSwitchWaitFor() === 'beat' ? 'downbeat' : 'beat');
});
});
}
/** Sync toggle when settings changed elsewhere (e.g. another tab via audio status poll). */
function applySequenceSwitchWaitFromServer(raw) {
if (sequenceSwitchSaveInFlight || sequenceSwitchSimulatedMode) return;
let mode = 'beat';
if (raw === 'downbeat') mode = 'downbeat';
else if (raw !== 'beat' && raw !== 'phrase') return;
if (mode === getSequenceSwitchWaitFor()) return;
sequenceSwitchWaitFor = mode;
updateSequenceSwitchToggleUI();
}
function seqDebugEnabled() {
return sequenceDebugEnabled;
}
/** @param {boolean} [clearSequenceTileSelection] When false, leaves the active highlight on sequence tiles (used when restarting playback so the click handler’s selection is not cleared). */
async function stopZoneSequencePlayback(clearSequenceTileSelection = true) {
// Clear selection **before** awaiting fetch so overlapping stop() calls cannot finish out of
// order and strip .active from tiles after a later render or click (intermittent dead UI).
if (clearSequenceTileSelection) {
document.querySelectorAll('.sequence-tile-main.active').forEach((btn) => btn.classList.remove('active'));
}
try {
const res = await fetch('/sequences/stop', {
method: 'POST',
headers: { Accept: 'application/json' },
credentials: 'same-origin',
});
if (!res.ok) {
console.warn('Sequence stop failed:', res.status);
}
} catch (e) {
console.warn('Sequence stop:', e);
}
if (typeof window.ledControllerSequencePlaybackChanged === 'function') {
window.ledControllerSequencePlaybackChanged(false);
}
}
function normalizeSequenceLanes(doc) {
let lanesRaw = Array.isArray(doc && doc.lanes) ? doc.lanes : [];
let lanes = lanesRaw.filter((l) => Array.isArray(l));
const hasAnyLaneSteps = lanes.some((l) => l.length > 0);
if ((!lanes.length || !hasAnyLaneSteps) && Array.isArray(doc && doc.steps) && doc.steps.length) {
lanes = [doc.steps.slice()];
}
if (!lanes.length) lanes = [[]];
return lanes.map((lane) =>
lane
.filter((s) => s && typeof s === 'object')
.map((s) => ({
preset_id: s.preset_id != null ? String(s.preset_id) : String(s.presetId || ''),
animation_id: s.animation_id != null ? String(s.animation_id) : '',
rest: s.rest === true,
others: s.others === 'off' ? 'off' : '',
length: s.length === 'animation' ? 'animation' : '',
targets: Array.isArray(s.targets) ? s.targets.map((x) => parseInt(String(x), 10)).filter((x) => x >= 0) : [],
beats: Math.max(0.25, parseFloat(String(s.beats != null ? s.beats : 1)) || 1),
seconds: Math.max(0.1, parseFloat(String(s.seconds != null ? s.seconds : 3)) || 3),
group_ids: Array.isArray(s.group_ids)
? s.group_ids.map((x) => String(x).trim()).filter(Boolean)
: [],
})),
);
}
/**
* Log each preset in the sequence with its step beat count (beats per step before advancing).
* @param {string} sequenceId
* @param {Record<string, unknown>} sequenceDoc
* @param {Record<string, unknown>} presetsMap
*/
function logSequenceSelectionPresets(sequenceId, sequenceDoc, presetsMap) {
if (!sequenceDoc || typeof sequenceDoc !== 'object') return;
const lanes = normalizeSequenceLanes(sequenceDoc);
const nameFor = (pid) => {
const p = presetsMap && presetsMap[pid];
if (p && typeof p === 'object' && p.name != null && String(p.name).trim()) {
return String(p.name).trim();
}
return pid || '(unknown preset)';
};
const nm = String(sequenceDoc.name || '').trim() || sequenceId;
const multi =
lanes.filter((lane) => lane.some((s) => s && s.preset_id)).length > 1;
let headerLine = `Sequence "${nm}" (${sequenceId}) — advance: beats`;
if (multi) {
headerLine +=
' — header/audio beat readout follows lane 1 only (other lanes run in parallel)';
}
console.log(headerLine);
lanes.forEach((lane, li) => {
const steps = lane.filter((s) => s && s.preset_id);
if (!steps.length) return;
if (multi) console.log(`Lane ${li + 1}`);
steps.forEach((step) => {
const b = step.beats;
console.log(` ${nameFor(step.preset_id)}: ${b} beat${b === 1 ? '' : 's'}`);
});
});
}
function zoneGroupIdsFromDoc(zoneDoc) {
return Array.isArray(zoneDoc && zoneDoc.group_ids)
? zoneDoc.group_ids.map((x) => String(x).trim()).filter(Boolean)
: [];
}
function groupIdsForLaneStep(sequenceDoc, step, laneIndex, numLanes) {
const lgs = Array.isArray(sequenceDoc.lanes_group_ids) ? sequenceDoc.lanes_group_ids : [];
if (laneIndex < lgs.length) {
const forLane = lgs[laneIndex];
if (Array.isArray(forLane)) {
return forLane.map((x) => String(x).trim()).filter(Boolean);
}
}
if (numLanes > 1 && laneIndex >= lgs.length) {
return [];
}
const shared = Array.isArray(sequenceDoc.group_ids)
? sequenceDoc.group_ids.map((x) => String(x).trim()).filter((x) => x.length > 0)
: [];
if (shared.length) return shared;
if (numLanes === 1 && step && Array.isArray(step.group_ids) && step.group_ids.length) {
return step.group_ids.map((x) => String(x).trim()).filter(Boolean);
}
return [];
}
function buildLaneGroupIdsForEditor(doc, laneIndex, numLanes) {
const raw = Array.isArray(doc && doc.lanes_group_ids) ? doc.lanes_group_ids : [];
if (laneIndex < raw.length) {
const row = raw[laneIndex];
if (Array.isArray(row)) {
return row.map(String).filter(Boolean);
}
}
if (numLanes > 1 && laneIndex >= raw.length) {
return [];
}
return [];
}
function renderLaneGroupCheckboxes(groupsMap, selectedIds, zoneGroupIds) {
const wrap = document.createElement('div');
wrap.className = 'sequence-lane-groups-wrap';
wrap.style.cssText = 'margin-bottom:0.6rem;';
const row = document.createElement('div');
row.className = 'sequence-lane-groups';
row.style.cssText = 'display:flex;flex-wrap:wrap;gap:0.5rem;align-items:center;';
const sel = new Set((selectedIds || []).map((x) => String(x)));
const zg = Array.isArray(zoneGroupIds) ? zoneGroupIds.map(String).filter(Boolean) : [];
const gidsToShow = zg.length
? zg
: Object.keys(groupsMap).sort((a, b) => a.localeCompare(b));
gidsToShow.forEach((gid) => {
const g = groupsMap[gid];
const gn = g && g.name ? String(g.name) : gid;
const id = `seq-lg-${gid}-${Math.random().toString(36).slice(2)}`;
const lbl = document.createElement('label');
lbl.style.cssText = 'display:inline-flex;align-items:center;gap:0.25rem;font-size:0.9em;';
const cb = document.createElement('input');
cb.type = 'checkbox';
cb.className = 'sequence-lane-group';
cb.value = gid;
cb.id = id;
if (sel.has(String(gid))) cb.checked = true;
const sp = document.createElement('span');
sp.textContent = `${gn} (${gid})`;
lbl.appendChild(cb);
lbl.appendChild(sp);
row.appendChild(lbl);
});
const editG = document.createElement('button');
editG.type = 'button';
editG.className = 'btn btn-secondary btn-small';
editG.textContent = 'Edit groups';
editG.title = 'Open Device groups';
editG.addEventListener('click', async () => {
if (typeof window.openDeviceGroupsModal === 'function') {
await window.openDeviceGroupsModal();
return;
}
const b = document.getElementById('groups-btn');
if (b) b.click();
else alert('Groups could not be opened.');
});
row.appendChild(editG);
wrap.appendChild(row);
return wrap;
}
function splitDeviceNamesForLane(allNames, laneIndex, numLanes) {
const names = Array.isArray(allNames) ? allNames.filter((n) => n && String(n).trim()) : [];
if (numLanes <= 1) return names;
if (names.length >= numLanes) {
const n = names[laneIndex];
return n ? [n] : [];
}
return names;
}
function presetsSectionElForZone(zoneId) {
if (zoneId != null && String(zoneId).length) {
const el = document.querySelector(`.presets-section[data-zone-id="${String(zoneId)}"]`);
if (el) return el;
}
return document.querySelector('.presets-section[data-zone-id]');
}
/** Match preset tiles: prefer DOM device list, then zone JSON (same as parseTabDeviceNames + computeZoneTargets). */
async function resolveSequenceSendDeviceNames(zoneId, zoneDoc, groupIds) {
const gids = Array.isArray(groupIds) ? groupIds.map((x) => String(x).trim()).filter((x) => x.length > 0) : [];
if (window.zonesManager && typeof window.zonesManager.resolveSequenceStepDeviceNames === 'function' && zoneDoc) {
return await window.zonesManager.resolveSequenceStepDeviceNames(zoneDoc, gids);
}
return [];
}
/** Start sequence playback on the server (ESP-NOW / TCP delivery from backend). */
async function requestBackendSequencePlay(sequenceId, zoneId, sequenceDoc) {
// Do not call stop here: server start() already stops any prior run. A fire-and-forget
// client stop can reorder after play and clear the new session (same tile re-click bug).
const body = { zone_id: String(zoneId) };
const res = await fetch(`/sequences/${encodeURIComponent(sequenceId)}/play`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
credentials: 'same-origin',
body: JSON.stringify(body),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error((err && err.error) || res.statusText);
}
if (typeof window.ledControllerSequencePlaybackChanged === 'function') {
window.ledControllerSequencePlaybackChanged(true);
}
}
/** Play an animation once over whatever runs in the zone; its tile shows progress while it plays. */
async function fireAnimation(sequenceId, zoneId) {
const res = await fetch(`/sequences/${encodeURIComponent(sequenceId)}/fire`, {
method: 'POST',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
credentials: 'same-origin',
body: JSON.stringify({ zone_id: zoneId ? String(zoneId) : '', wait: 'now' }),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error((err && err.error) || res.statusText);
}
pollAnimationProgress();
}
let animProgressTimer = null;
async function pollAnimationProgress() {
if (animProgressTimer) clearTimeout(animProgressTimer);
animProgressTimer = null;
let ov = null;
try {
const r = await fetch('/sequences/status', { cache: 'no-store', headers: { Accept: 'application/json' } });
const st = r.ok ? await r.json() : null;
ov = st && st.overlay ? st.overlay : null;
} catch (_) {
ov = null;
}
document.querySelectorAll('.animation-tile-row').forEach((row) => {
const on = !!(ov && (ov.active || ov.pending) && String(ov.sequence_id || ov.pending_id) === row.dataset.sequenceId);
row.classList.toggle('firing', on);
row.style.setProperty('--anim-progress', on && ov.active ? String(ov.progress || 0) : '0');
});
if (ov && (ov.active || ov.pending)) animProgressTimer = setTimeout(pollAnimationProgress, 250);
}
async function fetchSequencesMap() {
try {
const res = await fetch('/sequences', { cache: 'no-store', headers: { Accept: 'application/json' } });
if (!res.ok) return {};
const data = await res.json();
return data && typeof data === 'object' ? data : {};
} catch (e) {
console.error('fetchSequencesMap:', e);
return {};
}
}
async function fetchGroupsMapSeq() {
try {
const res = await fetch('/groups', {
headers: { Accept: 'application/json' },
credentials: 'same-origin',
});
if (!res.ok) return {};
const data = await res.json();
return data && typeof data === 'object' ? data : {};
} catch (e) {
return {};
}
}
function createSequenceTileRow(sequenceId, sequenceDoc, zoneId, zoneDoc, allPresets, uiMode) {
const row = document.createElement('div');
const canDrag = false;
const isAnim = sequenceDoc && sequenceDoc.kind === 'animation';
row.className = `preset-tile-row preset-tile-row--${uiMode} sequence-tile-row${isAnim ? ' animation-tile-row' : ''}${canDrag ? ' draggable-preset' : ''}`;
row.dataset.sequenceId = sequenceId;
const button = document.createElement('button');
button.type = 'button';
button.className = 'pattern-button preset-tile-main sequence-tile-main';
button.title = sequenceDoc.name || `Sequence ${sequenceId}`;
const label = document.createElement('span');
label.textContent = `${isAnim ? '⚡ ' : ''}${sequenceDoc.name || sequenceId}`;
label.style.fontWeight = 'bold';
label.className = 'pattern-button-label';
button.appendChild(label);
if (isAnim) {
// One shot: never becomes the active tile, so the sequence or preset underneath stays highlighted
button.title = `${sequenceDoc.name || sequenceId} — plays once, then back to what was running`;
const bar = document.createElement('span');
bar.className = 'animation-tile-progress';
button.appendChild(bar);
button.addEventListener('click', () => {
fireAnimation(sequenceId, zoneId).catch((e) => {
console.error(e);
alert(e.message || 'Animation failed.');
});
});
} else button.addEventListener('click', () => {
const strip = document.getElementById('presets-list-zone');
const clearActiveStrip = () => {
if (strip) strip.querySelectorAll('.pattern-button').forEach((btn) => btn.classList.remove('active'));
};
clearActiveStrip();
button.classList.add('active');
void (async () => {
let seq = sequenceDoc;
let zone = zoneDoc;
let presets = allPresets;
try {
const [sr, zr, pr] = await Promise.all([
fetch(`/sequences/${encodeURIComponent(sequenceId)}`, {
headers: { Accept: 'application/json' },
credentials: 'same-origin',
}),
fetch(`/zones/${encodeURIComponent(zoneId)}`, {
headers: { Accept: 'application/json' },
credentials: 'same-origin',
}),
fetch('/presets', { headers: { Accept: 'application/json' }, credentials: 'same-origin' }),
]);
if (sr.ok) {
const j = await sr.json();
if (j && typeof j === 'object' && !j.error) seq = j;
}
if (zr.ok) {
const j = await zr.json();
if (j && typeof j === 'object' && !j.error) zone = j;
}
if (pr.ok) {
const raw = await pr.json();
if (raw && typeof raw === 'object') {
if (typeof window.filterPresetsForCurrentProfile === 'function') {
presets = await window.filterPresetsForCurrentProfile(raw);
} else {
presets = raw;
}
}
}
} catch (e) {
console.warn('Sequence play: refresh fetch failed, using cached data', e);
}
logSequenceSelectionPresets(sequenceId, seq, presets);
try {
await requestBackendSequencePlay(sequenceId, zoneId, seq);
} catch (e) {
console.error(e);
alert(e.message || 'Sequence playback failed.');
}
})();
});
row.appendChild(button);
if (uiMode === 'edit') {
const actions = document.createElement('div');
actions.className = 'preset-tile-actions';
const editBtn = document.createElement('button');
editBtn.type = 'button';
editBtn.className = 'btn btn-secondary btn-small';
editBtn.textContent = 'Edit';
editBtn.addEventListener('click', (e) => {
e.preventDefault();
e.stopPropagation();
openSequenceEditor(sequenceId, sequenceDoc);
});
actions.appendChild(editBtn);
row.appendChild(actions);
}
return row;
}
async function appendZoneSequenceTiles(zoneId, zoneDoc, allPresets, paletteColors, presetsListEl) {
if (!presetsListEl || !zoneId) return;
const ids = [
...(Array.isArray(zoneDoc.sequence_ids) ? zoneDoc.sequence_ids.map((x) => String(x)) : []),
...(Array.isArray(zoneDoc.animation_ids) ? zoneDoc.animation_ids.map((x) => String(x)) : []),
];
if (!ids.length) return;
const sequences = await fetchSequencesMap();
const uiMode = typeof window.getPresetUiMode === 'function' ? window.getPresetUiMode() : 'run';
for (const sid of ids) {
const seq = sequences[sid];
if (!seq) continue;
const row = createSequenceTileRow(sid, seq, zoneId, zoneDoc, allPresets, uiMode);
presetsListEl.appendChild(row);
}
}
async function addSequenceToTab(sequenceId, zoneId) {
if (!zoneId) {
const leftPanel = document.querySelector('.presets-section[data-zone-id]');
zoneId = leftPanel ? leftPanel.dataset.zoneId : null;
}
if (!zoneId || !sequenceId) {
alert('Could not determine zone or sequence.');
return;
}
try {
const tabResponse = await fetch(`/zones/${zoneId}`, { headers: { Accept: 'application/json' } });
if (!tabResponse.ok) throw new Error('Failed to load zone');
const tabData = await tabResponse.json();
const seqs = await fetchSequencesMap();
const field = seqs[sequenceId] && seqs[sequenceId].kind === 'animation' ? 'animation_ids' : 'sequence_ids';
const list = Array.isArray(tabData[field]) ? tabData[field].map(String) : [];
if (list.includes(String(sequenceId))) {
alert('Already on this zone.');
return;
}
list.push(String(sequenceId));
tabData[field] = list;
const updateResponse = await fetch(`/zones/${zoneId}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(tabData),
});
if (!updateResponse.ok) throw new Error('Failed to update zone');
if (typeof window.renderTabPresets === 'function') {
await window.renderTabPresets(zoneId);
}
} catch (e) {
console.error('addSequenceToTab:', e);
alert('Failed to add sequence to zone.');
}
}
async function removeSequenceFromTab(zoneId, sequenceId) {
if (!zoneId || !sequenceId) return;
try {
const tabResponse = await fetch(`/zones/${zoneId}`, { headers: { Accept: 'application/json' } });
if (!tabResponse.ok) throw new Error('Failed to load zone');
const tabData = await tabResponse.json();
const list = Array.isArray(tabData.sequence_ids) ? tabData.sequence_ids.map(String) : [];
const alist = Array.isArray(tabData.animation_ids) ? tabData.animation_ids.map(String) : [];
const next = list.filter((x) => String(x) !== String(sequenceId));
const anext = alist.filter((x) => String(x) !== String(sequenceId));
if (next.length === list.length && anext.length === alist.length) {
alert('Not on this zone.');
return;
}
tabData.sequence_ids = next;
tabData.animation_ids = anext;
const updateResponse = await fetch(`/zones/${zoneId}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(tabData),
});
if (!updateResponse.ok) throw new Error('Failed to update zone');
if (typeof window.refreshEditTabSequencesUi === 'function') {
await window.refreshEditTabSequencesUi(zoneId);
}
if (typeof window.renderTabPresets === 'function') {
await window.renderTabPresets(zoneId);
}
} catch (e) {
console.error('removeSequenceFromTab:', e);
alert('Failed to remove sequence from zone.');
}
}
async function refreshEditTabSequencesUi(zoneId) {
const currentEl = document.getElementById('edit-zone-sequences-current');
const addEl = document.getElementById('edit-zone-sequences-list');
if (!currentEl || !addEl || !zoneId) return;
try {
const zoneRes = await fetch(`/zones/${zoneId}`, { headers: { Accept: 'application/json' } });
if (!zoneRes.ok) throw new Error('zone');
const zone = await zoneRes.json();
const onZone = [
...(Array.isArray(zone.sequence_ids) ? zone.sequence_ids.map(String) : []),
...(Array.isArray(zone.animation_ids) ? zone.animation_ids.map(String) : []),
];
const seqMap = await fetchSequencesMap();
const onSet = new Set(onZone);
currentEl.innerHTML = '';
if (!onZone.length) {
currentEl.innerHTML = '<span class="muted-text">No sequences on this zone yet.</span>';
} else {
for (const sid of onZone) {
const sdoc = seqMap[sid] || {};
const name = `${sdoc.kind === 'animation' ? '⚡ ' : ''}${sdoc.name || sid}`;
const row = document.createElement('div');
row.className = 'profiles-row edit-zone-item-row';
const span = document.createElement('span');
span.textContent = `${name} — ${sid}`;
const rm = document.createElement('button');
rm.type = 'button';
rm.className = 'btn btn-danger btn-small';
rm.textContent = 'Remove';
rm.addEventListener('click', async () => {
if (!window.confirm(`Remove this sequence from the zone?\n\n${name}`)) return;
await removeSequenceFromTab(zoneId, sid);
});
row.appendChild(span);
row.appendChild(rm);
currentEl.appendChild(row);
}
}
addEl.innerHTML = '';
const allIds = Object.keys(seqMap);
const available = allIds.filter((id) => !onSet.has(String(id)));
if (!available.length) {
addEl.innerHTML =
'<span class="muted-text">No sequences to add.</span>';
} else {
const wrap = document.createElement('div');
wrap.className = 'zone-devices-add profiles-actions';
const sel = document.createElement('select');
sel.className = 'zone-device-add-select';
sel.setAttribute('aria-label', 'Sequence to add to this zone');
sel.appendChild(new Option('Add sequence…', ''));
available
.slice()
.sort((a, b) => {
const na = (seqMap[a] && seqMap[a].name) || a;
const nb = (seqMap[b] && seqMap[b].name) || b;
return String(na).localeCompare(String(nb), undefined, { sensitivity: 'base' });
})
.forEach((id) => {
const n = (seqMap[id] && seqMap[id].name) || id;
const a = seqMap[id] && seqMap[id].kind === 'animation' ? '⚡ ' : '';
sel.appendChild(new Option(`${a}${n} — ${id}`, id));
});
const addBtn = document.createElement('button');
addBtn.type = 'button';
addBtn.className = 'btn btn-primary btn-small';
addBtn.textContent = 'Add';
addBtn.addEventListener('click', async () => {
const id = sel.value;
if (!id) return;
await addSequenceToTab(id, zoneId);
sel.value = '';
await refreshEditTabSequencesUi(zoneId);
});
wrap.appendChild(sel);
wrap.appendChild(addBtn);
addEl.appendChild(wrap);
}
} catch (e) {
console.error('refreshEditTabSequencesUi:', e);
currentEl.innerHTML = '<span class="muted-text">Failed to load sequences.</span>';
addEl.innerHTML = '';
}
}
let sequenceEditorId = null;
/** Insert point when dragging a step row vertically within a lane. */
function getDragAfterSequenceStepRow(container, y) {
const draggableElements = [
...container.querySelectorAll(':scope > .sequence-step-row:not(.dragging)'),
];
return draggableElements.reduce(
(closest, child) => {
const box = child.getBoundingClientRect();
const offset = y - box.top - box.height / 2;
if (offset < 0 && offset > closest.offset) {
return { offset, element: child };
}
return closest;
},
{ offset: Number.NEGATIVE_INFINITY, element: null },
).element;
}
/** Reorder step rows within one lane (DOM order = save order). */
function wireSequenceLaneStepsDragReorder(stepsHost) {
if (!stepsHost || stepsHost.dataset.sequenceLaneDndWired === '1') return;
stepsHost.dataset.sequenceLaneDndWired = '1';
let draggedRow = null;
stepsHost.addEventListener('dragstart', (e) => {
const handle = e.target.closest('.sequence-step-drag-handle');
if (!handle || !stepsHost.contains(handle)) return;
const row = handle.closest('.sequence-step-row');
if (!row || !stepsHost.contains(row)) return;
draggedRow = row;
row.classList.add('dragging');
try {
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/plain', 'sequence-step');
} catch (_) {
/* ignore */
}
});
stepsHost.addEventListener('dragend', () => {
if (draggedRow) draggedRow.classList.remove('dragging');
draggedRow = null;
});
stepsHost.addEventListener('dragenter', (e) => {
if (!draggedRow || !stepsHost.contains(draggedRow)) return;
e.preventDefault();
});
stepsHost.addEventListener('dragover', (e) => {
if (!draggedRow || !stepsHost.contains(draggedRow)) return;
e.preventDefault();
try {
e.dataTransfer.dropEffect = 'move';
} catch (_) {
/* ignore */
}
const afterElement = getDragAfterSequenceStepRow(stepsHost, e.clientY);
if (afterElement == null) {
stepsHost.appendChild(draggedRow);
} else if (afterElement !== draggedRow) {
stepsHost.insertBefore(draggedRow, afterElement);
}
});
stepsHost.addEventListener('drop', (e) => {
if (!draggedRow) return;
e.preventDefault();
});
}
/* ------------------------------------------------------------------ editor
* Sequence editor state: the sequence's targets (an ordered driver list: groups and/or single drivers),
* the presets and animations steps can play, and the groups/devices targets can name. Targets keep a
* local uid while editing; lanes and steps store the uids and save them as indexes.
*/
const seqEd = {
targets: [], // [{uid, name, group_ids: [], devices: []}]
presetsMap: {},
groupsMap: {},
devicesMap: {},
seqMap: {},
zoneGroupIds: [],
nextUid: 1,
};
const LANES_MAX_UI = 16;
function seqEdTargetLabel(t, i) {
const n = t && t.name ? String(t.name).trim() : '';
return n || `Target ${i + 1}`;
}
/** Checkbox chips, one per target; `selected` is a set of uids. */
function renderTargetChips(host, selected, cls) {
host.innerHTML = '';
host.dataset.chipClass = cls;
if (!seqEd.targets.length) {
const m = document.createElement('span');
m.className = 'muted-text';
m.textContent = 'No targets yet (add them above).';
host.appendChild(m);
return;
}
seqEd.targets.forEach((t, i) => {
const lbl = document.createElement('label');
lbl.className = 'seq-chip';
const cb = document.createElement('input');
cb.type = 'checkbox';
cb.className = cls;
cb.value = String(t.uid);
cb.checked = selected.has(String(t.uid));
const sp = document.createElement('span');
sp.textContent = seqEdTargetLabel(t, i);
lbl.appendChild(cb);
lbl.appendChild(sp);
host.appendChild(lbl);
});
}
function chipSelection(host) {
const out = new Set();
if (!host) return out;
host.querySelectorAll('input[type=checkbox]:checked').forEach((c) => out.add(String(c.value)));
return out;
}
/** Re-render every chip row after targets were added, renamed, moved or removed (keeping selections). */
function refreshAllTargetChips() {
document.querySelectorAll('#sequence-editor-modal .seq-target-chips').forEach((host) => {
renderTargetChips(host, chipSelection(host), host.dataset.chipClass || 'seq-chip-cb');
});
document.querySelectorAll('#sequence-editor-lanes .sequence-lane').forEach((laneEl) => {
const legacy = laneEl.querySelector('.sequence-lane-groups-wrap');
if (legacy) legacy.style.display = seqEd.targets.length ? 'none' : '';
});
renderSequenceGrid();
}
function renderTargetsPanel() {
const host = document.getElementById('sequence-editor-targets');
if (!host) return;
host.innerHTML = '';
seqEd.targets.forEach((t, i) => {
const row = document.createElement('div');
row.className = 'seq-target-row profiles-row';
const num = document.createElement('span');
num.className = 'seq-target-num';
num.textContent = String(i + 1);
const name = document.createElement('input');
name.type = 'text';
name.placeholder = `Target ${i + 1}`;
name.value = t.name || '';
name.addEventListener('input', () => {
t.name = name.value;
refreshAllTargetChips();
});
const det = document.createElement('details');
const sum = document.createElement('summary');
const what = () => {
const g = t.group_ids.map((id) => (seqEd.groupsMap[id] && seqEd.groupsMap[id].name) || id);
const d = t.devices.map((m) => (seqEd.devicesMap[m] && seqEd.devicesMap[m].name) || m);
const all = [...g, ...d];
return all.length ? all.join(', ') : 'Nothing picked';
};
sum.textContent = what();
det.appendChild(sum);
const pick = document.createElement('div');
pick.className = 'seq-target-pick';
const addBox = (label, list, value) => {
const l = document.createElement('label');
l.className = 'seq-chip';
const cb = document.createElement('input');
cb.type = 'checkbox';
cb.checked = list.includes(value);
cb.addEventListener('change', () => {
const at = list.indexOf(value);
if (cb.checked && at < 0) list.push(value);
if (!cb.checked && at >= 0) list.splice(at, 1);
sum.textContent = what();
});
const sp = document.createElement('span');
sp.textContent = label;
l.appendChild(cb);
l.appendChild(sp);
pick.appendChild(l);
};
const gh = document.createElement('div');
gh.className = 'muted-text';
gh.textContent = 'Groups';
pick.appendChild(gh);
Object.keys(seqEd.groupsMap)
.sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))
.forEach((gid) => addBox(`${(seqEd.groupsMap[gid] && seqEd.groupsMap[gid].name) || gid}`, t.group_ids, gid));
const dh = document.createElement('div');
dh.className = 'muted-text';
dh.textContent = 'Single drivers';
pick.appendChild(dh);
Object.keys(seqEd.devicesMap)
.sort((a, b) => String((seqEd.devicesMap[a] || {}).name || a).localeCompare(String((seqEd.devicesMap[b] || {}).name || b)))
.forEach((mac) => addBox(`${(seqEd.devicesMap[mac] && seqEd.devicesMap[mac].name) || mac}`, t.devices, mac));
det.appendChild(pick);
const btns = document.createElement('div');
btns.className = 'seq-target-btns';
const mk = (txt, title, fn, disabled) => {
const b = document.createElement('button');
b.type = 'button';
b.className = 'btn btn-secondary btn-small';
b.textContent = txt;
b.title = title;
b.disabled = !!disabled;
b.addEventListener('click', fn);
btns.appendChild(b);
return b;
};
mk('↑', 'Move up', () => {
seqEd.targets.splice(i - 1, 0, seqEd.targets.splice(i, 1)[0]);
renderTargetsPanel();
}, i === 0);
mk('↓', 'Move down', () => {
seqEd.targets.splice(i + 1, 0, seqEd.targets.splice(i, 1)[0]);
renderTargetsPanel();
}, i === seqEd.targets.length - 1);
const rm = mk('Remove', 'Remove target', () => {
seqEd.targets.splice(i, 1);
renderTargetsPanel();
});
rm.className = 'btn btn-danger btn-small';
row.appendChild(num);
row.appendChild(name);
row.appendChild(det);
row.appendChild(btns);
host.appendChild(row);
});
refreshAllTargetChips();
}
function addSeqTarget(t) {
if (seqEd.targets.length >= 32) {
alert('A sequence can have up to 32 targets.');
return false;
}
seqEd.targets.push({ uid: seqEd.nextUid++, name: '', group_ids: [], devices: [], ...t });
return true;
}
/** One target per driver in the current zone's groups, in device-list order (for chases). */
function addTargetsPerDriver() {
const macs = [];
const gids = seqEd.zoneGroupIds.length ? seqEd.zoneGroupIds : Object.keys(seqEd.groupsMap);
gids.forEach((gid) => {
const g = seqEd.groupsMap[gid];
(g && Array.isArray(g.devices) ? g.devices : []).forEach((m) => {
const mac = String(m).toLowerCase().replace(/[^0-9a-f]/g, '');
if (mac.length === 12 && !macs.includes(mac)) macs.push(mac);
});
});
if (!macs.length) {
alert('No drivers found in this zone\'s groups.');
return;
}
const have = new Set(seqEd.targets.filter((t) => t.devices.length === 1 && !t.group_ids.length).map((t) => t.devices[0]));
macs.forEach((mac) => {
if (have.has(mac)) return;
const d = seqEd.devicesMap[mac];
addSeqTarget({ name: (d && d.name) || mac, devices: [mac] });
});
renderTargetsPanel();
}
/** Step "what plays" picker: presets, animations, or a rest. Values: p:<id>, a:<id>, rest. */
function buildStepPlaySelect(step) {
const sel = document.createElement('select');
sel.className = 'sequence-step-preset zone-device-add-select';
sel.appendChild(new Option('Select…', ''));
sel.appendChild(new Option('— Rest (off) —', 'rest'));
const byName = (map) => (a, b) =>
String((map[a] && map[a].name) || a).localeCompare(String((map[b] && map[b].name) || b), undefined, { sensitivity: 'base' });
const pg = document.createElement('optgroup');
pg.label = 'Presets';
Object.keys(seqEd.presetsMap)
.sort(byName(seqEd.presetsMap))
.forEach((pid) => pg.appendChild(new Option(`${(seqEd.presetsMap[pid] && seqEd.presetsMap[pid].name) || pid}`, `p:${pid}`)));
sel.appendChild(pg);
const anims = Object.keys(seqEd.seqMap).filter((id) => seqEd.seqMap[id] && seqEd.seqMap[id].kind === 'animation' && id !== sequenceEditorId);
if (anims.length) {
const ag = document.createElement('optgroup');
ag.label = 'Animations';
anims.sort(byName(seqEd.seqMap)).forEach((id) => ag.appendChild(new Option(`⚡ ${seqEd.seqMap[id].name || id}`, `a:${id}`)));
sel.appendChild(ag);
}
if (step && step.rest) sel.value = 'rest';
else if (step && step.animation_id) sel.value = `a:${step.animation_id}`;
else if (step && step.preset_id) sel.value = `p:${step.preset_id}`;
return sel;
}
function renderSequenceStepRow(presetsMap, step) {
const row = document.createElement('div');
row.className = 'sequence-step-row profiles-row';
row.style.cssText =
'display:flex;flex-direction:column;gap:0.35rem;margin-bottom:0.75rem;padding:0.5rem;border:1px solid rgba(255,255,255,0.12);border-radius:6px;';
const top = document.createElement('div');
top.style.cssText = 'display:flex;align-items:center;gap:0.75rem;flex-wrap:wrap;';
const dragHandle = document.createElement('span');
dragHandle.className = 'sequence-step-drag-handle';
dragHandle.draggable = true;
dragHandle.title = 'Drag to reorder';
dragHandle.textContent = '⠿';
dragHandle.style.cssText =
'cursor:grab;user-select:none;flex-shrink:0;line-height:1;opacity:0.75;padding:0.15rem 0.25rem;';
const presetWrap = document.createElement('div');
presetWrap.style.cssText = 'display:flex;align-items:center;gap:0.5rem;flex-wrap:wrap;';
const pl = document.createElement('label');
pl.textContent = 'Plays';
const psel = buildStepPlaySelect(step);
presetWrap.appendChild(pl);
presetWrap.appendChild(psel);
const beatWrap = document.createElement('div');
beatWrap.style.cssText = 'display:flex;align-items:center;gap:0.35rem;';
const bl = document.createElement('label');
bl.textContent = 'Beats';
const beatsInp = document.createElement('input');
beatsInp.type = 'number';
beatsInp.className = 'sequence-step-beats';
beatsInp.autocomplete = 'off';
beatsInp.min = '0.25';
beatsInp.max = '256';
beatsInp.step = '0.25';
beatsInp.value = String(step && step.beats != null ? Math.max(0.25, parseFloat(String(step.beats)) || 1) : 1);
beatsInp.style.width = '4.5rem';
beatWrap.appendChild(bl);
beatWrap.appendChild(beatsInp);
beatWrap.classList.add('sequence-step-beats-wrap');
const secWrap = document.createElement('div');
secWrap.className = 'sequence-step-seconds-wrap';
secWrap.style.cssText = 'display:flex;align-items:center;gap:0.35rem;';
const sl = document.createElement('label');
sl.textContent = 'Seconds';
const secInp = document.createElement('input');
secInp.type = 'number';
secInp.className = 'sequence-step-seconds';
secInp.autocomplete = 'off';
secInp.min = '0.1';
secInp.max = '3600';
secInp.step = '0.1';
secInp.value = String(step && step.seconds != null ? Math.max(0.1, parseFloat(String(step.seconds)) || 3) : 3);
secInp.style.width = '5rem';
secWrap.appendChild(sl);
secWrap.appendChild(secInp);
const editPresetBtn = document.createElement('button');
editPresetBtn.type = 'button';
editPresetBtn.className = 'btn btn-secondary btn-small';
editPresetBtn.textContent = 'Edit';
editPresetBtn.title = 'Edit the preset or animation';
editPresetBtn.addEventListener('click', async (e) => {
e.preventDefault();
const v = psel.value || '';
if (v.startsWith('a:')) {
openSequenceEditor(v.slice(2), seqEd.seqMap[v.slice(2)]);
return;
}
const presetId = v.startsWith('p:') ? v.slice(2) : '';
if (!presetId) {
alert('Select a preset first.');
return;
}
let preset = presetsMap[presetId];
try {
const r = await fetch(`/presets/${presetId}`, { headers: { Accept: 'application/json' } });
if (r.ok) preset = await r.json();
} catch (_) {
/* keep cached */
}
preset = preset && typeof preset === 'object' ? preset : {};
document.dispatchEvent(
new CustomEvent('editPreset', {
detail: { presetId, preset, zoneId: null },
}),
);
});
top.appendChild(dragHandle);
top.appendChild(presetWrap);
top.appendChild(beatWrap);
top.appendChild(secWrap);
top.appendChild(editPresetBtn);
row.appendChild(top);
// More: which targets this step lights, others off, animation length
const more = document.createElement('details');
more.className = 'seq-step-more';
const ms = document.createElement('summary');
ms.textContent = 'Targets and options';
more.appendChild(ms);
const chips = document.createElement('div');
chips.className = 'seq-target-chips seq-step-targets';
const stepSel = new Set();
(step && Array.isArray(step.targets) ? step.targets : []).forEach((ix) => {
if (seqEd.targets[ix]) stepSel.add(String(seqEd.targets[ix].uid));
});
if (step && step._uids) step._uids.forEach((u) => stepSel.add(String(u)));
renderTargetChips(chips, stepSel, 'seq-step-target');
const chipsHint = document.createElement('div');
chipsHint.className = 'muted-text';
chipsHint.textContent = 'Lights only these (none ticked: all of the lane\'s targets, or the chase).';
more.appendChild(chipsHint);
more.appendChild(chips);
const opts = document.createElement('div');
opts.style.cssText = 'display:flex;gap:1rem;flex-wrap:wrap;margin-top:0.35rem;';
const othersLbl = document.createElement('label');
const othersCb = document.createElement('input');
othersCb.type = 'checkbox';
othersCb.className = 'sequence-step-others-off';
othersCb.checked = !!(step && step.others === 'off');
othersLbl.appendChild(othersCb);
othersLbl.appendChild(document.createTextNode(' Lane\'s other targets off'));
const lenLbl = document.createElement('label');
lenLbl.className = 'sequence-step-length-wrap';
const lenCb = document.createElement('input');
lenCb.type = 'checkbox';
lenCb.className = 'sequence-step-anim-length';
lenCb.checked = !step || step.length === 'animation' || !step.animation_id;
lenLbl.appendChild(lenCb);
lenLbl.appendChild(document.createTextNode(' Step lasts as long as the animation'));
opts.appendChild(othersLbl);
opts.appendChild(lenLbl);
more.appendChild(opts);
if (stepSel.size || othersCb.checked) more.open = true;
row.appendChild(more);
const syncKind = () => {
const v = psel.value || '';
const anim = v.startsWith('a:');
lenLbl.style.display = anim ? '' : 'none';
editPresetBtn.disabled = !(anim || v.startsWith('p:'));
renderSequenceGrid();
};
psel.addEventListener('change', syncKind);
beatsInp.addEventListener('input', () => renderSequenceGrid());
secInp.addEventListener('input', () => renderSequenceGrid());
syncKind();
const rm = document.createElement('button');
rm.type = 'button';
rm.className = 'btn btn-danger btn-small';
rm.textContent = 'Remove step';
rm.addEventListener('click', () => {
row.remove();
renderSequenceGrid();
});
row.appendChild(rm);
return row;
}
function laneOptsField(label, input) {
const l = document.createElement('label');
l.className = 'seq-lane-opt';
const sp = document.createElement('span');
sp.textContent = label;
l.appendChild(sp);
l.appendChild(input);
return l;
}
function renderLaneOptions(opts) {
const o = opts && typeof opts === 'object' ? opts : {};
const box = document.createElement('div');
box.className = 'seq-lane-opts';
const mode = document.createElement('select');
mode.className = 'seq-lane-mode zone-device-add-select';
[['', 'Sequence default'], ['beats', 'Beats'], ['time', 'Seconds']].forEach(([v, t]) => mode.appendChild(new Option(t, v)));
mode.value = o.mode === 'beats' || o.mode === 'time' ? o.mode : '';
mode.addEventListener('change', applySequenceEditorMode);
const offset = document.createElement('input');
offset.type = 'number';
offset.className = 'seq-lane-offset';
offset.min = '0';
offset.step = '0.25';
offset.value = String(Math.max(0, parseFloat(String(o.offset || 0)) || 0));
offset.style.width = '4.5rem';
offset.title = 'Beats (or seconds) before this lane starts';
const rate = document.createElement('select');
rate.className = 'seq-lane-rate zone-device-add-select';
[['0.25', '¼×'], ['0.5', '½×'], ['1', '1×'], ['2', '2×'], ['4', '4×']].forEach(([v, t]) => rate.appendChild(new Option(t, v)));
rate.value = String(o.rate || 1);
if (!rate.value) rate.value = '1';
box.appendChild(laneOptsField('Timing', mode));
box.appendChild(laneOptsField('Start after', offset));
box.appendChild(laneOptsField('Speed', rate));
const tLbl = document.createElement('div');
tLbl.className = 'muted-text';
tLbl.textContent = 'Plays to';
const chips = document.createElement('div');
chips.className = 'seq-target-chips seq-lane-targets';
const sel = new Set();
(Array.isArray(o.targets) ? o.targets : []).forEach((ix) => {
if (seqEd.targets[ix]) sel.add(String(seqEd.targets[ix].uid));
});
renderTargetChips(chips, sel, 'seq-lane-target');
chips.addEventListener('change', () => renderSequenceGrid());
const chase = o.chase && typeof o.chase === 'object' ? o.chase : null;
const chaseRow = document.createElement('div');
chaseRow.className = 'seq-lane-chase';
const chaseCb = document.createElement('input');
chaseCb.type = 'checkbox';
chaseCb.className = 'seq-lane-chase-on';
chaseCb.checked = !!chase;
const chaseLbl = document.createElement('label');
chaseLbl.appendChild(chaseCb);
chaseLbl.appendChild(document.createTextNode(' Chase: each step moves to the next target'));
const order = document.createElement('select');
order.className = 'seq-lane-chase-order zone-device-add-select';
[['forward', 'Forward'], ['reverse', 'Reverse'], ['bounce', 'Bounce'], ['random', 'Random']].forEach(([v, t]) => order.appendChild(new Option(t, v)));
order.value = (chase && chase.order) || 'forward';
const width = document.createElement('input');
width.type = 'number';
width.className = 'seq-lane-chase-width';
width.min = '1';
width.max = '32';
width.value = String((chase && chase.width) || 1);
width.style.width = '3.5rem';
width.title = 'How many targets are lit at once';
const others = document.createElement('select');
others.className = 'seq-lane-chase-others zone-device-add-select';
[['off', 'Others off'], ['hold', 'Others hold']].forEach(([v, t]) => others.appendChild(new Option(t, v)));
others.value = chase && chase.others === 'hold' ? 'hold' : 'off';
const chaseOpts = document.createElement('span');
chaseOpts.className = 'seq-lane-chase-opts';
chaseOpts.appendChild(order);
chaseOpts.appendChild(laneOptsField('Width', width));
chaseOpts.appendChild(others);
const syncChase = () => {
chaseOpts.style.display = chaseCb.checked ? '' : 'none';
};
chaseCb.addEventListener('change', syncChase);
syncChase();
chaseRow.appendChild(chaseLbl);
chaseRow.appendChild(chaseOpts);
box.appendChild(tLbl);
box.appendChild(chips);
box.appendChild(chaseRow);
return box;
}
function renderSequenceLane(laneIndex, laneSteps, laneGroupIds, presetsMap, groupsMap, zoneGroupIds, laneOpts) {
const wrap = document.createElement('div');
wrap.className = 'sequence-lane';
wrap.dataset.laneIndex = String(laneIndex);
const head = document.createElement('div');
head.style.cssText =
'display:flex;align-items:center;justify-content:space-between;gap:0.5rem;margin-bottom:0.5rem;flex-wrap:wrap;';
const title = document.createElement('strong');
title.textContent = `Lane ${laneIndex + 1}`;
head.appendChild(title);
const headBtns = document.createElement('div');
headBtns.style.cssText = 'display:flex;gap:0.35rem;flex-wrap:wrap;';
const addStep = document.createElement('button');
addStep.type = 'button';
addStep.className = 'btn btn-secondary btn-small';
addStep.textContent = 'Add step';
addStep.addEventListener('click', () => {
const stepsHost = wrap.querySelector('.sequence-lane-steps');
if (stepsHost) {
stepsHost.appendChild(renderSequenceStepRow(presetsMap, { preset_id: '', beats: 1, seconds: 3 }));
applySequenceEditorMode();
}
});
const dupLane = document.createElement('button');
dupLane.type = 'button';
dupLane.className = 'btn btn-secondary btn-small';
dupLane.textContent = 'Duplicate';
dupLane.title = 'Copy this lane (then give the copy an offset for a canon)';
dupLane.addEventListener('click', () => {
const host = document.getElementById('sequence-editor-lanes');
if (!host || host.querySelectorAll('.sequence-lane').length >= LANES_MAX_UI) {
alert(`A sequence can have up to ${LANES_MAX_UI} lanes.`);
return;
}
const data = collectLaneFromEl(wrap);
const copy = renderSequenceLane(0, data.steps.map((s) => ({ ...s, _uids: s._uids })), data.groups, presetsMap, groupsMap, zoneGroupIds, data.optsUi);
wrap.after(copy);
refreshSequenceEditorLaneTitles();
applySequenceEditorMode();
});
const rmLane = document.createElement('button');
rmLane.type = 'button';
rmLane.className = 'btn btn-danger btn-small sequence-lane-remove-lane';
rmLane.textContent = 'Remove lane';
rmLane.addEventListener('click', () => {
const host = document.getElementById('sequence-editor-lanes');
const n = host ? host.querySelectorAll('.sequence-lane').length : 1;
if (n <= 1) return;
wrap.remove();
refreshSequenceEditorLaneTitles();
});
headBtns.appendChild(addStep);
headBtns.appendChild(dupLane);
headBtns.appendChild(rmLane);
head.appendChild(headBtns);
wrap.appendChild(head);
wrap.appendChild(renderLaneOptions(laneOpts));
// Older sequences: groups per lane, shown while the sequence has no targets
const legacy = renderLaneGroupCheckboxes(groupsMap, laneGroupIds, zoneGroupIds);
if (seqEd.targets.length) legacy.style.display = 'none';
wrap.appendChild(legacy);
const stepsHost = document.createElement('div');
stepsHost.className = 'sequence-lane-steps';
const steps = Array.isArray(laneSteps) && laneSteps.length ? laneSteps : [{ preset_id: '', beats: 1, seconds: 3 }];
steps.forEach((s) => {
stepsHost.appendChild(renderSequenceStepRow(presetsMap, s));
});
wireSequenceLaneStepsDragReorder(stepsHost);
stepsHost.addEventListener('drop', () => setTimeout(renderSequenceGrid, 0));
wrap.appendChild(stepsHost);
return wrap;
}
function refreshSequenceEditorLaneTitles() {
const host = document.getElementById('sequence-editor-lanes');
if (!host) return;
const lanes = [...host.querySelectorAll('.sequence-lane')];
lanes.forEach((el, i) => {
el.dataset.laneIndex = String(i);
const t = el.querySelector(':scope > div strong');
if (t) t.textContent = `Lane ${i + 1}`;
const rm = el.querySelector('.sequence-lane-remove-lane');
if (rm) rm.disabled = lanes.length <= 1;
});
const add = document.getElementById('sequence-editor-add-lane-btn');
if (add) add.disabled = lanes.length >= LANES_MAX_UI;
renderSequenceGrid();
}
function laneIsTimed(laneEl) {
const sel = document.getElementById('sequence-editor-mode');
const def = !!sel && sel.value === 'time';
const m = laneEl.querySelector('.seq-lane-mode');
return m && m.value ? m.value === 'time' : def;
}
/** Show the Beats or Seconds field on every step, to match its lane's timing. */
function applySequenceEditorMode() {
document.querySelectorAll('#sequence-editor-lanes .sequence-lane').forEach((laneEl) => {
const timed = laneIsTimed(laneEl);
laneEl.querySelectorAll('.sequence-step-beats-wrap').forEach((e) => {
e.style.display = timed ? 'none' : 'flex';
});
laneEl.querySelectorAll('.sequence-step-seconds-wrap').forEach((e) => {
e.style.display = timed ? 'flex' : 'none';
});
const off = laneEl.querySelector('.seq-lane-offset');
if (off) off.title = timed ? 'Seconds before this lane starts' : 'Beats before this lane starts';
});
renderSequenceGrid();
}
function uidsToIndexes(uids) {
const out = [];
seqEd.targets.forEach((t, i) => {
if (uids.has(String(t.uid))) out.push(i);
});
return out;
}
/** One lane from the editor: its steps (saved form), legacy groups and options. */
function collectLaneFromEl(laneEl) {
const groups = [];
laneEl.querySelectorAll('.sequence-lane-group:checked').forEach((c) => {
if (c.value) groups.push(String(c.value));
});
const steps = [];
const stepsHost = laneEl.querySelector('.sequence-lane-steps');
const rows = stepsHost ? stepsHost.querySelectorAll(':scope > .sequence-step-row') : [];
rows.forEach((row) => {
const v = (row.querySelector('.sequence-step-preset') || {}).value || '';
if (!v) return;
const beatsInp = row.querySelector('.sequence-step-beats');
const secInp = row.querySelector('.sequence-step-seconds');
const beats = Math.max(0.25, parseFloat(beatsInp && beatsInp.value ? beatsInp.value : '1') || 1);
const seconds = Math.max(0.1, parseFloat(secInp && secInp.value ? secInp.value : '3') || 3);
const st = { beats, seconds };
if (v === 'rest') {
st.preset_id = '';
st.rest = true;
} else if (v.startsWith('a:')) {
st.animation_id = v.slice(2);
const len = row.querySelector('.sequence-step-anim-length');
if (len && len.checked) st.length = 'animation';
} else {
st.preset_id = v.slice(2);
}
const uids = chipSelection(row.querySelector('.seq-step-targets'));
if (uids.size) {
st.targets = uidsToIndexes(uids);
st._uids = [...uids];
}
const oo = row.querySelector('.sequence-step-others-off');
if (oo && oo.checked) st.others = 'off';
st._row = row;
steps.push(st);
});
const q = (c) => laneEl.querySelector(c);
const laneUids = chipSelection(q('.seq-lane-targets'));
const opts = {};
const mode = q('.seq-lane-mode');
if (mode && mode.value) opts.mode = mode.value;
const off = parseFloat((q('.seq-lane-offset') || {}).value || '0') || 0;
if (off > 0) opts.offset = off;
const rate = parseFloat((q('.seq-lane-rate') || {}).value || '1') || 1;
if (rate !== 1) opts.rate = rate;
if (laneUids.size) opts.targets = uidsToIndexes(laneUids);
const chaseOn = q('.seq-lane-chase-on');
if (chaseOn && chaseOn.checked) {
opts.chase = {
order: (q('.seq-lane-chase-order') || {}).value || 'forward',
width: Math.max(1, parseInt((q('.seq-lane-chase-width') || {}).value || '1', 10) || 1),
others: (q('.seq-lane-chase-others') || {}).value === 'hold' ? 'hold' : 'off',
};
}
return { steps, groups, opts, optsUi: { ...opts }, timed: laneIsTimed(laneEl) };
}
function collectLanesFromEditor() {
const host = document.getElementById('sequence-editor-lanes');
const laneEls = host ? [...host.querySelectorAll('.sequence-lane')] : [];
const lanes = [];
const lanes_group_ids = [];
const lane_opts = [];
laneEls.forEach((laneEl) => {
const l = collectLaneFromEl(laneEl);
lanes.push(l.steps.map(({ _row, _uids, ...st }) => st));
lanes_group_ids.push(l.groups);
lane_opts.push(l.opts);
});
return { lanes, lanes_group_ids, lane_opts };
}
/* -------------------------------------------------------------- grid view */
let seqGridTimer = null;
function seqStepLabel(st) {
if (st.rest) return { text: 'rest', color: '' };
if (st.animation_id) {
const a = seqEd.seqMap[st.animation_id];
return { text: `⚡ ${(a && a.name) || st.animation_id}`, color: '' };
}
const p = seqEd.presetsMap[st.preset_id];
const colors = p && Array.isArray(p.colors) ? p.colors : [];
return { text: (p && p.name) || st.preset_id, color: colors[0] || '' };
}
/** Lanes side by side on a shared time axis: one row per lane, cells as wide as their steps. */
function renderSequenceGrid() {
const host = document.getElementById('sequence-editor-grid');
if (!host || host.hidden) return;
const laneHost = document.getElementById('sequence-editor-lanes');
const laneEls = laneHost ? [...laneHost.querySelectorAll('.sequence-lane')] : [];
host.innerHTML = '';
const bpm = parseFloat((document.getElementById('audio-simulated-bpm') || {}).value || '120') || 120;
const beatS = 60 / bpm;
const rows = laneEls.map((el) => collectLaneFromEl(el));
// Lengths in beats (time lanes converted at the clock tempo)
const len = (l, st) => (l.timed ? st.seconds / beatS : st.beats) / (l.opts.rate || 1);
const offs = (l) => (l.opts.offset || 0) / (l.timed ? beatS : 1);
const total = Math.max(4, ...rows.map((l) => offs(l) + l.steps.reduce((a, st) => a + len(l, st), 0)));
const scale = 100 / total;
rows.forEach((l, li) => {
const row = document.createElement('div');
row.className = 'seq-grid-row';
const name = document.createElement('div');
name.className = 'seq-grid-lane';
const tnames = (l.opts.targets || []).map((i) => seqEdTargetLabel(seqEd.targets[i], i));
name.textContent = `${li + 1}${l.opts.chase ? ' ⇢' : ''}`;
name.title = tnames.length ? tnames.join(', ') : 'Lane groups / zone';
const track = document.createElement('div');
track.className = 'seq-grid-track';
if (offs(l) > 0) {
const gap = document.createElement('div');
gap.className = 'seq-grid-cell seq-grid-gap';
gap.style.width = `${offs(l) * scale}%`;
track.appendChild(gap);
}
l.steps.forEach((st, si) => {
const cell = document.createElement('button');
cell.type = 'button';
cell.className = 'seq-grid-cell';
cell.dataset.lane = String(li);
cell.dataset.step = String(si);
cell.style.width = `${len(l, st) * scale}%`;
const lab = seqStepLabel(st);
cell.textContent = lab.text;
if (st.rest) cell.classList.add('seq-grid-rest');
if (st.animation_id) cell.classList.add('seq-grid-anim');
if (lab.color) cell.style.setProperty('--cell-color', lab.color);
cell.title = `${lab.text} — ${l.timed ? `${st.seconds}s` : `${st.beats} beat(s)`}${st.targets ? ` → ${st.targets.map((i) => seqEdTargetLabel(seqEd.targets[i], i)).join(', ')}` : ''}`;
cell.addEventListener('click', () => {
// Swap the cell for the step's own picker, so changes land on the step
const sel = buildStepPlaySelect(st);
sel.className = 'seq-grid-pick';
cell.replaceWith(sel);
sel.style.width = cell.style.width;
sel.focus();
const done = () => {
const src = st._row && st._row.querySelector('.sequence-step-preset');
if (src && sel.value && src.value !== sel.value) {
src.value = sel.value;
src.dispatchEvent(new Event('change'));
} else {
renderSequenceGrid();
}
};
sel.addEventListener('change', done);
sel.addEventListener('blur', () => setTimeout(renderSequenceGrid, 0));
});
track.appendChild(cell);
});
row.appendChild(name);
row.appendChild(track);
host.appendChild(row);
});
const axis = document.createElement('div');
axis.className = 'muted-text seq-grid-axis';
axis.textContent = `${Math.round(total * 100) / 100} beats per pass (seconds shown at ${bpm} BPM)`;
host.appendChild(axis);
}
/** Highlight the playing steps in the grid while this sequence (or animation) plays. */
async function pollSequenceGridPlayhead() {
const host = document.getElementById('sequence-editor-grid');
const modal = document.getElementById('sequence-editor-modal');
if (!host || host.hidden || !modal || !modal.classList.contains('active') || !sequenceEditorId) {
seqGridTimer = null;
return;
}
try {
const r = await fetch('/sequences/status', { cache: 'no-store', headers: { Accept: 'application/json' } });
const st = r.ok ? await r.json() : null;
let lanes = null;
if (st && st.active && String(st.sequence_id) === sequenceEditorId) lanes = st.lanes;
else if (st && st.overlay && st.overlay.active && String(st.overlay.sequence_id) === sequenceEditorId) lanes = st.overlay.lanes;
host.querySelectorAll('.seq-grid-cell.playing').forEach((c) => c.classList.remove('playing'));
(Array.isArray(lanes) ? lanes : []).forEach((l, li) => {
if (!l || !l.started || l.done) return;
const c = host.querySelector(`.seq-grid-cell[data-lane="${li}"][data-step="${l.step}"]`);
if (c) c.classList.add('playing');
});
} catch (_) {
/* try again */
}
seqGridTimer = setTimeout(pollSequenceGridPlayhead, 400);
}
function setSequenceEditorView(grid) {
const g = document.getElementById('sequence-editor-grid');
const btn = document.getElementById('sequence-editor-view-btn');
if (!g) return;
g.hidden = !grid;
if (btn) btn.textContent = grid ? 'Hide grid' : 'Show grid';
try {
localStorage.setItem('seqEditorGrid', grid ? '1' : '0');
} catch (_) {
/* private mode */
}
if (grid) {
renderSequenceGrid();
if (!seqGridTimer) pollSequenceGridPlayhead();
}
}
function applySequenceKindUi() {
const kind = document.getElementById('sequence-editor-kind');
const anim = !!kind && kind.value === 'animation';
const hint = document.getElementById('sequence-editor-kind-hint');
if (hint) {
hint.textContent = anim
? 'An animation plays once over whatever is running, then the drivers go back to it. Fire it from a zone tile or from a step of a sequence.'
: 'A sequence plays in a zone, looping unless Loop is off.';
}
}
async function openSequenceEditor(sequenceId, existing) {
sequenceEditorId = sequenceId != null && String(sequenceId).length ? String(sequenceId) : null;
const modal = document.getElementById('sequence-editor-modal');
const nameInput = document.getElementById('sequence-editor-name');
const lanesHost = document.getElementById('sequence-editor-lanes');
if (!modal || !nameInput || !lanesHost) return;
const [presetsRes, groupsMap, devicesRes, seqMap] = await Promise.all([
fetch('/presets', { headers: { Accept: 'application/json' } }),
fetchGroupsMapSeq(),
fetch('/devices', { headers: { Accept: 'application/json' } }).catch(() => null),
fetchSequencesMap(),
]);
const presetsMap = presetsRes.ok ? await presetsRes.json() : {};
let devicesMap = {};
if (devicesRes && devicesRes.ok) {
const d = await devicesRes.json().catch(() => ({}));
devicesMap = d && typeof d === 'object' ? d : {};
}
let zoneDoc = {};
const zoneIdForEditor = resolveZoneIdForPresetStripRefresh();
if (zoneIdForEditor) {
try {
const zr = await fetch(`/zones/${encodeURIComponent(zoneIdForEditor)}`, {
headers: { Accept: 'application/json' },
credentials: 'same-origin',
});
if (zr.ok) {
const zj = await zr.json();
if (zj && typeof zj === 'object' && !zj.error) zoneDoc = zj;
}
} catch (_) {
/* no zone context */
}
}
const zoneGroupIds = zoneGroupIdsFromDoc(zoneDoc);
let doc = existing;
if (sequenceEditorId) {
try {
const r = await fetch(`/sequences/${encodeURIComponent(sequenceEditorId)}`, {
cache: 'no-store',
headers: { Accept: 'application/json' },
credentials: 'same-origin',
});
if (r.ok) {
const j = await r.json();
if (j && typeof j === 'object' && !j.error) {
doc = j;
}
}
} catch (_) {
/* keep existing */
}
}
if (!doc || typeof doc !== 'object') {
doc = {};
}
seqEd.presetsMap = presetsMap;
seqEd.groupsMap = groupsMap;
seqEd.devicesMap = devicesMap;
seqEd.seqMap = seqMap;
seqEd.zoneGroupIds = zoneGroupIds;
seqEd.targets = [];
(Array.isArray(doc.targets) ? doc.targets : []).forEach((t) =>
addSeqTarget({
name: t && t.name ? String(t.name) : '',
group_ids: Array.isArray(t && t.group_ids) ? t.group_ids.map(String) : [],
devices: Array.isArray(t && t.devices) ? t.devices.map((m) => String(m).toLowerCase()) : [],
}),
);
nameInput.value = doc.name || '';
const modeSelOpen = document.getElementById('sequence-editor-mode');
if (modeSelOpen) modeSelOpen.value = doc.advance_mode === 'time' ? 'time' : 'beats';
const kindSel = document.getElementById('sequence-editor-kind');
const isAnim = doc.kind === 'animation' || (!sequenceEditorId && seqEditorNewKind === 'animation');
if (kindSel) kindSel.value = isAnim ? 'animation' : 'sequence';
const loopCb = document.getElementById('sequence-editor-loop');
if (loopCb) loopCb.checked = doc.loop == null ? !isAnim : doc.loop === true || doc.loop === 1;
applySequenceKindUi();
const lanes = normalizeSequenceLanes(doc);
const laneOpts = Array.isArray(doc.lane_opts) ? doc.lane_opts : [];
renderTargetsPanel();
lanesHost.innerHTML = '';
if (!lanes.some((l) => l.length > 0)) {
const lg0 = buildLaneGroupIdsForEditor(doc, 0, 1);
lanesHost.appendChild(renderSequenceLane(0, [], lg0, presetsMap, groupsMap, zoneGroupIds, laneOpts[0]));
} else {
lanes.forEach((laneSteps, i) => {
const lg = buildLaneGroupIdsForEditor(doc, i, lanes.length);
lanesHost.appendChild(renderSequenceLane(i, laneSteps, lg, presetsMap, groupsMap, zoneGroupIds, laneOpts[i]));
});
}
refreshSequenceEditorLaneTitles();
applySequenceEditorMode();
const edDel = document.getElementById('sequence-editor-delete-btn');
if (edDel) edDel.style.display = sequenceEditorId ? 'inline-block' : 'none';
const edTry = document.getElementById('sequence-editor-try-btn');
if (edTry) edTry.style.display = sequenceEditorId ? 'inline-block' : 'none';
let grid = false;
try {
grid = localStorage.getItem('seqEditorGrid') === '1';
} catch (_) {
grid = false;
}
modal.classList.add('active');
setSequenceEditorView(grid);
}
let seqEditorNewKind = 'sequence';
/** Zone id for refreshing the visible preset/sequence strip if `getCurrentZoneId` is not set yet. */
function resolveZoneIdForPresetStripRefresh() {
if (window.zonesManager && typeof window.zonesManager.getCurrentZoneId === 'function') {
const z = window.zonesManager.getCurrentZoneId();
if (z != null && String(z).trim() !== '') {
return String(z).trim();
}
}
const sec = document.querySelector('.presets-section[data-zone-id]');
if (sec && sec.dataset.zoneId != null && String(sec.dataset.zoneId).trim() !== '') {
return String(sec.dataset.zoneId).trim();
}
return null;
}
async function saveSequenceEditor() {
const modeSel = document.getElementById('sequence-editor-mode');
const nameInput = document.getElementById('sequence-editor-name');
const { lanes, lanes_group_ids, lane_opts } = collectLanesFromEditor();
const idxs = [];
lanes.forEach((l, i) => {
if (l.length) idxs.push(i);
});
if (!idxs.length) {
alert('Add at least one step with a preset, animation or rest.');
return;
}
const targets = seqEd.targets.map((t) => ({
name: String(t.name || '').trim(),
group_ids: [...t.group_ids],
devices: [...t.devices],
}));
const nonEmpty = idxs.map((i) => lanes[i]);
const opts = idxs.map((i) => lane_opts[i] || {});
// Lanes that play to targets also get their groups in lanes_group_ids, for readers that predate targets
const nonEmptyLg = idxs.map((i, k) => {
const own = lanes_group_ids[i] ? [...lanes_group_ids[i]] : [];
if (!targets.length || !opts[k].targets) return own;
const g = [];
opts[k].targets.forEach((ti) => (targets[ti] ? targets[ti].group_ids : []).forEach((x) => g.includes(x) || g.push(x)));
return g;
});
const kindSel = document.getElementById('sequence-editor-kind');
const loopCb = document.getElementById('sequence-editor-loop');
const payload = {
name: nameInput ? nameInput.value.trim() : '',
kind: kindSel && kindSel.value === 'animation' ? 'animation' : 'sequence',
targets,
lanes: nonEmpty,
lane_opts: opts,
lanes_group_ids: nonEmptyLg,
group_ids: nonEmptyLg[0] ? [...nonEmptyLg[0]] : [],
advance_mode: modeSel && modeSel.value === 'time' ? 'time' : 'beats',
loop: loopCb ? !!loopCb.checked : true,
steps: nonEmpty.length === 1 ? nonEmpty[0] : [],
};
try {
if (sequenceEditorId) {
const res = await fetch(`/sequences/${sequenceEditorId}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
body: JSON.stringify(payload),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error((err && err.error) || res.statusText);
}
} else {
const res = await fetch('/sequences', {
method: 'POST',
headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
body: JSON.stringify(payload),
});
if (!res.ok) {
const err = await res.json().catch(() => ({}));
throw new Error((err && err.error) || res.statusText);
}
const created = await res.json().catch(() => null);
if (created && typeof created === 'object') {
const entries = Object.entries(created);
if (entries.length > 0) {
sequenceEditorId = String(entries[0][0]);
const edDel = document.getElementById('sequence-editor-delete-btn');
if (edDel) edDel.style.display = 'inline-block';
const edTry = document.getElementById('sequence-editor-try-btn');
if (edTry) edTry.style.display = 'inline-block';
}
}
}
seqEd.seqMap = await fetchSequencesMap();
await loadSequencesModalList();
const zid = resolveZoneIdForPresetStripRefresh();
if (zid && typeof window.refreshEditTabSequencesUi === 'function') {
await window.refreshEditTabSequencesUi(zid);
}
if (zid && typeof window.renderTabPresets === 'function') {
await window.renderTabPresets(zid);
}
} catch (e) {
console.error(e);
alert(e.message || 'Failed to save sequence.');
}
}
async function deleteCurrentSequence() {
const idToDelete = sequenceEditorId;
if (!idToDelete) return;
if (!window.confirm('Delete this sequence? It will be removed from the server.')) return;
try {
const res = await fetch(`/sequences/${idToDelete}`, { method: 'DELETE' });
if (!res.ok) throw new Error('Delete failed');
const edModal = document.getElementById('sequence-editor-modal');
if (edModal) edModal.classList.remove('active');
sequenceEditorId = null;
await loadSequencesModalList();
const zid = resolveZoneIdForPresetStripRefresh();
if (zid) {
const tabResponse = await fetch(`/zones/${zid}`, { headers: { Accept: 'application/json' } });
if (tabResponse.ok) {
const tabData = await tabResponse.json();
const list = Array.isArray(tabData.sequence_ids) ? tabData.sequence_ids.map(String) : [];
const alist = Array.isArray(tabData.animation_ids) ? tabData.animation_ids.map(String) : [];
const sid = String(idToDelete);
if (list.includes(sid) || alist.includes(sid)) {
tabData.sequence_ids = list.filter((x) => x !== sid);
tabData.animation_ids = alist.filter((x) => x !== sid);
await fetch(`/zones/${zid}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(tabData),
});
}
}
if (typeof window.refreshEditTabSequencesUi === 'function') {
await window.refreshEditTabSequencesUi(zid);
}
if (typeof window.renderTabPresets === 'function') {
await window.renderTabPresets(zid);
}
}
} catch (e) {
console.error(e);
alert('Failed to delete sequence.');
}
}
async function loadSequencesModalList() {
const listEl = document.getElementById('sequences-list');
if (!listEl) return;
listEl.innerHTML = '<p class="muted-text">Loading…</p>';
const map = await fetchSequencesMap();
const ids = Object.keys(map).sort((a, b) => {
const na = (map[a] && map[a].name) || a;
const nb = (map[b] && map[b].name) || b;
return String(na).localeCompare(String(nb), undefined, { sensitivity: 'base' });
});
listEl.innerHTML = '';
if (!ids.length) {
listEl.innerHTML = '<p class="muted-text">No sequences yet.</p>';
return;
}
ids.forEach((id) => {
const doc = map[id] || {};
const row = document.createElement('div');
row.className = 'profiles-row';
row.style.cssText = 'display:flex;justify-content:space-between;align-items:center;gap:0.5rem;';
const title = document.createElement('span');
const ln = normalizeSequenceLanes(doc);
const nSteps = ln.reduce((a, l) => a + l.length, 0);
const nLanes = ln.filter((l) => l.length > 0).length || 1;
const anim = doc.kind === 'animation';
title.textContent = `${anim ? '⚡ ' : ''}${doc.name || id} — ${anim ? 'animation, ' : ''}${nLanes} lane(s), ${nSteps} step(s)`;
const edit = document.createElement('button');
edit.type = 'button';
edit.className = 'btn btn-secondary btn-small';
edit.textContent = 'Edit';
edit.addEventListener('click', () => openSequenceEditor(id, doc));
row.appendChild(title);
row.appendChild(edit);
listEl.appendChild(row);
});
}
window.applySequenceSwitchWaitFromServer = applySequenceSwitchWaitFromServer;
window.setSequenceSwitchSimulatedMode = setSequenceSwitchSimulatedMode;
window.stopZoneSequencePlayback = stopZoneSequencePlayback;
/** @param {boolean} on */
window.setSequenceDebug = function setSequenceDebug(on) {
sequenceDebugEnabled = !!on;
console.log(seqDebugEnabled() ? 1 : 0);
};
window.appendZoneSequenceTiles = appendZoneSequenceTiles;
window.fireAnimation = fireAnimation;
window.refreshEditTabSequencesUi = refreshEditTabSequencesUi;
window.addSequenceToTab = addSequenceToTab;
window.removeSequenceFromTab = removeSequenceFromTab;
document.addEventListener('DOMContentLoaded', () => {
void initSequenceSwitchToggle();
const btn = document.getElementById('sequences-btn');
const modal = document.getElementById('sequences-modal');
const closeBtn = document.getElementById('sequences-close-btn');
const addBtn = document.getElementById('sequence-add-btn');
const addAnimBtn = document.getElementById('animation-add-btn');
if (addAnimBtn) {
addAnimBtn.addEventListener('click', () => {
sequenceEditorId = null;
seqEditorNewKind = 'animation';
openSequenceEditor(null, null);
});
}
if (btn && modal) {
btn.addEventListener('click', () => {
modal.classList.add('active');
loadSequencesModalList();
});
}
if (closeBtn && modal) {
closeBtn.addEventListener('click', () => modal.classList.remove('active'));
}
if (addBtn) {
addBtn.addEventListener('click', () => {
sequenceEditorId = null;
seqEditorNewKind = 'sequence';
openSequenceEditor(null, null);
});
}
const openPresetsFromSeq = document.getElementById('sequences-open-presets-btn');
if (openPresetsFromSeq) {
openPresetsFromSeq.addEventListener('click', () => {
const b = document.getElementById('presets-btn');
if (b) b.click();
else alert('Presets is not available.');
});
}
const edClose = document.getElementById('sequence-editor-close-btn');
const edSave = document.getElementById('sequence-editor-save-btn');
const edDel = document.getElementById('sequence-editor-delete-btn');
if (edClose) {
edClose.addEventListener('click', () => {
document.getElementById('sequence-editor-modal') && document.getElementById('sequence-editor-modal').classList.remove('active');
});
}
if (edSave) edSave.addEventListener('click', () => saveSequenceEditor());
if (edDel) edDel.addEventListener('click', () => deleteCurrentSequence());
const edAddLane = document.getElementById('sequence-editor-add-lane-btn');
if (edAddLane) {
edAddLane.addEventListener('click', async () => {
const host = document.getElementById('sequence-editor-lanes');
if (!host) return;
const presetsRes = await fetch('/presets', { headers: { Accept: 'application/json' } });
const presetsMap = presetsRes.ok ? await presetsRes.json() : {};
const groupsMap = await fetchGroupsMapSeq();
const idx = host.querySelectorAll('.sequence-lane').length;
if (idx >= LANES_MAX_UI) {
alert(`A sequence can have up to ${LANES_MAX_UI} lanes.`);
return;
}
seqEd.presetsMap = presetsMap;
host.appendChild(renderSequenceLane(idx, [], [], presetsMap, groupsMap, seqEd.zoneGroupIds, {}));
refreshSequenceEditorLaneTitles();
applySequenceEditorMode();
});
}
const edMode = document.getElementById('sequence-editor-mode');
if (edMode) edMode.addEventListener('change', applySequenceEditorMode);
const edKind = document.getElementById('sequence-editor-kind');
if (edKind) {
edKind.addEventListener('change', () => {
const loopCb = document.getElementById('sequence-editor-loop');
if (loopCb) loopCb.checked = edKind.value !== 'animation';
applySequenceKindUi();
});
}
const addTarget = document.getElementById('sequence-editor-add-target-btn');
if (addTarget) {
addTarget.addEventListener('click', () => {
if (addSeqTarget({})) renderTargetsPanel();
});
}
const perDriver = document.getElementById('sequence-editor-per-driver-btn');
if (perDriver) perDriver.addEventListener('click', addTargetsPerDriver);
const viewBtn = document.getElementById('sequence-editor-view-btn');
if (viewBtn) {
viewBtn.addEventListener('click', () => {
const g = document.getElementById('sequence-editor-grid');
setSequenceEditorView(!!g && g.hidden);
});
}
const tryBtn = document.getElementById('sequence-editor-try-btn');
if (tryBtn) {
tryBtn.addEventListener('click', async () => {
if (!sequenceEditorId) return;
await saveSequenceEditor();
const zid = resolveZoneIdForPresetStripRefresh();
const kind = document.getElementById('sequence-editor-kind');
try {
if (kind && kind.value === 'animation') await fireAnimation(sequenceEditorId, zid);
else await requestBackendSequencePlay(sequenceEditorId, zid, null);
} catch (e) {
alert(e.message || 'Could not play it.');
}
});
}
});