291 lines
19 KiB
JavaScript
291 lines
19 KiB
JavaScript
import { app } from "../../scripts/app.js";
|
||
|
||
const CLASS = "DumasH3SequencePromptBuilder";
|
||
const MAX_CLIPS = 16;
|
||
const get = (node, name) => node.widgets?.find((widget) => widget.name === name);
|
||
const el = (tag, text = "") => { const item = document.createElement(tag); item.textContent = text; return item; };
|
||
|
||
function defaultState(count, seconds) {
|
||
return { version: 1, clips: Array.from({ length: count }, () => ({
|
||
duration: seconds, slots: [{ start: 0, end: seconds, text: "" }], prompt: "",
|
||
})) };
|
||
}
|
||
|
||
function readState(widget, count, seconds) {
|
||
try {
|
||
const value = JSON.parse(String(widget?.value || ""));
|
||
if (Array.isArray(value.clips)) return value;
|
||
} catch (_) { /* replace malformed editor state with a usable default */ }
|
||
return defaultState(count, seconds);
|
||
}
|
||
|
||
function hide(widget) {
|
||
if (!widget) return;
|
||
widget.type = "hidden"; widget.hidden = true; widget.options ||= {};
|
||
widget.options.hidden = true; widget.computeSize = () => [0, 0]; widget.draw = () => {};
|
||
}
|
||
|
||
function configure(node) {
|
||
if (node?.comfyClass !== CLASS || typeof document === "undefined" || typeof node.addDOMWidget !== "function") return;
|
||
if (node.__dumasSequencePromptBuilder) return node.__dumasSequencePromptBuilder();
|
||
const countWidget = get(node, "clip_count");
|
||
const secondsWidget = get(node, "default_chunk_seconds");
|
||
const stateWidget = get(node, "timeline_json");
|
||
if (!countWidget || !secondsWidget || !stateWidget) return;
|
||
hide(stateWidget);
|
||
const panel = el("div");
|
||
panel.style.cssText = "box-sizing:border-box;width:calc(100% + 14px);margin-left:-7px;min-width:420px;padding:9px;color:#d9e3dc;background:#292929;border:1px solid #454545;border-radius:4px;font:12px Arial;pointer-events:auto";
|
||
const host = el("div"); host.style.cssText = "pointer-events:auto;background:#292929;width:100%;margin-top:-7px;margin-bottom:-7px"; host.append(panel);
|
||
["pointerdown", "mousedown", "mouseup", "dblclick"].forEach((name) => host.addEventListener(name, (event) => event.stopPropagation()));
|
||
const display = node.addDOMWidget("clip_tabs", "dumas_h3_clip_tabs", host, { serialize: false });
|
||
display.options ||= {}; display.options.serialize = false;
|
||
let active = 0;
|
||
let state = readState(stateWidget, Number(countWidget.value) || 2, Number(secondsWidget.value) || 4);
|
||
let promptText = null;
|
||
// Writing the hidden widget value is safe while a textarea owns focus.
|
||
// Calling its callback is not: ComfyUI callbacks redraw the DOM widget,
|
||
// which destroys the focused textarea during blur/pointer transitions.
|
||
const persistState = () => {
|
||
stateWidget.value = JSON.stringify(state);
|
||
node.setDirtyCanvas?.(true, true);
|
||
};
|
||
const setState = () => {
|
||
persistState();
|
||
stateWidget.callback?.(stateWidget.value);
|
||
};
|
||
const input = (type, value, onChange) => {
|
||
const item = el("input"); item.type = type; item.value = value;
|
||
item.style.cssText = type === "range"
|
||
? "width:100%;box-sizing:border-box;margin:2px 0;accent-color:#79c98a"
|
||
: "width:100%;box-sizing:border-box;margin:2px 0;color:#111";
|
||
item.onchange = () => onChange(item.value); return item;
|
||
};
|
||
const addSlot = (clip, afterIndex = clip.slots.length - 1) => {
|
||
const duration = Number(clip.duration) || 0.1;
|
||
if (afterIndex === clip.slots.length - 1 && afterIndex >= 0) {
|
||
const previous = clip.slots[afterIndex];
|
||
const split = Number(previous.start) + Math.max(0.1, (duration - Number(previous.start)) / 2);
|
||
previous.end = Math.min(duration - 0.1, split);
|
||
clip.slots.splice(afterIndex + 1, 0, { start: previous.end, end: duration, text: "" });
|
||
return;
|
||
}
|
||
const previousEnd = afterIndex >= 0 ? Number(clip.slots[afterIndex]?.end) || 0 : 0;
|
||
const remaining = Math.max(0.1, duration - previousEnd);
|
||
clip.slots.splice(afterIndex + 1, 0, {
|
||
start: previousEnd,
|
||
end: Math.min(duration, previousEnd + Math.max(0.1, remaining / 2)),
|
||
text: "",
|
||
});
|
||
};
|
||
const formatTime = (seconds) => `00:${Number(seconds).toFixed(3).padStart(6, "0")}`;
|
||
// Keep the user's script as the source of truth, like CSGlide does. The
|
||
// slots are only the timeline model used to paint the bar and to locate
|
||
// boundaries. Rebuilding the textarea from slots is lossy (and was the
|
||
// reason a redraw could erase text that had just been typed).
|
||
const formatPromptFromSlots = (clip) => clip.slots.map((slot, index) =>
|
||
`[Shot ${index + 1}] At ${formatTime(slot.start)}, ${slot.text || ""}`).join("\n\n");
|
||
const promptFor = (clip) => {
|
||
if (typeof clip.prompt === "string" && clip.prompt.length) return clip.prompt;
|
||
return formatPromptFromSlots(clip);
|
||
};
|
||
const syncPrompt = (clip, value) => {
|
||
const text = String(value || "");
|
||
// The shot description starts on the same line as the marker in the
|
||
// CSGlide-style editor. Only consume the marker prefix through its
|
||
// timestamp comma; consuming the whole line would discard text such
|
||
// as `[Shot 1] At 00:00.000, the character walks...` when a new shot
|
||
// is added and the marker scaffold is rebuilt.
|
||
const marks = [...text.matchAll(/\[Shot\s+(\d+)\]\s+At\s+[^,\n]+,\s*/gi)];
|
||
if (!marks.length) { if (clip.slots[0]) clip.slots[0].text = text.trim(); return; }
|
||
marks.forEach((mark, index) => {
|
||
const slotIndex = Number(mark[1]) - 1;
|
||
if (!clip.slots[slotIndex]) return;
|
||
const from = mark.index + mark[0].length;
|
||
const to = index + 1 < marks.length ? marks[index + 1].index : text.length;
|
||
clip.slots[slotIndex].text = text.slice(from, to).trim();
|
||
});
|
||
};
|
||
const retimePrompt = (text, clip) => {
|
||
let index = 0;
|
||
return String(text || "").replace(/(\[Shot\s+\d+\]\s+At\s+)[^,\n]+(,?)/gi, (whole, prefix, suffix) => {
|
||
const start = clip.slots[index++]?.start ?? 0;
|
||
return `${prefix}${formatTime(start)}${suffix}`;
|
||
});
|
||
};
|
||
const commitPrompt = (clip, value, redraw = false) => {
|
||
clip.prompt = String(value ?? "");
|
||
syncPrompt(clip, clip.prompt);
|
||
// Do not invoke the widget callback for ordinary text edits. The
|
||
// callback redraws the DOM and can run while the textarea is blurring
|
||
// to a timeline handle, exactly the interaction CSGlide avoids.
|
||
persistState();
|
||
if (redraw) render();
|
||
};
|
||
const rebuildPromptAfterStructureChange = (clip) => {
|
||
// Adding/removing a shot is the one operation allowed to add/remove
|
||
// marker lines. Preserve all existing shot text before formatting.
|
||
syncPrompt(clip, clip.prompt || promptFor(clip));
|
||
clip.prompt = formatPromptFromSlots(clip);
|
||
};
|
||
const render = () => {
|
||
const count = Math.max(1, Math.min(MAX_CLIPS, Number(countWidget.value) || 1));
|
||
const chunkDuration = Number(secondsWidget.value) || 4;
|
||
while (state.clips.length < count) state.clips.push({ duration: chunkDuration, slots: [] });
|
||
state.clips = state.clips.slice(0, count); active = Math.min(active, count - 1);
|
||
panel.replaceChildren();
|
||
const tabs = el("div"); tabs.style.cssText = "display:flex;flex-wrap:wrap;gap:4px;margin-bottom:8px;border-bottom:1px solid #444;padding-bottom:6px";
|
||
state.clips.forEach((clip, index) => {
|
||
const button = el("button", `Clip ${index + 1}`); button.type = "button"; button.disabled = index === active;
|
||
button.style.cssText = `padding:3px 10px;border:1px solid ${index === active ? "#8bc99b" : "#555"};border-radius:3px;background:${index === active ? "#4b6f55" : "#333"};color:${index === active ? "#fff" : "#bbb"};cursor:pointer`;
|
||
button.onclick = () => { active = index; render(); }; tabs.append(button);
|
||
});
|
||
panel.append(tabs);
|
||
const clip = state.clips[active];
|
||
// All clips share the one authoritative project duration widget.
|
||
const duration = chunkDuration;
|
||
clip.duration = duration;
|
||
if (clip.slots.length) clip.slots[clip.slots.length - 1].end = duration;
|
||
promptText = promptFor(clip);
|
||
const durationRow = el("div"); durationRow.style.cssText = "display:flex;align-items:center;gap:8px;margin:4px 0 6px;color:#b7d6bf";
|
||
durationRow.append(el("strong", `Clip ${active + 1}`), el("span", `· ${duration.toFixed(1)}s shared chunk duration`)); panel.append(durationRow);
|
||
const timeline = el("div"); timeline.style.cssText = "position:relative;height:38px;margin:8px 0 4px;background:#171717;border-radius:4px;overflow:hidden;border:1px solid #555";
|
||
const palette = ["#4b9b67", "#4d7fb1", "#a87945", "#8c5aa8", "#a44f5d", "#3f8e8a"];
|
||
let prompt = null;
|
||
const segments = [];
|
||
const handles = [];
|
||
const updateTimeline = () => {
|
||
clip.slots.forEach((slot, index) => {
|
||
const left = Math.max(0, Number(slot.start) / duration * 100);
|
||
const width = Math.max(0.1, (Number(slot.end) - Number(slot.start)) / duration * 100);
|
||
segments[index].style.left = `${left}%`;
|
||
segments[index].style.width = `${width}%`;
|
||
segments[index].title = `${Number(slot.start).toFixed(1)}s–${Number(slot.end).toFixed(1)}s`;
|
||
});
|
||
handles.forEach(({ handle, slot }) => { handle.style.left = `${Number(slot.end) / duration * 100}%`; });
|
||
};
|
||
clip.slots.forEach((slot, index) => {
|
||
const segment = el("button", `Shot ${index + 1}\n${(slot.text || "unscripted").slice(0, 18)}`); segment.type = "button";
|
||
segment.style.cssText = `position:absolute;top:0;height:100%;border:0;border-right:2px solid #292929;color:white;background:${palette[index % palette.length]};white-space:pre-wrap;font-size:10px;overflow:hidden;padding:2px;cursor:pointer`;
|
||
segment.onclick = () => { prompt.focus(); }; segments.push(segment); timeline.append(segment);
|
||
});
|
||
clip.slots.slice(0, -1).forEach((slot, index) => {
|
||
const next = clip.slots[index + 1];
|
||
const handle = el("div"); handle.title = `Resize boundary between Shot ${index + 1} and Shot ${index + 2}`;
|
||
handle.style.cssText = "position:absolute;top:0;width:17px;height:100%;transform:translateX(-50%);background:transparent;border:0;border-radius:3px;cursor:ew-resize;z-index:5;box-sizing:border-box;touch-action:none";
|
||
const ink = el("div");
|
||
ink.style.cssText = "position:absolute;left:7px;top:0;width:2px;height:100%;background:#f1f7f2;border:0;border-radius:1px;pointer-events:none";
|
||
handle.append(ink);
|
||
const move = (event) => {
|
||
event.preventDefault(); event.stopPropagation();
|
||
const rect = timeline.getBoundingClientRect();
|
||
const point = Math.min(duration - 0.1, Math.max(0.1, ((event.clientX - rect.left) / rect.width) * duration));
|
||
slot.end = point; next.start = point; updateTimeline();
|
||
};
|
||
let dragging = false;
|
||
const finish = (event) => {
|
||
if (!dragging) return;
|
||
dragging = false;
|
||
event?.preventDefault?.(); event?.stopPropagation?.();
|
||
document.removeEventListener("pointermove", move, true);
|
||
window.removeEventListener("pointerup", finish, true);
|
||
document.removeEventListener("mousemove", moveMouse, true);
|
||
document.removeEventListener("mouseup", finish, true);
|
||
promptText = retimePrompt(promptText ?? prompt?.value ?? clip.prompt ?? "", clip);
|
||
commitPrompt(clip, promptText);
|
||
render();
|
||
};
|
||
const moveMouse = (event) => { if (dragging) move(event); };
|
||
handle.onpointerdown = (event) => {
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
dragging = true;
|
||
// Textarea edits are intentionally committed on change, but a
|
||
// drag can happen while it still has focus. Capture them before
|
||
// the timeline redraws the prompt from state.
|
||
if (prompt) { promptText = prompt.value; clip.prompt = promptText; }
|
||
handle.setPointerCapture?.(event.pointerId);
|
||
document.addEventListener("pointermove", move, true);
|
||
window.addEventListener("pointerup", finish, true);
|
||
document.addEventListener("mousemove", moveMouse, true);
|
||
document.addEventListener("mouseup", finish, true);
|
||
};
|
||
handles.push({ handle, slot }); timeline.append(handle);
|
||
});
|
||
updateTimeline();
|
||
panel.append(timeline);
|
||
const sliderHint = el("div", "Drag the white handles to resize shots. The bar represents the complete chunk duration."); sliderHint.style.cssText = "color:#aab6ad;margin-bottom:6px;font-size:11px"; panel.append(sliderHint);
|
||
|
||
const shotChips = el("div"); shotChips.style.cssText = "display:flex;gap:4px;overflow:hidden;margin:3px 0 5px";
|
||
clip.slots.forEach((slot, index) => {
|
||
const chipText = (slot.text || `Shot ${index + 1}`).replace(/\s+/g, " ").trim().slice(0, 31);
|
||
const chip = el("button", chipText || `Shot ${index + 1}`); chip.type = "button";
|
||
chip.title = `Jump to Shot ${index + 1}`;
|
||
chip.style.cssText = `max-width:180px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:3px 8px;border:1px solid ${palette[index % palette.length]};border-radius:4px;background:#1e1e1e;color:#e6e6e6;font:11px Arial;cursor:pointer`;
|
||
chip.onclick = () => {
|
||
if (!prompt) return;
|
||
const marker = `[Shot ${index + 1}]`;
|
||
const position = prompt.value.indexOf(marker);
|
||
prompt.focus();
|
||
if (position >= 0) prompt.setSelectionRange(position, position + marker.length);
|
||
};
|
||
shotChips.append(chip);
|
||
});
|
||
panel.append(shotChips);
|
||
const promptLabel = el("div", "PROMPT SCRIPT"); promptLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:4px 0 3px"; panel.append(promptLabel);
|
||
prompt = el("textarea"); prompt.rows = 10; prompt.value = promptText; prompt.placeholder = "[Shot 1] At 00:00.000, describe the opening action...\n\nType @ at the start of a new line to add the next shot."; prompt.style.cssText = "width:100%;box-sizing:border-box;color:#e8e8e8;background:#171717;border:1px solid #4e4e4e;border-radius:4px;padding:8px;font:12px/1.45 monospace;margin-top:2px;resize:vertical;outline:none";
|
||
prompt.oninput = () => { promptText = prompt.value; clip.prompt = prompt.value; };
|
||
prompt.onblur = () => { if (prompt) { clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); persistState(); } };
|
||
prompt.onchange = () => { commitPrompt(clip, prompt.value); };
|
||
prompt.onpointerdown = (event) => event.stopPropagation();
|
||
prompt.onkeydown = (event) => {
|
||
if (event.key !== "@") return;
|
||
const cursor = prompt.selectionStart || 0;
|
||
if (cursor !== 0 && prompt.value[cursor - 1] !== "\n") return;
|
||
event.preventDefault();
|
||
clip.prompt = prompt.value;
|
||
syncPrompt(clip, clip.prompt);
|
||
addSlot(clip);
|
||
rebuildPromptAfterStructureChange(clip);
|
||
setState(); render();
|
||
};
|
||
panel.append(prompt);
|
||
const checkLabel = el("div", "PROMPT CHECK"); checkLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:7px 0 3px"; panel.append(checkLabel);
|
||
const check = el("div", `${clip.slots.length} shot${clip.slots.length === 1 ? "" : "s"} · ${duration.toFixed(1)}s chunk · @ references preserved`); check.style.cssText = "padding:6px 8px;background:#171717;border:1px solid #444;border-radius:4px;color:#9bd0a8;font:11px monospace"; panel.append(check);
|
||
const encoderLabel = el("div", "SENT TO ENCODER AS"); encoderLabel.style.cssText = "color:#8fa898;font-size:10px;letter-spacing:.08em;margin:7px 0 3px"; panel.append(encoderLabel);
|
||
const encoder = el("div", clip.slots.map((slot, index) => `Shot ${index + 1} ${formatTime(slot.start)}`).join(" ")); encoder.style.cssText = "padding:6px 8px;background:#171717;border:1px solid #444;border-radius:4px;color:#7cc4d5;font:11px monospace;white-space:nowrap;overflow:hidden;text-overflow:ellipsis"; panel.append(encoder);
|
||
const actions = el("div"); actions.style.cssText = "display:flex;gap:5px;margin-top:5px";
|
||
const add = el("button", "@ Add shot"); add.type = "button"; add.onclick = () => { clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); addSlot(clip); rebuildPromptAfterStructureChange(clip); setState(); render(); }; actions.append(add);
|
||
if (clip.slots.length > 1) { const remove = el("button", "Remove last shot"); remove.type = "button"; remove.onclick = () => { clip.prompt = prompt.value; syncPrompt(clip, clip.prompt); clip.slots.pop(); clip.slots.at(-1).end = clip.duration; rebuildPromptAfterStructureChange(clip); setState(); render(); }; actions.append(remove); }
|
||
panel.append(actions);
|
||
// The editor now contains chips, the prompt check and encoder summary;
|
||
// the old slot-count estimate left a large blank tail in the node.
|
||
// Measure the actual DOM panel instead of guessing from slot count.
|
||
const measuredHeight = Math.ceil(panel.getBoundingClientRect().height || panel.scrollHeight || 0);
|
||
display.computeSize = (width) => [Math.max(420, Number(width) || 420), Math.max(0, measuredHeight - 14)];
|
||
};
|
||
const refresh = () => { state = readState(stateWidget, Number(countWidget.value) || 2, Number(secondsWidget.value) || 4); render(); setState(); };
|
||
countWidget.callback = ((previous) => function(...args) { const result = previous?.apply(this, args); refresh(); return result; })(countWidget.callback);
|
||
secondsWidget.callback = ((previous) => function(...args) {
|
||
const result = previous?.apply(this, args);
|
||
const duration = Math.max(0.1, Number(secondsWidget.value) || 0.1);
|
||
state.clips.forEach((clip) => {
|
||
clip.duration = duration;
|
||
clip.slots.forEach((slot) => {
|
||
slot.start = Math.min(Number(slot.start) || 0, Math.max(0, duration - 0.1));
|
||
slot.end = Math.min(Math.max(Number(slot.end) || duration, slot.start + 0.1), duration);
|
||
});
|
||
});
|
||
setState(); render(); return result;
|
||
})(secondsWidget.callback);
|
||
stateWidget.callback = ((previous) => function(...args) { const result = previous?.apply(this, args); render(); return result; })(stateWidget.callback);
|
||
node.__dumasSequencePromptBuilder = refresh;
|
||
refresh();
|
||
}
|
||
|
||
app.registerExtension({
|
||
name: "DUMAS.H3.SequencePromptBuilder",
|
||
nodeCreated(node) { setTimeout(() => configure(node), 0); },
|
||
loadedGraphNode(node) { setTimeout(() => configure(node), 0); },
|
||
afterConfigureGraph() { for (const node of app.graph?._nodes || []) configure(node); },
|
||
});
|