Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 ausboss
|
0c0e93a760 | ||
|
ausboss
|
c37386c1d4 | ||
|
ausboss
|
7cb0abaacf |
@@ -4,6 +4,11 @@ All notable changes to ComfyUI-AusBoss are documented here.
|
||||
|
||||
## Unreleased
|
||||
|
||||
- **New node: Load Audio.** Load a sound file and keep only the part you
|
||||
want. The node shows the sound as a wave: drag the IN and OUT handles to
|
||||
trim it, and press play to hear just that part. Set Max length to the
|
||||
longest sound the next step takes, and anything longer shows in red as
|
||||
cut off, so you see exactly what comes out before you run.
|
||||
- **Resizing one node of a selection now resizes them all.** With two or more
|
||||
nodes selected, pull the edge or corner of one: nodes stacked in a column
|
||||
get its width, nodes side by side in a row get its height, and a grid gets
|
||||
|
||||
@@ -162,6 +162,12 @@ Upload a video, or pick one from the Source list, which plays the clip under the
|
||||
|
||||
It returns the frames, audio, frame count, fps, width, height, duration and a core `VIDEO`. Only the part you kept is decoded, and it checks memory before a large load. When you save the frames, wire its fps into the save node.
|
||||
|
||||
### Load Audio
|
||||
|
||||
Upload a sound file, or pick one from the Source list, and the node shows it as a wave. Drag the IN and OUT handles to keep only the part you want, or type the times. Press play to hear just that part. Set **Max length** to the longest sound the next step can take, such as a video's length: anything past it turns red and is cut off, so you see what comes out before you run. Click the red length next to OUT to move OUT to the cut.
|
||||
|
||||
It returns the `audio` you kept and its length in `seconds`. Only that part is decoded. [Help page](js/docs/AUSBOSS_NODES_LoadAudio.md).
|
||||
|
||||
### Video Crop + Rotate + Pad → Frame
|
||||
|
||||
Picks one frame from a video, then gives you the same rotate, crop and pad controls as the image node, plus an optional megapixel resize. Scrub to the frame with the playhead on the node; the editor adds frame-by-frame stepping and playback. It returns the transformed `image`, a `mask` of the added area, a `stitcher`, the chosen `original` frame, and the output `width` and `height`. For a whole clip, use the Clip version below.
|
||||
|
||||
@@ -36,6 +36,7 @@ NODE_MODULES = [
|
||||
"node_layout_boxes",
|
||||
"node_literals",
|
||||
"node_load_image_pad",
|
||||
"node_load_audio",
|
||||
"node_load_video",
|
||||
"node_lora_loader",
|
||||
"node_mask_by_name",
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
# Load Audio
|
||||
|
||||
Loads a sound file and hands on only the part you pick. Use it for a voice
|
||||
clip, a song or any sound a video model or a save node takes, when you want
|
||||
one part of the file and not the whole thing.
|
||||
|
||||
The node shows the whole file as a wave, so you can see where the loud parts
|
||||
are. The part that comes out is bright. Drag the white **IN** and **OUT**
|
||||
handles to set where it starts and stops, drag the bright part to slide it,
|
||||
or click somewhere else on the wave to move it there. You can also type a time
|
||||
under the wave, in seconds (`12.5`) or minutes and seconds (`1:02.5`).
|
||||
|
||||
Press **▶** to hear only the part that comes out. **LOOP** plays it again and
|
||||
again.
|
||||
|
||||
## Max length
|
||||
|
||||
Set **Max length** to the longest sound the next step can take, such as the
|
||||
length of the video you are making. The start stays where it is, and anything
|
||||
past the limit turns red with a dashed line where it is cut. Next to OUT,
|
||||
the node shows how long the sound that comes out is, such as `15.0 s`. It
|
||||
turns red when part of your pick is cut; hold the mouse over it to see how
|
||||
much, and click it to move OUT to the cut. Play stops at the cut, so what you
|
||||
hear is what comes out. `0` means no limit.
|
||||
|
||||
Max length can be wired. When the wire comes from a number node such as
|
||||
Float 🆎, the wave shows the cut for that number; otherwise the length's tooltip says
|
||||
`max wired` and the run still cuts the sound to the wired length.
|
||||
|
||||
## Controls
|
||||
|
||||
- **Source** (`audio`): a sound file in ComfyUI's input folder. **Upload**
|
||||
adds one. Videos are listed as well, for their sound.
|
||||
- **Max length** (`max_seconds`): the longest the sound may be, in seconds.
|
||||
`0` means no limit.
|
||||
- **IN** (`start_seconds`): where the sound starts.
|
||||
- **OUT** (`end_seconds`): where the sound stops. `0` means the end of the
|
||||
file.
|
||||
|
||||
## Outputs
|
||||
|
||||
- `audio`: the part you picked, for any node that takes `AUDIO`.
|
||||
- `seconds`: how long that sound is.
|
||||
|
||||
## Technical details
|
||||
|
||||
- Only the picked part is decoded: decoding stops once the window is full,
|
||||
so a short pick from a long recording stays quick.
|
||||
- The sound keeps its own sample rate and channels.
|
||||
- A start past the end of the file stops the run with a message that says so.
|
||||
- The wave is drawn in the browser from the file itself; nothing extra is
|
||||
stored with the workflow besides the four values above.
|
||||
@@ -27,6 +27,15 @@ needs.
|
||||
- The line underneath shows the last run's seed. The history saves with the
|
||||
workflow.
|
||||
|
||||
## Compact look
|
||||
|
||||
The **gear** beside the number picks the look. **Compact** is one short
|
||||
row: the number, a mode chip and a dice. Tap the chip to go Random → Fixed →
|
||||
+1 → −1. The dice rolls a new seed and pins it. A long seed shrinks to fit.
|
||||
Hover the number to see the last run's seed. The look is saved on the node,
|
||||
and new Seed nodes start in the look you picked last. **Full** brings back
|
||||
the whole card, with the seeds it ran with.
|
||||
|
||||
## Output
|
||||
|
||||
- **seed**: The seed, unchanged.
|
||||
|
||||
@@ -33,6 +33,7 @@ help panel.
|
||||
| Apply a stack of LoRAs | LoRA Loader (`AUSBOSS_NODES_LoraLoader`) |
|
||||
| Krea 2 prompt, and Krea 2 outpainting | Krea 2 Encode (`AUSBOSS_NODES_Krea2Encode`), Krea 2 Outpaint Model Patch (`AUSBOSS_NODES_Krea2OutpaintModelPatch`) |
|
||||
| Load or save a video | Load Video (`AUSBOSS_NODES_LoadVideo`), Save Video (`AUSBOSS_NODES_SaveVideo`) |
|
||||
| Load a sound file and keep only part of it, up to a set length | Load Audio (`AUSBOSS_NODES_LoadAudio`) |
|
||||
| Turn, crop and pad a video: one frame, or the whole clip | Video Crop + Rotate + Pad → Frame (`AUSBOSS_NODES_VideoCropRotatePad`), → Clip (`AUSBOSS_NODES_VideoCropRotatePadClip`) |
|
||||
| Change a clip's frame rate | Frame Interpolate (`AUSBOSS_NODES_FrameInterpolate`) |
|
||||
| Work with frame batches | Select Frame, Select Every Nth, Split Batch, Merge Batches (`AUSBOSS_NODES_SelectFrame`, `_SelectEveryNth`, `_SplitBatch`, `_MergeBatches`) |
|
||||
|
||||
@@ -862,8 +862,11 @@ app.registerExtension({
|
||||
chainCallback(nodeType.prototype, "onExecuted", function (output) {
|
||||
if (isForeignRun()) return;
|
||||
const state = buildPanel(this, config);
|
||||
// A result arrived (Save Image sends one even with its preview off).
|
||||
if (state) { state.stale = false; state.resultGone = false; scheduleRefresh(state); }
|
||||
// Count-only results carry no replacement for a stale picture.
|
||||
if (state) {
|
||||
if (outputRecordQuery(output)) { state.stale = false; state.resultGone = false; }
|
||||
scheduleRefresh(state);
|
||||
}
|
||||
// Saved: the file's picture replaces the steps.
|
||||
if (state?.stepOverlay) {
|
||||
state.stepsSaved = stepRun().promptId;
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
// Load Audio's window rules for the face, mirroring audio_window in
|
||||
// nodes/_audio_trim_helpers.py so the wave shows exactly what one Run hands
|
||||
// on. Pure: tests/load_audio_window.test.mjs runs it without a browser.
|
||||
|
||||
function finite(value, fallback = 0) {
|
||||
const number = Number(value);
|
||||
return Number.isFinite(number) ? number : fallback;
|
||||
}
|
||||
|
||||
// The pick, and what comes out of it. `end` 0 means "to the end of the
|
||||
// file". A max above 0 keeps the start and cuts off anything past
|
||||
// start + max. All times in seconds; duration is the file's length.
|
||||
export function outputWindow(durationValue, startValue, endValue, maxValue = 0) {
|
||||
const duration = Math.max(0, finite(durationValue));
|
||||
const start = Math.min(Math.max(0, finite(startValue)), duration);
|
||||
const pickedEnd = finite(endValue) > 0 ? Math.min(finite(endValue), duration) : duration;
|
||||
const end = Math.max(start, pickedEnd);
|
||||
const max = Math.max(0, finite(maxValue));
|
||||
const keepEnd = max > 0 && end - start > max ? Math.min(duration, start + max) : end;
|
||||
return { start, end, keepEnd, length: keepEnd - start, cut: Math.max(0, end - keepEnd) };
|
||||
}
|
||||
|
||||
// "0:12.0" style, the way the IN and OUT fields write a time.
|
||||
export function secondsLabel(value) {
|
||||
const seconds = Math.max(0, finite(value));
|
||||
if (seconds < 60) return `${seconds.toFixed(1)} s`;
|
||||
const minutes = Math.floor(seconds / 60);
|
||||
return `${minutes}:${(seconds - minutes * 60).toFixed(1).padStart(4, "0")}`;
|
||||
}
|
||||
|
||||
// The line between IN and OUT: what comes out, and what the max cuts off.
|
||||
export function outputSummary(window, { maxFromLink = false } = {}) {
|
||||
if (!window || window.length <= 0) return "";
|
||||
const parts = [secondsLabel(window.length)];
|
||||
if (window.cut > 0.005) parts.push(`cut ${secondsLabel(window.cut)}`);
|
||||
if (maxFromLink) parts.push("max wired");
|
||||
return parts.join(" · ");
|
||||
}
|
||||
|
||||
// Loud and quiet across the file: for each of `buckets` slices, the lowest
|
||||
// and highest sample of the channels mixed down. Channel data is a list of
|
||||
// Float32Arrays (AudioBuffer.getChannelData). Returns a Float32Array of
|
||||
// [min0, max0, min1, max1, ...].
|
||||
export function wavePeaks(channels, bucketsValue = 1200) {
|
||||
const list = Array.isArray(channels) ? channels.filter(Boolean) : [];
|
||||
const buckets = Math.max(1, Math.floor(finite(bucketsValue, 1200)));
|
||||
const peaks = new Float32Array(buckets * 2);
|
||||
const length = list.length ? list[0].length : 0;
|
||||
if (!length) return peaks;
|
||||
const count = list.length;
|
||||
for (let bucket = 0; bucket < buckets; bucket += 1) {
|
||||
const from = Math.floor((bucket * length) / buckets);
|
||||
const to = Math.max(from + 1, Math.floor(((bucket + 1) * length) / buckets));
|
||||
let low = 0;
|
||||
let high = 0;
|
||||
for (let index = from; index < to && index < length; index += 1) {
|
||||
let sample = 0;
|
||||
for (let channel = 0; channel < count; channel += 1) sample += list[channel][index] || 0;
|
||||
sample /= count;
|
||||
if (sample < low) low = sample;
|
||||
if (sample > high) high = sample;
|
||||
}
|
||||
peaks[bucket * 2] = low;
|
||||
peaks[bucket * 2 + 1] = high;
|
||||
}
|
||||
return peaks;
|
||||
}
|
||||
|
||||
// Which part of the wave a press at `fraction` (0..1 across it) grabs: a
|
||||
// handle within `hitPixels` of it, the inside of the pick to slide it, or
|
||||
// "jump" to move the pick there.
|
||||
export function grabZone(window, durationValue, fraction, widthValue, hitPixels = 10) {
|
||||
const duration = Math.max(0, finite(durationValue));
|
||||
const width = Math.max(0, finite(widthValue));
|
||||
if (duration <= 0 || width <= 0) return "none";
|
||||
const x = Math.min(1, Math.max(0, finite(fraction))) * width;
|
||||
const startX = (window.start / duration) * width;
|
||||
const endX = (window.end / duration) * width;
|
||||
const toStart = Math.abs(x - startX);
|
||||
const toEnd = Math.abs(x - endX);
|
||||
if (Math.min(toStart, toEnd) <= hitPixels) return toStart <= toEnd ? "start" : "end";
|
||||
if (x > startX && x < endX) return "move";
|
||||
return "jump";
|
||||
}
|
||||
@@ -0,0 +1,563 @@
|
||||
// Load Audio 🆎 - the wave, the trim and the player.
|
||||
//
|
||||
// The card above (js/widget_cards) holds Source and Max length. This panel
|
||||
// draws the whole file as a wave: the part that comes out is bright, the
|
||||
// part a Max length cuts off is red, and the rest is dim. Drag a handle to
|
||||
// move IN or OUT, drag the middle to slide the pick, or click elsewhere to
|
||||
// move it there. Play plays only what comes out. The widgets underneath
|
||||
// (start_seconds, end_seconds, max_seconds) stay the source of truth.
|
||||
import { api } from "/scripts/api.js";
|
||||
import { app } from "/scripts/app.js";
|
||||
import { BRAND, chainCallback, keepDomWidgetWidthAuto, notifyAusbossChange } from "../shared/index.mjs";
|
||||
import { keepKeyInField } from "../shared/canvas_passthrough.mjs";
|
||||
import { WIDGET_FRAME, fillNodeHeight } from "../shared/panel_layout.mjs";
|
||||
import { formatTimecode, parseTimecode } from "../shared/timecode.mjs";
|
||||
import { parseImageReference } from "../shared/pad_canvas.mjs";
|
||||
import { mediaViewQuery, splitMediaName } from "../shared/video_preview.mjs";
|
||||
import { ensureVideoCss, hideCanvasWidget, makeToolButton } from "../shared/video_ui.mjs";
|
||||
import { MIN_TRIM_SECONDS, dragTrimHandle, slideTrimWindow } from "../load_video/trim_preview.mjs";
|
||||
import { grabZone, outputSummary, outputWindow, secondsLabel, wavePeaks } from "./audio_window.mjs";
|
||||
|
||||
const NODE_NAME = "AUSBOSS_NODES_LoadAudio";
|
||||
const PANEL_WIDGET = "ausboss_load_audio_wave";
|
||||
// The frontend's own player for an audio_upload input. The wave replaces it.
|
||||
const CORE_AUDIO_WIDGET = "audioUI";
|
||||
const MIN_WIDTH = 280;
|
||||
// 8px root padding + the wave's 28px floor + 6px gap + the 22px play, IN/OUT and loop row.
|
||||
const PANEL_MIN_HEIGHT = 64;
|
||||
// Opens small and neat: 300 px wide, with a wave about as tall as a field
|
||||
// (32 px). Drag the corner down for a taller wave.
|
||||
const DEFAULT_WIDTH = 300;
|
||||
const DEFAULT_WAVE_EXTRA = 4;
|
||||
const CUT_RED = "#e0525a";
|
||||
const PEAK_BUCKETS = 1600;
|
||||
const END_EPSILON = 0.03;
|
||||
|
||||
// Decoded once per file and kept small: only the peaks and the length.
|
||||
const peakCache = new Map();
|
||||
|
||||
function findWidget(node, name) {
|
||||
return node.widgets?.find((widget) => widget.name === name);
|
||||
}
|
||||
|
||||
function roundHundredth(value) {
|
||||
return Math.round(Number(value || 0) * 100) / 100;
|
||||
}
|
||||
|
||||
function hideCoreAudio(node) {
|
||||
for (const widget of node.widgets ?? []) {
|
||||
if (widget?.name === CORE_AUDIO_WIDGET) hideCanvasWidget(widget, widget.element);
|
||||
}
|
||||
}
|
||||
|
||||
// A wired Max length: the number the wire carries, when the far end is a
|
||||
// node that shows it (Float, Integer, a Primitive). null when it can't be known.
|
||||
function wiredMax(node) {
|
||||
const input = node.inputs?.find((slot) => slot?.widget?.name === "max_seconds");
|
||||
if (!input || input.link == null) return { wired: false, value: null };
|
||||
const graph = node.graph;
|
||||
const link = graph?.getLink?.(input.link) ?? graph?.links?.get?.(input.link) ?? graph?.links?.[input.link];
|
||||
const origin = link ? graph?.getNodeById?.(link.origin_id) : null;
|
||||
const shown = origin?.widgets?.find((widget) => typeof widget?.value === "number");
|
||||
return { wired: true, value: shown ? Number(shown.value) : null };
|
||||
}
|
||||
|
||||
function maxSeconds(state) {
|
||||
const wired = wiredMax(state.node);
|
||||
if (wired.wired) return { value: wired.value ?? 0, fromLink: true, known: wired.value != null };
|
||||
return { value: Number(state.maxWidget?.value) || 0, fromLink: false, known: true };
|
||||
}
|
||||
|
||||
function currentWindow(state) {
|
||||
return outputWindow(state.duration, state.startWidget.value, state.endWidget.value, maxSeconds(state).value);
|
||||
}
|
||||
|
||||
async function loadPeaks(name, route) {
|
||||
const key = name;
|
||||
if (peakCache.has(key)) return peakCache.get(key);
|
||||
const job = (async () => {
|
||||
const response = await api.fetchApi(route, { cache: "no-store" });
|
||||
if (!response.ok) throw new Error(`the file could not be read (${response.status})`);
|
||||
const bytes = await response.arrayBuffer();
|
||||
const Context = window.AudioContext || window.webkitAudioContext;
|
||||
const context = new Context();
|
||||
try {
|
||||
const buffer = await context.decodeAudioData(bytes);
|
||||
const channels = [];
|
||||
for (let index = 0; index < buffer.numberOfChannels; index += 1) channels.push(buffer.getChannelData(index));
|
||||
return { duration: buffer.duration, peaks: wavePeaks(channels, PEAK_BUCKETS) };
|
||||
} finally {
|
||||
context.close?.();
|
||||
}
|
||||
})();
|
||||
peakCache.set(key, job);
|
||||
job.catch(() => peakCache.delete(key));
|
||||
return job;
|
||||
}
|
||||
|
||||
function ensureAudioCss() {
|
||||
ensureVideoCss();
|
||||
if (document.getElementById("ausboss-load-audio-css")) return;
|
||||
const style = document.createElement("style");
|
||||
style.id = "ausboss-load-audio-css";
|
||||
style.textContent = `
|
||||
.ausboss-audio-root .ausboss-video-stage{min-height:28px;background:#050b0b;cursor:pointer;touch-action:none;}
|
||||
.ausboss-audio-root canvas.ausboss-audio-wave{position:absolute;inset:0;width:100%;height:100%;display:block;}
|
||||
.ausboss-audio-root .ausboss-video-stage:not(.is-empty) .ausboss-video-status{display:none;}
|
||||
.ausboss-audio-root .ausboss-audio-row{display:flex;align-items:center;gap:6px;flex:none;padding:0 2px;}
|
||||
.ausboss-audio-root .ausboss-audio-row .ausboss-video-values{flex:1 1 auto;min-width:0;}
|
||||
.ausboss-audio-root .ausboss-audio-play{min-width:30px;font-size:10px;}
|
||||
.ausboss-audio-root .ausboss-audio-length{flex:none;padding:0 2px;color:#7fd9d2;font-size:10px;font-variant-numeric:tabular-nums;white-space:nowrap;cursor:default;}
|
||||
.ausboss-audio-root .ausboss-audio-length:empty{display:none;}
|
||||
.ausboss-audio-root .ausboss-audio-length.has-cut{color:#ff9aa0;cursor:pointer;text-decoration:underline dotted rgba(224,82,90,.8);text-underline-offset:2px;}
|
||||
.ausboss-audio-root .ausboss-audio-row .ausboss-video-tool{flex:none;}
|
||||
.ausboss-audio-root .ausboss-video-values{display:flex;gap:8px;}
|
||||
.ausboss-audio-root .ausboss-video-value input{width:48px;}
|
||||
.ausboss-audio-root .ausboss-audio-length{margin-left:auto;}
|
||||
`;
|
||||
document.head.appendChild(style);
|
||||
}
|
||||
|
||||
function draw(state) {
|
||||
const { canvas } = state;
|
||||
const rect = canvas.getBoundingClientRect();
|
||||
const scale = window.devicePixelRatio || 1;
|
||||
const width = Math.max(1, Math.round(rect.width * scale));
|
||||
const height = Math.max(1, Math.round(rect.height * scale));
|
||||
if (canvas.width !== width || canvas.height !== height) {
|
||||
canvas.width = width;
|
||||
canvas.height = height;
|
||||
}
|
||||
const ctx = canvas.getContext("2d");
|
||||
ctx.clearRect(0, 0, width, height);
|
||||
if (!state.peaks || state.duration <= 0) return;
|
||||
const win = currentWindow(state);
|
||||
const xOf = (seconds) => (seconds / state.duration) * width;
|
||||
const startX = xOf(win.start);
|
||||
const keepX = xOf(win.keepEnd);
|
||||
const endX = xOf(win.end);
|
||||
// Backdrops: the part that comes out, then the part cut off.
|
||||
ctx.fillStyle = "rgba(0,180,170,0.13)";
|
||||
ctx.fillRect(startX, 0, keepX - startX, height);
|
||||
if (endX > keepX) {
|
||||
ctx.fillStyle = "rgba(224,82,90,0.16)";
|
||||
ctx.fillRect(keepX, 0, endX - keepX, height);
|
||||
}
|
||||
// The wave, one bar per pixel column.
|
||||
const mid = height / 2;
|
||||
const reach = mid * 0.92;
|
||||
const buckets = state.peaks.length / 2;
|
||||
for (let x = 0; x < width; x += 1) {
|
||||
const from = Math.floor((x / width) * buckets);
|
||||
const to = Math.max(from + 1, Math.floor(((x + 1) / width) * buckets));
|
||||
let low = 0;
|
||||
let high = 0;
|
||||
for (let bucket = from; bucket < to && bucket < buckets; bucket += 1) {
|
||||
low = Math.min(low, state.peaks[bucket * 2]);
|
||||
high = Math.max(high, state.peaks[bucket * 2 + 1]);
|
||||
}
|
||||
if (x >= startX && x < keepX) ctx.fillStyle = BRAND;
|
||||
else if (x >= keepX && x < endX) ctx.fillStyle = CUT_RED;
|
||||
else ctx.fillStyle = "#3a4948";
|
||||
const top = mid - high * reach;
|
||||
ctx.fillRect(x, top, 1, Math.max(1, (high - low) * reach));
|
||||
}
|
||||
// The handles: IN and OUT, and a dashed line where the max cuts off.
|
||||
// The grips stay small on a short wave so they don't hide it.
|
||||
const grip = Math.round(Math.max(3, Math.min(7, rect.height * 0.12)) * scale);
|
||||
const handle = (x, color) => {
|
||||
ctx.fillStyle = color;
|
||||
ctx.fillRect(Math.round(x) - scale, 0, 2 * scale, height);
|
||||
ctx.fillRect(Math.round(x) - 4 * scale, 0, 8 * scale, grip);
|
||||
ctx.fillRect(Math.round(x) - 4 * scale, height - grip, 8 * scale, grip);
|
||||
};
|
||||
handle(startX, "#f4ffff");
|
||||
handle(endX, "#f4ffff");
|
||||
if (endX > keepX + 1) {
|
||||
ctx.strokeStyle = CUT_RED;
|
||||
ctx.lineWidth = 2 * scale;
|
||||
ctx.setLineDash([4 * scale, 3 * scale]);
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(keepX, 0);
|
||||
ctx.lineTo(keepX, height);
|
||||
ctx.stroke();
|
||||
ctx.setLineDash([]);
|
||||
}
|
||||
// The playhead while it plays, or where it paused inside the pick.
|
||||
if (state.audio && !state.audio.paused) {
|
||||
const x = xOf(state.audio.currentTime);
|
||||
ctx.fillStyle = "#ffffff";
|
||||
ctx.fillRect(x - scale / 2, 0, scale, height);
|
||||
}
|
||||
}
|
||||
|
||||
function updateFace(state) {
|
||||
const win = currentWindow(state);
|
||||
const max = maxSeconds(state);
|
||||
if (document.activeElement !== state.startInput) state.startInput.value = formatTimecode(win.start);
|
||||
if (document.activeElement !== state.endInput) state.endInput.value = formatTimecode(win.end);
|
||||
if (state.duration > 0) {
|
||||
const summary = outputSummary(win, { maxFromLink: max.fromLink && !max.known });
|
||||
state.summary.textContent = win.length > 0 ? secondsLabel(win.length) : "";
|
||||
state.summary.classList.toggle("has-cut", win.cut > 0.005);
|
||||
state.summary.title = win.cut > 0.005
|
||||
? `${summary}. Max length is ${max.value} s, so ${formatTimecode(win.keepEnd)} to ${formatTimecode(win.end)} is cut off (red). Click to move OUT to ${formatTimecode(win.keepEnd)}.`
|
||||
: `${summary}: ${formatTimecode(win.start)} to ${formatTimecode(win.keepEnd)} comes out.`;
|
||||
} else {
|
||||
state.summary.textContent = "";
|
||||
}
|
||||
draw(state);
|
||||
}
|
||||
|
||||
function writeWidget(widget, value) {
|
||||
const next = roundHundredth(value);
|
||||
if (Math.abs(Number(widget.value || 0) - next) < 0.0001) return;
|
||||
widget.value = next;
|
||||
widget.callback?.(next);
|
||||
}
|
||||
|
||||
function writeTrim(state, bounds) {
|
||||
state.writing = true;
|
||||
try {
|
||||
writeWidget(state.startWidget, bounds.start);
|
||||
// OUT at the very end stays 0, the widget's own "to the end".
|
||||
writeWidget(state.endWidget, bounds.end >= state.duration - 0.005 ? 0 : bounds.end);
|
||||
} finally {
|
||||
state.writing = false;
|
||||
}
|
||||
updateFace(state);
|
||||
state.node.setDirtyCanvas?.(true, true);
|
||||
}
|
||||
|
||||
function installDrag(state) {
|
||||
const surface = state.stage;
|
||||
const infoAt = (clientX) => {
|
||||
const rect = state.canvas.getBoundingClientRect();
|
||||
const fraction = rect.width ? Math.min(1, Math.max(0, (clientX - rect.left) / rect.width)) : 0;
|
||||
const win = currentWindow(state);
|
||||
return { fraction, win, zone: grabZone(win, state.duration, fraction, rect.width) };
|
||||
};
|
||||
surface.addEventListener("pointermove", (event) => {
|
||||
if (state.dragging || state.duration <= 0) return;
|
||||
const { zone } = infoAt(event.clientX);
|
||||
surface.style.cursor = zone === "start" || zone === "end" ? "ew-resize" : zone === "move" ? "grab" : "pointer";
|
||||
});
|
||||
surface.addEventListener("pointerdown", (event) => {
|
||||
if (event.button !== 0 || state.dragging || state.duration <= 0) return;
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
const initial = infoAt(event.clientX);
|
||||
const bounds = { start: initial.win.start, end: initial.win.end };
|
||||
const anchor = initial.fraction * state.duration;
|
||||
const downX = event.clientX;
|
||||
let moved = false;
|
||||
state.dragging = true;
|
||||
try { surface.setPointerCapture(event.pointerId); } catch (_error) { /* mouse fallback */ }
|
||||
const centred = (fraction) => {
|
||||
const span = bounds.end - bounds.start;
|
||||
return slideTrimWindow(state.duration, bounds, fraction * state.duration - span / 2 - bounds.start);
|
||||
};
|
||||
const apply = (clientX) => {
|
||||
const next = infoAt(clientX);
|
||||
if (initial.zone === "start" || initial.zone === "end") {
|
||||
const now = currentWindow(state);
|
||||
writeTrim(state, dragTrimHandle(state.duration, { start: now.start, end: now.end }, initial.zone, next.fraction, MIN_TRIM_SECONDS));
|
||||
} else if (initial.zone === "move") {
|
||||
writeTrim(state, slideTrimWindow(state.duration, bounds, next.fraction * state.duration - anchor));
|
||||
} else {
|
||||
writeTrim(state, centred(next.fraction));
|
||||
}
|
||||
};
|
||||
const move = (moveEvent) => {
|
||||
if (!(moveEvent.buttons & 1)) { finish(moveEvent); return; }
|
||||
if (!moved && Math.abs(moveEvent.clientX - downX) < 3) return;
|
||||
moved = true;
|
||||
apply(moveEvent.clientX);
|
||||
};
|
||||
const finish = (finishEvent) => {
|
||||
if (!state.dragging) return;
|
||||
state.dragging = false;
|
||||
surface.removeEventListener("pointermove", move);
|
||||
try { surface.releasePointerCapture(event.pointerId); } catch (_error) { /* already released */ }
|
||||
if (!moved && initial.zone === "jump") writeTrim(state, centred(infoAt(finishEvent?.clientX ?? downX).fraction));
|
||||
if (moved || initial.zone === "jump") {
|
||||
if (state.audio && !state.audio.paused) state.audio.currentTime = currentWindow(state).start;
|
||||
notifyAusbossChange();
|
||||
}
|
||||
};
|
||||
surface.addEventListener("pointermove", move);
|
||||
surface.addEventListener("pointerup", finish, { once: true });
|
||||
surface.addEventListener("pointercancel", finish, { once: true });
|
||||
surface.addEventListener("lostpointercapture", finish, { once: true });
|
||||
});
|
||||
}
|
||||
|
||||
function loopEnabled(node) {
|
||||
node.properties ??= {};
|
||||
return !!node.properties.ausboss_load_audio_loop;
|
||||
}
|
||||
|
||||
function installPlayer(state) {
|
||||
const audio = state.audio;
|
||||
const stop = () => {
|
||||
if (state.raf) cancelAnimationFrame(state.raf);
|
||||
state.raf = 0;
|
||||
state.playButton.textContent = "▶";
|
||||
state.playButton.classList.remove("active");
|
||||
draw(state);
|
||||
};
|
||||
const tick = () => {
|
||||
if (audio.paused) { stop(); return; }
|
||||
const win = currentWindow(state);
|
||||
if (audio.currentTime >= win.keepEnd - END_EPSILON || audio.currentTime < win.start - 0.25) {
|
||||
if (loopEnabled(state.node)) audio.currentTime = win.start;
|
||||
else { audio.pause(); audio.currentTime = win.start; stop(); return; }
|
||||
}
|
||||
draw(state);
|
||||
state.raf = requestAnimationFrame(tick);
|
||||
};
|
||||
audio.addEventListener("play", () => {
|
||||
state.playButton.textContent = "❚❚";
|
||||
state.playButton.classList.add("active");
|
||||
if (state.raf) cancelAnimationFrame(state.raf);
|
||||
state.raf = requestAnimationFrame(tick);
|
||||
}, { signal: state.abort.signal });
|
||||
audio.addEventListener("pause", stop, { signal: state.abort.signal });
|
||||
state.playButton.addEventListener("click", (event) => {
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
if (state.duration <= 0) return;
|
||||
if (!audio.paused) { audio.pause(); return; }
|
||||
const win = currentWindow(state);
|
||||
if (audio.currentTime < win.start || audio.currentTime >= win.keepEnd - END_EPSILON) audio.currentTime = win.start;
|
||||
audio.play().catch(() => stop());
|
||||
});
|
||||
state.stopPlayer = () => { audio.pause(); stop(); };
|
||||
}
|
||||
|
||||
function commitTimeInput(state, edge, input) {
|
||||
if (state.duration <= 0) return;
|
||||
const seconds = parseTimecode(input.value);
|
||||
const win = currentWindow(state);
|
||||
if (seconds === null) {
|
||||
input.value = formatTimecode(edge === "start" ? win.start : win.end);
|
||||
return;
|
||||
}
|
||||
writeTrim(state, dragTrimHandle(state.duration, { start: win.start, end: win.end }, edge, seconds / state.duration, MIN_TRIM_SECONDS));
|
||||
notifyAusbossChange();
|
||||
input.blur();
|
||||
}
|
||||
|
||||
function watchWidget(state, widget) {
|
||||
if (!widget || widget.__ausbossAudioWatch) return;
|
||||
widget.__ausbossAudioWatch = true;
|
||||
const prior = widget.callback;
|
||||
widget.callback = function (...args) {
|
||||
const result = prior?.apply(this, args);
|
||||
if (!state.writing) updateFace(state);
|
||||
return result;
|
||||
};
|
||||
}
|
||||
|
||||
function buildPanel(node) {
|
||||
if (node.__ausbossLoadAudio) return node.__ausbossLoadAudio;
|
||||
const audioWidget = findWidget(node, "audio");
|
||||
const startWidget = findWidget(node, "start_seconds");
|
||||
const endWidget = findWidget(node, "end_seconds");
|
||||
if (!audioWidget || !startWidget || !endWidget) return null;
|
||||
ensureAudioCss();
|
||||
hideCoreAudio(node);
|
||||
hideCanvasWidget(startWidget);
|
||||
hideCanvasWidget(endWidget);
|
||||
|
||||
const root = document.createElement("div");
|
||||
root.className = "ausboss-video-root ausboss-audio-root";
|
||||
const stage = document.createElement("div");
|
||||
stage.className = "ausboss-video-stage is-empty";
|
||||
stage.title = "Drag a handle to set where the sound starts or stops. Drag the middle to slide it.";
|
||||
const canvas = document.createElement("canvas");
|
||||
canvas.className = "ausboss-audio-wave";
|
||||
const status = document.createElement("div");
|
||||
status.className = "ausboss-video-status";
|
||||
status.textContent = "Choose or upload a sound file";
|
||||
const playButton = makeToolButton("▶", "Play the part that comes out");
|
||||
playButton.classList.add("ausboss-audio-play");
|
||||
const loopButton = makeToolButton("LOOP", "Play it again and again");
|
||||
stage.append(canvas, status);
|
||||
|
||||
const values = document.createElement("div");
|
||||
values.className = "ausboss-video-values";
|
||||
const makeValue = (labelText, title) => {
|
||||
const wrap = document.createElement("div");
|
||||
wrap.className = "ausboss-video-value";
|
||||
const label = document.createElement("label");
|
||||
label.textContent = labelText;
|
||||
const input = document.createElement("input");
|
||||
input.type = "text";
|
||||
input.inputMode = "decimal";
|
||||
input.placeholder = "m:ss.s";
|
||||
input.title = title;
|
||||
input.addEventListener("keydown", (event) => {
|
||||
keepKeyInField(event);
|
||||
if (event.key === "Enter") input.dispatchEvent(new Event("change"));
|
||||
});
|
||||
wrap.append(label, input);
|
||||
return { wrap, input };
|
||||
};
|
||||
const startValue = makeValue("IN", "Where the sound starts. Type seconds (12.5) or a time (0:12.5).");
|
||||
const endValue = makeValue("OUT", "Where the sound stops. Type seconds (24) or a time (0:24.0).");
|
||||
// How long the output is, beside OUT and off the wave. Red when Max
|
||||
// length cuts the pick short; the tooltip says how much.
|
||||
const summary = document.createElement("div");
|
||||
summary.className = "ausboss-audio-length";
|
||||
values.append(startValue.wrap, endValue.wrap);
|
||||
const row = document.createElement("div");
|
||||
row.className = "ausboss-audio-row";
|
||||
row.append(playButton, values, summary, loopButton);
|
||||
root.append(stage, row);
|
||||
|
||||
const widget = node.addDOMWidget(PANEL_WIDGET, "ausboss_audio", root, {
|
||||
serialize: false,
|
||||
hideOnZoom: false,
|
||||
getMinHeight: () => PANEL_MIN_HEIGHT + WIDGET_FRAME,
|
||||
});
|
||||
keepDomWidgetWidthAuto(widget);
|
||||
widget.serialize = false;
|
||||
fillNodeHeight(widget, {
|
||||
minWidth: MIN_WIDTH,
|
||||
minHeight: PANEL_MIN_HEIGHT + WIDGET_FRAME,
|
||||
minNodeSize: [MIN_WIDTH, 200],
|
||||
exactMinWidth: true,
|
||||
});
|
||||
|
||||
const audio = new Audio();
|
||||
audio.preload = "auto";
|
||||
const abort = new AbortController();
|
||||
const state = node.__ausbossLoadAudio = {
|
||||
node, root, stage, canvas, status, playButton, loopButton, summary, audio,
|
||||
startInput: startValue.input, endInput: endValue.input,
|
||||
audioWidget, startWidget, endWidget, maxWidget: findWidget(node, "max_seconds"),
|
||||
duration: 0, peaks: null, abort, writing: false, dragging: false, raf: 0, loading: 0,
|
||||
};
|
||||
|
||||
// Clicking the red length moves OUT to where the sound really ends.
|
||||
summary.addEventListener("click", (event) => {
|
||||
const win = currentWindow(state);
|
||||
if (win.cut <= 0.005) return;
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
writeTrim(state, { start: win.start, end: win.keepEnd });
|
||||
notifyAusbossChange();
|
||||
});
|
||||
|
||||
const updateLoop = () => loopButton.classList.toggle("active", loopEnabled(node));
|
||||
updateLoop();
|
||||
loopButton.addEventListener("click", (event) => {
|
||||
event.preventDefault();
|
||||
event.stopPropagation();
|
||||
node.properties.ausboss_load_audio_loop = !loopEnabled(node);
|
||||
updateLoop();
|
||||
notifyAusbossChange();
|
||||
});
|
||||
|
||||
const refresh = async () => {
|
||||
state.stopPlayer?.();
|
||||
const name = audioWidget.value;
|
||||
const ticket = ++state.loading;
|
||||
state.duration = 0;
|
||||
state.peaks = null;
|
||||
if (!name || typeof name !== "string") {
|
||||
audio.removeAttribute("src");
|
||||
stage.classList.add("is-empty");
|
||||
status.textContent = "Choose or upload a sound file";
|
||||
updateFace(state);
|
||||
return;
|
||||
}
|
||||
const parts = splitMediaName(name);
|
||||
stage.classList.add("is-empty");
|
||||
status.textContent = `Loading ${parts.filename}…`;
|
||||
const type = parseImageReference(name)?.type ?? "input";
|
||||
const route = `/view?${mediaViewQuery({ ...parts, type }, "input")}`;
|
||||
audio.src = api.apiURL(route);
|
||||
try {
|
||||
const result = await loadPeaks(name, route);
|
||||
if (ticket !== state.loading) return;
|
||||
state.duration = result.duration;
|
||||
state.peaks = result.peaks;
|
||||
stage.classList.remove("is-empty");
|
||||
updateFace(state);
|
||||
} catch (error) {
|
||||
if (ticket !== state.loading) return;
|
||||
status.textContent = `This sound could not be shown: ${error?.message || error}`;
|
||||
}
|
||||
};
|
||||
state.refresh = refresh;
|
||||
|
||||
installDrag(state);
|
||||
installPlayer(state);
|
||||
watchWidget(state, startWidget);
|
||||
watchWidget(state, endWidget);
|
||||
watchWidget(state, state.maxWidget);
|
||||
startValue.input.addEventListener("change", () => commitTimeInput(state, "start", startValue.input));
|
||||
endValue.input.addEventListener("change", () => commitTimeInput(state, "end", endValue.input));
|
||||
const observer = new ResizeObserver(() => draw(state));
|
||||
observer.observe(stage);
|
||||
state.observer = observer;
|
||||
|
||||
const priorAudioCallback = audioWidget.callback;
|
||||
audioWidget.callback = function (...args) {
|
||||
const result = priorAudioCallback?.apply(this, args);
|
||||
peakCache.delete(audioWidget.value);
|
||||
refresh();
|
||||
return result;
|
||||
};
|
||||
setTimeout(refresh, 0);
|
||||
return state;
|
||||
}
|
||||
|
||||
app.registerExtension({
|
||||
name: "ausboss.load_audio",
|
||||
beforeRegisterNodeDef(nodeType, nodeData) {
|
||||
if (nodeData?.name !== NODE_NAME) return;
|
||||
// The frontend's Upload button for an audio_upload input looks for its
|
||||
// player widget and fails without one, and it adds that player only to
|
||||
// its own audio nodes. Ask for it here, ahead of the button; the panel
|
||||
// hides it, since the wave plays the sound instead.
|
||||
const required = nodeData.input?.required;
|
||||
if (required && !required.audioUI) {
|
||||
const entries = Object.entries(required);
|
||||
const at = entries.findIndex(([name]) => name === "audio") + 1;
|
||||
entries.splice(at, 0, ["audioUI", ["AUDIO_UI", {}]]);
|
||||
nodeData.input.required = Object.fromEntries(entries);
|
||||
}
|
||||
chainCallback(nodeType.prototype, "onNodeCreated", function () {
|
||||
buildPanel(this);
|
||||
// Only for a genuinely new node: onConfigure restores a saved size
|
||||
// after this runs, so a workflow's own size still wins.
|
||||
const floor = Number(this.computeSize?.()?.[1]) || 0;
|
||||
if (floor > 0) this.setSize?.([DEFAULT_WIDTH, floor + DEFAULT_WAVE_EXTRA]);
|
||||
});
|
||||
chainCallback(nodeType.prototype, "onConfigure", function () {
|
||||
queueMicrotask(() => {
|
||||
const state = buildPanel(this);
|
||||
if (state) {
|
||||
hideCoreAudio(this);
|
||||
state.refresh?.();
|
||||
}
|
||||
});
|
||||
});
|
||||
// A wire into Max length changes what comes out; redraw when one comes or goes.
|
||||
chainCallback(nodeType.prototype, "onConnectionsChange", function () {
|
||||
const state = this.__ausbossLoadAudio;
|
||||
if (state) queueMicrotask(() => updateFace(state));
|
||||
});
|
||||
chainCallback(nodeType.prototype, "onRemoved", function () {
|
||||
const state = this.__ausbossLoadAudio;
|
||||
state?.stopPlayer?.();
|
||||
state?.abort?.abort();
|
||||
state?.observer?.disconnect();
|
||||
if (state) state.audio.removeAttribute("src");
|
||||
this.__ausbossLoadAudio = null;
|
||||
});
|
||||
},
|
||||
});
|
||||
@@ -170,7 +170,7 @@ api.addEventListener("execution_interrupted", () => settleAll());
|
||||
// second or two, so things light up while it is still looking.
|
||||
api.addEventListener(LOOK_EVENT, ({ detail }) => {
|
||||
try {
|
||||
if (!faces.size || !detail?.note) return;
|
||||
if (!faces.size || !detail?.note || isForeignRun(detail.prompt_id)) return;
|
||||
const id = String(detail.node ?? "");
|
||||
const root = app.rootGraph ?? app.graph;
|
||||
for (const face of faces) {
|
||||
@@ -183,11 +183,39 @@ api.addEventListener(LOOK_EVENT, ({ detail }) => {
|
||||
// A run that left the queue without ever reaching the node (it was deleted
|
||||
// there) would leave a face waiting for good. Once the queue is empty and a
|
||||
// face has waited a while, it stops waiting; the next touch asks again.
|
||||
let emptyQueueTimer = 0;
|
||||
let emptyQueueVersion = 0;
|
||||
function settleEmptyQueue() {
|
||||
const now = performance.now();
|
||||
let delay = Infinity;
|
||||
for (const face of faces) {
|
||||
if (!face.alive || !face.inFlight) continue;
|
||||
const left = 1501 - (now - face.askedAt);
|
||||
if (left <= 0) face.settle();
|
||||
else delay = Math.min(delay, left);
|
||||
}
|
||||
if (Number.isFinite(delay)) {
|
||||
const version = emptyQueueVersion;
|
||||
emptyQueueTimer = setTimeout(async () => {
|
||||
emptyQueueTimer = 0;
|
||||
try {
|
||||
const queue = await (await api.fetchApi("/queue")).json();
|
||||
if (version !== emptyQueueVersion) return;
|
||||
if (Array.isArray(queue?.queue_pending) && Array.isArray(queue?.queue_running)
|
||||
&& !queue.queue_pending.length && !queue.queue_running.length) settleEmptyQueue();
|
||||
} catch {
|
||||
// A failed queue read never cancels a request that may still run.
|
||||
}
|
||||
}, delay);
|
||||
}
|
||||
}
|
||||
api.addEventListener("status", ({ detail }) => {
|
||||
try {
|
||||
emptyQueueVersion += 1;
|
||||
clearTimeout(emptyQueueTimer);
|
||||
emptyQueueTimer = 0;
|
||||
if (!faces.size || detail?.exec_info?.queue_remaining !== 0) return;
|
||||
const now = performance.now();
|
||||
for (const face of faces) if (face.inFlight && now - face.askedAt > 1500) face.settle();
|
||||
settleEmptyQueue();
|
||||
} catch {
|
||||
// Never in the way of a run.
|
||||
}
|
||||
|
||||
+123
-12
@@ -19,6 +19,8 @@ import { copyToClipboard } from "../shared/clipboard.mjs";
|
||||
import { hideInputsInDef, hideWidget } from "../shared/widget_visibility.mjs";
|
||||
import { holdNodeMinWidth, pinVuePanelHeight } from "../shared/panel_layout.mjs";
|
||||
import { formatSeed, pushSeed, seedFromExecuted } from "../shared/seed_history.mjs";
|
||||
import { SEED_LOOK_MENU, SEED_LOOK_SCOPE, controlChip, nextControl, seedLook, setSeedLook } from "../shared/seed_look.mjs";
|
||||
import { gearIconSvg, loadSettings, openSettingsMenu } from "../shared/settings_menu.mjs";
|
||||
|
||||
const NODE_CLASS = "AUSBOSS_NODES_Seed";
|
||||
const CSS_ID = "ausboss-seed-css";
|
||||
@@ -28,8 +30,19 @@ const PROPERTY = "ausboss_seed_history"; // [seed, newest first]
|
||||
// in a double; a fresh seed rolled here obeys the same ceiling.
|
||||
const ROLL_MAX = 0x4000000000000;
|
||||
const CARD_HEIGHT = 158;
|
||||
const PANEL_DECLARED_HEIGHT = CARD_HEIGHT + 20; // + the frontend's wrapper insets
|
||||
// The compact look is one row: 8px card padding, a 32px row, 8px padding.
|
||||
const COMPACT_CARD_HEIGHT = 50;
|
||||
const PANEL_INSETS = 20; // the frontend's wrapper insets
|
||||
const NODE_WIDTH = 300;
|
||||
const COMPACT_NODE_WIDTH = 290;
|
||||
|
||||
function panelHeight(node) {
|
||||
return (seedLook(node) === "compact" ? COMPACT_CARD_HEIGHT : CARD_HEIGHT) + PANEL_INSETS;
|
||||
}
|
||||
|
||||
function nodeWidthFloor(node) {
|
||||
return seedLook(node) === "compact" ? COMPACT_NODE_WIDTH : NODE_WIDTH;
|
||||
}
|
||||
|
||||
let openMenu = null;
|
||||
|
||||
@@ -59,6 +72,21 @@ function ensureCss() {
|
||||
.ausboss-seed-btn:disabled{opacity:.4;cursor:default;pointer-events:none;}
|
||||
.ausboss-seed-hint{overflow:hidden;white-space:nowrap;text-overflow:ellipsis;color:#6f8886;font-size:10.5px;text-align:center;}
|
||||
.ausboss-seed-hint b{color:#9fe3dc;font-weight:600;font-family:ui-monospace,"SF Mono",Menlo,Consolas,monospace;}
|
||||
.ausboss-seed-top{display:flex;align-items:center;gap:6px;min-width:0;}
|
||||
.ausboss-seed-top .ausboss-seed-field{flex:1 1 auto;min-width:0;}
|
||||
.ausboss-seed-gear{display:grid;place-items:center;}
|
||||
.ausboss-seed-chip,.ausboss-seed-dice{display:none;flex:none;height:32px;border:1px solid #2a3437;border-radius:7px;background:#0f1516;color:#d8ecea;font:600 11.5px/1 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;cursor:pointer;pointer-events:auto;}
|
||||
.ausboss-seed-chip{min-width:56px;padding:0 7px;}
|
||||
.ausboss-seed-chip.random{border-color:rgba(0,180,170,.55);color:${BRAND};}
|
||||
.ausboss-seed-dice{width:32px;font-size:15px;}
|
||||
.ausboss-seed-chip:hover,.ausboss-seed-dice:hover{border-color:${BRAND};color:#fff;}
|
||||
.ausboss-seed-card.compact{gap:0;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-seg,.ausboss-seed-card.compact .ausboss-seed-row,.ausboss-seed-card.compact .ausboss-seed-hint{display:none;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-chip,.ausboss-seed-card.compact .ausboss-seed-dice{display:block;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-field{height:32px;padding:0 3px 0 9px;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-field input{font-size:14px;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-tag,.ausboss-seed-card.compact .ausboss-seed-icon:not(.ausboss-seed-gear){display:none;}
|
||||
.ausboss-seed-card.compact .ausboss-seed-field input{font-size:13.5px;letter-spacing:0;}
|
||||
.ausboss-seed-menu{position:fixed;z-index:10000;min-width:230px;padding:4px;border:1px solid #3a4047;border-radius:7px;background:#1c1f23;box-shadow:0 8px 28px rgba(0,0,0,.5);font:12px/1.3 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;color:#d7dde2;}
|
||||
.ausboss-seed-menu-head{padding:5px 8px 6px;border-bottom:1px solid #2c3238;color:#78908e;font:10px/1 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;letter-spacing:.08em;text-transform:uppercase;}
|
||||
.ausboss-seed-menu-item{display:block;width:100%;padding:6px 8px;border:none;border-radius:5px;background:transparent;color:inherit;font:inherit;text-align:left;cursor:pointer;}
|
||||
@@ -124,6 +152,7 @@ function render(state) {
|
||||
const linked = seedLinked(node);
|
||||
const value = seedWidget(node)?.value;
|
||||
if (document.activeElement !== state.input) state.input.value = formatSeed(Number(value));
|
||||
fitCompactNumber(state);
|
||||
state.input.disabled = linked;
|
||||
state.field.classList.toggle("linked", linked);
|
||||
state.field.title = linked ? "The seed comes from its input link" : "Click to type a seed";
|
||||
@@ -136,6 +165,11 @@ function render(state) {
|
||||
state.segStep.title = stepping
|
||||
? "Click again to step the other way"
|
||||
: "Increment the seed after each queue (click again for decrement)";
|
||||
const chip = controlChip(control);
|
||||
state.chip.textContent = chip.text;
|
||||
state.chip.title = chip.title;
|
||||
state.chip.classList.toggle("random", control === "randomize");
|
||||
state.card.classList.toggle("compact", seedLook(node) === "compact");
|
||||
state.useLast.disabled = !seeds.length;
|
||||
state.more.disabled = seeds.length < 2;
|
||||
state.hint.textContent = "";
|
||||
@@ -145,6 +179,8 @@ function render(state) {
|
||||
b.textContent = formatSeed(last);
|
||||
state.hint.append(b);
|
||||
if (control === "randomize") state.hint.append(" · rolls a new seed each queue");
|
||||
// The compact look has no hint line: the last run shows on the number.
|
||||
if (seedLook(node) === "compact") state.field.title = `${state.field.title}. Last run: ${formatSeed(last)}`;
|
||||
} else {
|
||||
state.hint.textContent = control === "randomize"
|
||||
? "rolls a new seed each queue"
|
||||
@@ -152,6 +188,16 @@ function render(state) {
|
||||
}
|
||||
}
|
||||
|
||||
// The compact row is narrow, so a long seed gets smaller digits instead of
|
||||
// being cut off: monospace digits are about 0.6 of the font size wide.
|
||||
function fitCompactNumber(state) {
|
||||
const { input } = state;
|
||||
if (seedLook(state.node) !== "compact") { input.style.fontSize = ""; return; }
|
||||
const digits = Math.max(1, String(input.value || "").length);
|
||||
const room = input.clientWidth || 100;
|
||||
input.style.fontSize = `${Math.max(8, Math.min(13.5, room / (0.64 * digits))).toFixed(1)}px`;
|
||||
}
|
||||
|
||||
function showMenu(state) {
|
||||
closeMenu();
|
||||
const seeds = history(state.node);
|
||||
@@ -241,7 +287,9 @@ function buildPanel(node) {
|
||||
input.inputMode = "numeric";
|
||||
input.spellcheck = false;
|
||||
const copy = button("ausboss-seed-icon", "⧉", "Copy the seed");
|
||||
field.append(tag, input, copy);
|
||||
const gear = button("ausboss-seed-icon ausboss-seed-gear", "", "Seed settings: full or compact look");
|
||||
gear.innerHTML = gearIconSvg(12);
|
||||
field.append(tag, input, copy, gear);
|
||||
field.addEventListener("pointerdown", (event) => event.stopPropagation());
|
||||
|
||||
const seg = el("div", "ausboss-seed-seg");
|
||||
@@ -257,11 +305,16 @@ function buildPanel(node) {
|
||||
row.append(newSeed, useLast, more);
|
||||
|
||||
const hint = el("div", "ausboss-seed-hint");
|
||||
card.append(field, seg, row, hint);
|
||||
// Compact look: the mode chip and a dice sit on the number's row.
|
||||
const chip = button("ausboss-seed-chip", "Fixed");
|
||||
const dice = button("ausboss-seed-dice", "🎲", "Roll a fresh seed and pin it (Fixed)");
|
||||
const top = el("div", "ausboss-seed-top");
|
||||
top.append(field, chip, dice);
|
||||
card.append(top, seg, row, hint);
|
||||
root.append(card);
|
||||
|
||||
const state = (node.__ausbossSeed = {
|
||||
node, root, field, tag, input, copy, segRandom, segFixed, segStep, newSeed, useLast, more, hint,
|
||||
node, root, card, field, tag, input, copy, gear, chip, dice, segRandom, segFixed, segStep, newSeed, useLast, more, hint,
|
||||
});
|
||||
|
||||
const commitTyped = () => {
|
||||
@@ -304,6 +357,31 @@ function buildPanel(node) {
|
||||
notifyAusbossChange();
|
||||
});
|
||||
newSeed.addEventListener("click", () => { setSeed(node, rollSeed()); render(state); });
|
||||
dice.addEventListener("click", () => { setSeed(node, rollSeed()); render(state); });
|
||||
// The chip walks the same modes as the full card's buttons, and starts a
|
||||
// new run the same way: into Random rolls now, Fixed into +1 steps now.
|
||||
chip.addEventListener("click", () => {
|
||||
const current = controlWidget(node)?.value ?? "fixed";
|
||||
const next = nextControl(current);
|
||||
setControl(node, next);
|
||||
if (!seedLinked(node)) {
|
||||
const value = Number(seed.value) || 0;
|
||||
if (next === "randomize") setSeed(node, rollSeed(), { pin: false });
|
||||
else if (current === "fixed" && next === "increment") setSeed(node, value + 1, { pin: false });
|
||||
}
|
||||
render(state);
|
||||
notifyAusbossChange();
|
||||
});
|
||||
gear.addEventListener("click", () => {
|
||||
openSettingsMenu({
|
||||
scope: SEED_LOOK_SCOPE,
|
||||
schema: SEED_LOOK_MENU,
|
||||
anchor: gear.getBoundingClientRect(),
|
||||
title: "Seed settings",
|
||||
initial: { look: seedLook(node) },
|
||||
onChange: (values) => applyLook(state, values.look),
|
||||
});
|
||||
});
|
||||
useLast.addEventListener("click", () => {
|
||||
const seeds = history(node);
|
||||
if (seeds.length) { setSeed(node, seeds[0]); render(state); }
|
||||
@@ -318,7 +396,7 @@ function buildPanel(node) {
|
||||
const widget = node.addDOMWidget(WIDGET_NAME, "ausboss_seed", root, {
|
||||
serialize: false,
|
||||
hideOnZoom: false,
|
||||
getMinHeight: () => PANEL_DECLARED_HEIGHT,
|
||||
getMinHeight: () => panelHeight(node),
|
||||
});
|
||||
keepDomWidgetWidthAuto(widget);
|
||||
// Not saved with the workflow either: options.serialize only keeps it out
|
||||
@@ -327,18 +405,20 @@ function buildPanel(node) {
|
||||
// A constant-height card: pinned on purpose (see
|
||||
// tests/panel_guards.test.mjs, fixedByDesign).
|
||||
widget.computeSize = (width) => [
|
||||
Math.max(NODE_WIDTH, Number(width || node.size?.[0] || NODE_WIDTH)),
|
||||
PANEL_DECLARED_HEIGHT,
|
||||
Math.max(nodeWidthFloor(node), Number(width || node.size?.[0] || nodeWidthFloor(node))),
|
||||
panelHeight(node),
|
||||
];
|
||||
// Pinned in Nodes 2.0 as well, where a node can be made taller than its card.
|
||||
pinVuePanelHeight(widget);
|
||||
widget.options.minNodeSize = [NODE_WIDTH, 120];
|
||||
widget.options.minNodeSize = [nodeWidthFloor(node), 60];
|
||||
// The frontend skips a pinned card's width, so its floor is held here.
|
||||
holdNodeMinWidth(widget, NODE_WIDTH);
|
||||
holdNodeMinWidth(widget, nodeWidthFloor(node));
|
||||
state.widget = widget;
|
||||
|
||||
new ResizeObserver(() => fitCompactNumber(state)).observe(input);
|
||||
render(state);
|
||||
node.setSize?.([
|
||||
Math.max(node.size?.[0] ?? 0, NODE_WIDTH),
|
||||
Math.max(node.size?.[0] ?? 0, nodeWidthFloor(node)),
|
||||
node.computeSize?.()[1] ?? node.size?.[1],
|
||||
]);
|
||||
// The card is a fixed-height row: width may grow, but a corner drag
|
||||
@@ -356,18 +436,49 @@ function buildPanel(node) {
|
||||
return state;
|
||||
}
|
||||
|
||||
// Switch looks: the card, the node's floor and its height follow. Going
|
||||
// compact also makes the node as narrow as the compact row allows, and
|
||||
// going full widens it back to the full card's floor.
|
||||
function applyLook(state, look) {
|
||||
const { node } = state;
|
||||
const before = seedLook(node);
|
||||
const after = setSeedLook(node, look);
|
||||
if (before === after) return;
|
||||
render(state);
|
||||
if (state.widget) {
|
||||
state.widget.options.minNodeSize = [nodeWidthFloor(node), 60];
|
||||
holdNodeMinWidth(state.widget, nodeWidthFloor(node));
|
||||
}
|
||||
const width = after === "compact" ? COMPACT_NODE_WIDTH : Math.max(node.size?.[0] ?? 0, NODE_WIDTH);
|
||||
node.setSize?.([width, node.computeSize?.()[1] ?? node.size?.[1]]);
|
||||
node.setDirtyCanvas?.(true, true);
|
||||
notifyAusbossChange();
|
||||
}
|
||||
|
||||
app.registerExtension({
|
||||
name: "AusBoss.Seed",
|
||||
beforeRegisterNodeDef(nodeType, nodeData) {
|
||||
if (nodeData?.name !== NODE_CLASS) return;
|
||||
hideInputsInDef(nodeData, ["seed"]);
|
||||
chainCallback(nodeType.prototype, "onNodeCreated", function () {
|
||||
buildPanel(this);
|
||||
// A new node starts in the look last picked from any Seed's gear. A
|
||||
// loaded one keeps its own: onConfigure restores its properties after.
|
||||
if (loadSettings(SEED_LOOK_SCOPE, SEED_LOOK_MENU).look === "compact") setSeedLook(this, "compact");
|
||||
const state = buildPanel(this);
|
||||
if (state && seedLook(this) === "compact") {
|
||||
this.setSize?.([COMPACT_NODE_WIDTH, this.computeSize?.()[1] ?? this.size?.[1]]);
|
||||
}
|
||||
});
|
||||
chainCallback(nodeType.prototype, "onConfigure", function () {
|
||||
queueMicrotask(() => {
|
||||
const state = buildPanel(this);
|
||||
if (state) render(state);
|
||||
if (!state) return;
|
||||
render(state);
|
||||
// A saved compact Seed: lower the floor to the compact row's.
|
||||
if (state.widget) {
|
||||
state.widget.options.minNodeSize = [nodeWidthFloor(this), 60];
|
||||
holdNodeMinWidth(state.widget, nodeWidthFloor(this));
|
||||
}
|
||||
});
|
||||
});
|
||||
chainCallback(nodeType.prototype, "onConnectionsChange", function () {
|
||||
|
||||
@@ -64,7 +64,7 @@ export function restoreOutputLinks(node, outputs, graph) {
|
||||
const targetNode = graph.getNodeById(target.nodeId);
|
||||
if (!targetNode) continue;
|
||||
const current = lookupLink(graph, targetNode.inputs?.[target.slot]?.link);
|
||||
if (current?.origin_id === node.id && current.origin_slot === output.slot) continue; // never stolen
|
||||
if (current?.origin_id === node.id) continue; // never stolen
|
||||
linkSlots(node, output.slot, targetNode, target.slot);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@ const emptyWidget = (inputs, name) => !linked(inputs?.[name]) && blank(inputs?.[
|
||||
|
||||
const picture = (name) => (inputs) => (emptyWidget(inputs, name) ? { input: name, kind: "picture" } : null);
|
||||
const video = (name) => (inputs) => (emptyWidget(inputs, name) ? { input: name, kind: "video" } : null);
|
||||
const sound = (name) => (inputs) => (emptyWidget(inputs, name) ? { input: name, kind: "sound file" } : null);
|
||||
|
||||
function videoSource(inputs) {
|
||||
const mode = inputs?.source_mode;
|
||||
@@ -38,6 +39,7 @@ export const SOURCE_LOADERS = Object.freeze({
|
||||
AUSBOSS_NODES_ImageCropRotatePad: picture("image"),
|
||||
// A wired source_image replaces the file, so the file may stay blank.
|
||||
AUSBOSS_NODES_LoadImagePad: (inputs) => (linked(inputs?.source_image) ? null : picture("image")(inputs)),
|
||||
AUSBOSS_NODES_LoadAudio: sound("audio"),
|
||||
AUSBOSS_NODES_LoadVideo: video("video"),
|
||||
AUSBOSS_NODES_VideoCropRotatePad: videoSource,
|
||||
AUSBOSS_NODES_VideoCropRotatePadClip: videoSource,
|
||||
@@ -110,7 +112,8 @@ export function emptySourceMessage(found) {
|
||||
if (!first) return "";
|
||||
const more = found.length - 1;
|
||||
const tail = more > 0 ? ` (and ${more} more node${more === 1 ? "" : "s"})` : "";
|
||||
return `Load a ${first.kind === "video" ? "video" : "picture"} first: ${first.title}${tail}`;
|
||||
const noun = first.kind === "video" || first.kind === "sound file" ? first.kind : "picture";
|
||||
return `Load a ${noun} first: ${first.title}${tail}`;
|
||||
}
|
||||
|
||||
// "Save Image: exact_name may not ..." names the input it is about, after
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
// Seed 🆎's two looks, picked from the gear on its card: the full card
|
||||
// (the default), or "compact", one short row with the number, a mode chip
|
||||
// and a new-seed button. The look is kept in the node's properties, so the
|
||||
// node's inputs, saved values and the prompt it sends are the same in both,
|
||||
// and the last look picked is what new Seed nodes start with.
|
||||
//
|
||||
// Data and decisions only (tests/seed_look.test.mjs); js/seed/index.js
|
||||
// draws the card.
|
||||
|
||||
export const SEED_LOOK_PROPERTY = "ausboss_seed_look";
|
||||
export const SEED_LOOKS = ["full", "compact"];
|
||||
export const SEED_LOOK_SCOPE = "seed_look";
|
||||
|
||||
export function seedLook(node) {
|
||||
return node?.properties?.[SEED_LOOK_PROPERTY] === "compact" ? "compact" : "full";
|
||||
}
|
||||
|
||||
// The full card leaves no property behind, so a node set back to it is
|
||||
// saved exactly as one that was never changed.
|
||||
export function setSeedLook(node, look) {
|
||||
if (!node) return "full";
|
||||
node.properties ??= {};
|
||||
if (look === "compact") node.properties[SEED_LOOK_PROPERTY] = "compact";
|
||||
else delete node.properties[SEED_LOOK_PROPERTY];
|
||||
return seedLook(node);
|
||||
}
|
||||
|
||||
// The gear menu (js/shared/settings_menu.mjs). The pick is also kept as the
|
||||
// look new Seed nodes start with.
|
||||
export const SEED_LOOK_MENU = [
|
||||
{
|
||||
key: "look",
|
||||
label: "Look",
|
||||
type: "choice",
|
||||
options: SEED_LOOKS,
|
||||
default: "full",
|
||||
hint: "How this Seed node looks. New Seed nodes start the same way.",
|
||||
optionHints: {
|
||||
full: "the whole card: mode buttons, New seed, Use last run, and the seeds it ran with.",
|
||||
compact: "one short row: the number, a mode chip you tap to change, and a dice for a new seed.",
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
// The compact row's chip: tap to go Random -> Fixed -> Step +1 -> Step -1
|
||||
// -> Random. Values are the frontend's control_after_generate choices.
|
||||
const CYCLE = ["randomize", "fixed", "increment", "decrement"];
|
||||
|
||||
export function nextControl(control) {
|
||||
const index = CYCLE.indexOf(control);
|
||||
return CYCLE[(index + 1) % CYCLE.length] ?? "fixed";
|
||||
}
|
||||
|
||||
export function controlChip(control) {
|
||||
switch (control) {
|
||||
case "randomize": return { text: "Random", title: "Rolls a new seed after each run. Tap for Fixed." };
|
||||
case "increment": return { text: "+1", title: "Adds 1 after each run. Tap for -1." };
|
||||
case "decrement": return { text: "−1", title: "Takes 1 off after each run. Tap for Random." };
|
||||
default: return { text: "Fixed", title: "Keeps this seed for every run. Tap for +1." };
|
||||
}
|
||||
}
|
||||
@@ -1046,7 +1046,7 @@ export function pieceAt(planes, index, { sizes, inside, adding = true, ranks = n
|
||||
const size = sizes?.[piece] ?? 0;
|
||||
if (!size) continue;
|
||||
const picked = inside?.[piece] ?? 0;
|
||||
const slack = Math.max(4, size * NEARLY);
|
||||
const slack = Math.min(size - 1, Math.max(4, size * NEARLY));
|
||||
if (adding ? size - picked > slack : picked > slack) return piece;
|
||||
}
|
||||
return -1;
|
||||
|
||||
+48
-15
@@ -141,11 +141,12 @@ const TOUCH_REACH = 2;
|
||||
// The areas of picked things a picture keeps, as the node sent them.
|
||||
const AREAS_KEPT = 96;
|
||||
// Pictures the faces of a page have shown, newest last. A picture keeps its
|
||||
// pieces and the picked areas it has shown, so a tab switch, an undo or a
|
||||
// second node on the same picture costs nothing.
|
||||
// pieces and the picked areas it has shown, so a tab switch, an undo or
|
||||
// another visit to the same picture costs nothing. Results belong to one face.
|
||||
const PICTURES_KEPT = 3;
|
||||
const STATES_KEPT = 14;
|
||||
const pictures = new Map();
|
||||
let pictureSerial = 0;
|
||||
// A face asks for a run again on its own at most this often in a row.
|
||||
const RETRIES = 2;
|
||||
// The long side of the small copy the masks are worked on, when the face
|
||||
@@ -284,13 +285,14 @@ const widgetByName = (node, name) => node.widgets?.find((widget) => widget?.name
|
||||
|
||||
// ---- the pictures a page has shown ---------------------------------------
|
||||
|
||||
function pictureFor(note) {
|
||||
function pictureFor(note, face) {
|
||||
const width = Math.round(Number(note.width));
|
||||
const height = Math.round(Number(note.height));
|
||||
const scale = Number(note.scale) > 0 ? Number(note.scale) : 1;
|
||||
let entry = pictures.get(note.key);
|
||||
const cacheKey = face ? `${face.pictureId ??= ++pictureSerial}|${note.key}` : note.key;
|
||||
let entry = pictures.get(cacheKey);
|
||||
if (entry && (entry.width !== width || entry.height !== height)) entry = null;
|
||||
pictures.delete(note.key);
|
||||
pictures.delete(cacheKey);
|
||||
entry ??= {
|
||||
key: note.key,
|
||||
width,
|
||||
@@ -308,7 +310,7 @@ function pictureFor(note) {
|
||||
nameSeeds: new Map(),
|
||||
states: new Map(),
|
||||
};
|
||||
pictures.set(note.key, entry);
|
||||
pictures.set(cacheKey, entry);
|
||||
while (pictures.size > PICTURES_KEPT) pictures.delete(pictures.keys().next().value);
|
||||
return entry;
|
||||
}
|
||||
@@ -386,7 +388,7 @@ function validNote(note) {
|
||||
// whether the picture has points left to ask about.
|
||||
const piecesTag = (pieces) => `${pieces?.list?.length ?? 0}:${(Array.isArray(pieces?.planes) ? pieces.planes : []).map((file) => file?.filename).join(",")}`;
|
||||
|
||||
async function loadPieces(entry, pieces) {
|
||||
async function loadPieces(entry, pieces, generation) {
|
||||
const tag = piecesTag(pieces);
|
||||
const list = (Array.isArray(pieces.list) ? pieces.list : [])
|
||||
.filter((piece) => piece && Number.isFinite(Number(piece.x)) && Number.isFinite(Number(piece.y)))
|
||||
@@ -410,6 +412,7 @@ async function loadPieces(entry, pieces) {
|
||||
});
|
||||
const files = (Array.isArray(pieces.planes) ? pieces.planes : []).filter(isFile);
|
||||
const images = await Promise.all(files.map((file) => loadImage(viewUrl(file, entry.key))));
|
||||
if (entry.generation !== generation) return;
|
||||
const planes = packPlanes(images.map((image) => readPixels(image, entry.pw, entry.ph)), entry.pw, entry.ph);
|
||||
const sizes = pieceSizes(planes, list.length);
|
||||
const overlaps = pieceOverlaps(planes, list.length);
|
||||
@@ -1401,7 +1404,7 @@ function syncTools(face) {
|
||||
// A click that waits for the look can be taken back like a pick.
|
||||
const waiting = live && face.pending.length > 0;
|
||||
face.undo.disabled = !live || (!some && !face.past.length && !waiting);
|
||||
face.clear.disabled = !some && !waiting;
|
||||
face.clear.disabled = !some && !waiting && !String(face.touches?.value ?? "").trim();
|
||||
if (face.lookButton) {
|
||||
const offer = live && face.snap && !face.held && !face.inFlight && !face.pic.scoped && Boolean(face.host.lookOnButton?.());
|
||||
face.lookButton.style.display = offer ? "" : "none";
|
||||
@@ -1480,6 +1483,28 @@ function ownLoader(node) {
|
||||
// for: a crop that is being dragged changes them many times a second.
|
||||
const OWN_SETTLE_MS = 700;
|
||||
|
||||
// One callback per source widget; removing a face removes its subscription.
|
||||
const sourceWatchers = new WeakMap();
|
||||
function sourceListeners(widget) {
|
||||
let listeners = sourceWatchers.get(widget);
|
||||
if (!listeners) {
|
||||
listeners = new Set();
|
||||
sourceWatchers.set(widget, listeners);
|
||||
chainCallback(widget, "callback", () => {
|
||||
for (const listener of listeners) listener();
|
||||
});
|
||||
}
|
||||
return listeners;
|
||||
}
|
||||
|
||||
function watchSource(face, widget, changed) {
|
||||
if (face.watchedSources.has(widget)) return;
|
||||
face.watchedSources.add(widget);
|
||||
const listeners = sourceListeners(widget);
|
||||
listeners.add(changed);
|
||||
face.forgetSources.push(() => listeners.delete(changed));
|
||||
}
|
||||
|
||||
// Show the loader's picture without a press on Show picture: the same run
|
||||
// that button asks for. Only ever in answer to something the person did (a
|
||||
// file chosen, a setting changed, a wire made), never while a workflow is
|
||||
@@ -1520,9 +1545,8 @@ function followOwnLoader(face, now = false) {
|
||||
};
|
||||
for (const widget of upstream.widgets ?? []) {
|
||||
if (!widget || face.watchedSources.has(widget)) continue;
|
||||
face.watchedSources.add(widget);
|
||||
// A workflow being opened sets its values too: that is not the person.
|
||||
chainCallback(widget, "callback", () => { if (face.alive && !face.host.loading?.()) later(); });
|
||||
watchSource(face, widget, () => { if (face.alive && !face.host.loading?.()) later(); });
|
||||
}
|
||||
if (now) later();
|
||||
}
|
||||
@@ -1552,8 +1576,7 @@ function syncSource(face) {
|
||||
const url = source?.url ?? "";
|
||||
const watched = loaderWidget(face.node);
|
||||
if (watched && !face.watchedSources.has(watched)) {
|
||||
face.watchedSources.add(watched);
|
||||
chainCallback(watched, "callback", () => queueMicrotask(() => { if (face.alive) syncState(face); }));
|
||||
watchSource(face, watched, () => queueMicrotask(() => { if (face.alive) syncState(face); }));
|
||||
}
|
||||
if (url === face.sourceUrl) return;
|
||||
face.sourceUrl = url;
|
||||
@@ -1791,8 +1814,8 @@ function show(face, entry, note, answered, { restored = false, own = false, inte
|
||||
refreshHover(face);
|
||||
draw(face);
|
||||
drawInk(face);
|
||||
wantFine(face);
|
||||
if (restored) return;
|
||||
wantFine(face);
|
||||
const waited = settlePending(face);
|
||||
// More is on its way (the look goes on, or a run sent behind it): what to
|
||||
// ask next is decided when the last of it is in.
|
||||
@@ -1842,7 +1865,8 @@ async function takeNote(face, note, { restored = false, interim = false } = {})
|
||||
}
|
||||
const turn = ++face.turn;
|
||||
const sentStamp = sent?.stamp ?? "";
|
||||
const entry = pictureFor(note);
|
||||
const entry = pictureFor(note, face);
|
||||
const generation = entry.generation = (entry.generation ?? 0) + 1;
|
||||
// How many looks at this picture have come back, and how far through its
|
||||
// list of words the node is: an early click waits for the words.
|
||||
if (own && sent.ask === "scope") entry.looks = (entry.looks ?? 0) + 1;
|
||||
@@ -1854,12 +1878,13 @@ async function takeNote(face, note, { restored = false, interim = false } = {})
|
||||
const jobs = [];
|
||||
if (!entry.image || entry.file !== note.picture.filename) {
|
||||
jobs.push(loadImage(viewUrl(note.picture, note.key)).then((image) => {
|
||||
if (entry.generation !== generation) return;
|
||||
entry.image = image;
|
||||
entry.file = note.picture.filename;
|
||||
}));
|
||||
}
|
||||
if (note.pieces && typeof note.pieces === "object" && piecesTag(note.pieces) !== entry.piecesTag) {
|
||||
jobs.push(loadPieces(entry, note.pieces));
|
||||
jobs.push(loadPieces(entry, note.pieces, generation));
|
||||
} else if (note.pieces && typeof note.pieces === "object") {
|
||||
entry.scoped = note.pieces.more !== true;
|
||||
}
|
||||
@@ -1909,6 +1934,7 @@ async function takeNote(face, note, { restored = false, interim = false } = {})
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (!face.alive || turn !== face.turn || entry.generation !== generation) return;
|
||||
if (answered) remember(entry, stamp, answered);
|
||||
if (fine) entry.fine = fine;
|
||||
if (typeof note.fine?.trouble === "string" && note.fine.trouble) {
|
||||
@@ -2870,6 +2896,7 @@ export function mountTouchStage(node, host) {
|
||||
sourceEpoch: 0,
|
||||
sentEpoch: 0,
|
||||
watchedSources: new WeakSet(),
|
||||
forgetSources: [],
|
||||
// One of the pack's loaders wired straight in: what it was last asked for.
|
||||
ownSeen: "",
|
||||
ownTimer: 0,
|
||||
@@ -2944,8 +2971,11 @@ export function mountTouchStage(node, host) {
|
||||
face.active = 0;
|
||||
face.fresh = 0;
|
||||
if (!face.items.length) {
|
||||
writeTouches(face, "");
|
||||
readItems(face);
|
||||
face.chipsShown = null;
|
||||
syncReadout(face);
|
||||
syncTools(face);
|
||||
return;
|
||||
}
|
||||
change(face, []);
|
||||
@@ -3110,6 +3140,9 @@ export function mountTouchStage(node, host) {
|
||||
clearTimeout(face.ownTimer);
|
||||
clearTimeout(face.dwell);
|
||||
clearTimeout(face.fineTimer);
|
||||
clearTimeout(face.pendingTimer);
|
||||
for (const forget of face.forgetSources) forget();
|
||||
face.forgetSources.length = 0;
|
||||
if (face.frameRequest) cancelAnimationFrame(face.frameRequest);
|
||||
abort.abort();
|
||||
};
|
||||
|
||||
@@ -384,6 +384,16 @@ const CARDS = {
|
||||
{ widget: "max_frames", label: "Limit" },
|
||||
],
|
||||
},
|
||||
AUSBOSS_NODES_LoadAudio: {
|
||||
// The wave, IN and OUT live in the panel under the card (js/load_audio).
|
||||
minWidth: 280, first: true, hide: ["upload"],
|
||||
rows: [
|
||||
{ widget: "audio", label: "Source", kind: "select",
|
||||
button: { text: "Upload", title: "Upload a sound file into ComfyUI's input folder", onClick: (node) => node.widgets?.find((w) => w.name === "upload")?.callback?.() } },
|
||||
{ widget: "max_seconds", label: "Max length", suffix: "s", decimals: 1, trimZeros: true,
|
||||
title: "The longest the sound may be. Anything past it is cut off and shows in red. 0 means no limit." },
|
||||
],
|
||||
},
|
||||
AUSBOSS_NODES_LoadImagePad: {
|
||||
minWidth: 340, first: true, hide: ["upload"],
|
||||
rows: [
|
||||
|
||||
@@ -1557,5 +1557,31 @@
|
||||
"AUSBOSS_NODES_WorkflowSwitches": {
|
||||
"display_name": "工作流开关 🆎",
|
||||
"description": "用一张小卡片开关工作流的各个部分。选中组成一个部分的节点，例如一个框和它的保存节点，按 + Switch：它们会得到一个 off | on 开关，名字由你定。每个组也可以有自己的开关。off 会旁路这些节点，图片仍然传到下一步（也可以设置为静音）。on 让它们重新运行。开关也可以改设置，而不是关闭节点：分别保存节点在 on 和 off 时的值，点一下就能把 Steps 设为 8 并打开一行 LoRA。按 Done，节点会缩成只有标签和开关。它从不运行，也没有连线。"
|
||||
},
|
||||
"AUSBOSS_NODES_LoadAudio": {
|
||||
"display_name": "加载音频 🆎",
|
||||
"description": "加载声音文件，只输出你选中的部分。节点把声音画成波形：拖动两个手柄设置起点和终点，按播放只听这一段。把最大长度设为下一步能接收的最长声音，超出的部分会显示为红色并被剪掉，运行前就能看到输出的内容。",
|
||||
"inputs": {
|
||||
"audio": {
|
||||
"name": "音频"
|
||||
},
|
||||
"start_seconds": {
|
||||
"name": "起始秒数"
|
||||
},
|
||||
"end_seconds": {
|
||||
"name": "结束秒数"
|
||||
},
|
||||
"max_seconds": {
|
||||
"name": "最大秒数"
|
||||
}
|
||||
},
|
||||
"outputs": {
|
||||
"0": {
|
||||
"name": "音频"
|
||||
},
|
||||
"1": {
|
||||
"name": "秒数"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
"""Trimmed audio decoding for Load Audio.
|
||||
|
||||
The window rules live in ``audio_window`` so the node and its tests agree on
|
||||
what one Run hands on; ``js/load_audio/audio_window.mjs`` mirrors them for the
|
||||
face. Decoding counts samples from the start of the sound track and stops as
|
||||
soon as the window is full, so a short pick from a long file never decodes
|
||||
the whole file.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
from pathlib import Path
|
||||
|
||||
import av
|
||||
import numpy as np
|
||||
import torch
|
||||
|
||||
from ._execution_helpers import raise_if_interrupted
|
||||
|
||||
try:
|
||||
import folder_paths
|
||||
except ImportError: # offline tests
|
||||
folder_paths = None
|
||||
|
||||
AUDIO_EXTENSIONS = {
|
||||
".aac",
|
||||
".aif",
|
||||
".aiff",
|
||||
".flac",
|
||||
".m4a",
|
||||
".mp3",
|
||||
".oga",
|
||||
".ogg",
|
||||
".opus",
|
||||
".wav",
|
||||
".webm",
|
||||
".wma",
|
||||
}
|
||||
# Video files carry sound too: a song is often only on hand inside a clip.
|
||||
SOUND_IN_VIDEO_EXTENSIONS = {".mkv", ".mov", ".mp4", ".m4v"}
|
||||
|
||||
FALLBACK_SAMPLE_RATE = 44100
|
||||
# Shorter than this is no window at all; the face keeps its handles this far apart.
|
||||
MIN_WINDOW_SECONDS = 0.1
|
||||
|
||||
|
||||
def _number(value, default: float = 0.0) -> float:
|
||||
try:
|
||||
number = float(value)
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
return number if math.isfinite(number) else default
|
||||
|
||||
|
||||
def list_input_audio() -> list[str]:
|
||||
"""Sound files (and videos, for their sound) in ComfyUI's input folder."""
|
||||
if folder_paths is None:
|
||||
return [""]
|
||||
root = Path(folder_paths.get_input_directory())
|
||||
kinds = AUDIO_EXTENSIONS | SOUND_IN_VIDEO_EXTENSIONS
|
||||
results = [
|
||||
path.relative_to(root).as_posix()
|
||||
for path in root.rglob("*")
|
||||
if path.is_file() and not path.name.startswith(".") and path.suffix.lower() in kinds
|
||||
]
|
||||
return sorted(results, key=str.casefold) or [""]
|
||||
|
||||
|
||||
def audio_window(start_seconds, end_seconds, max_seconds=0.0, duration=None) -> dict:
|
||||
"""The part of a sound file one Run hands on.
|
||||
|
||||
end 0 means "to the end of the file". max_seconds above 0 caps the
|
||||
window's length: the pick keeps its start and anything past
|
||||
start + max_seconds is cut off. ``duration`` is the file's length when it
|
||||
is known; None leaves an open end open.
|
||||
|
||||
Returns start, end (None when open), the end the person picked
|
||||
(``picked_end``) and how many seconds the cap cut off (``cut``).
|
||||
"""
|
||||
start = max(0.0, _number(start_seconds))
|
||||
picked_end = _number(end_seconds)
|
||||
end = picked_end if picked_end > 0 else None
|
||||
if duration is not None:
|
||||
length = max(0.0, _number(duration))
|
||||
start = min(start, length)
|
||||
end = length if end is None else min(end, length)
|
||||
if end is not None:
|
||||
end = max(start, end)
|
||||
picked = end
|
||||
limit = max(0.0, _number(max_seconds))
|
||||
if limit > 0 and (end is None or end - start > limit):
|
||||
end = start + limit
|
||||
if duration is not None:
|
||||
end = min(end, max(0.0, _number(duration)))
|
||||
cut = 0.0
|
||||
if picked is not None and end is not None:
|
||||
cut = max(0.0, picked - end)
|
||||
return {"start": start, "end": end, "picked_end": picked, "cut": cut}
|
||||
|
||||
|
||||
def decode_audio_window(path: Path, start_seconds, end_seconds, max_seconds=0.0) -> dict:
|
||||
"""ComfyUI AUDIO for the window ``audio_window`` describes.
|
||||
|
||||
Raises a plain ValueError for a file with no sound, or a start at or past
|
||||
the end of the sound.
|
||||
"""
|
||||
window = audio_window(start_seconds, end_seconds, max_seconds)
|
||||
start = window["start"]
|
||||
with av.open(str(path)) as container:
|
||||
stream = next((candidate for candidate in container.streams if candidate.type == "audio"), None)
|
||||
if stream is None:
|
||||
raise ValueError(f"{path.name} has no sound in it.")
|
||||
rate = int(stream.rate or FALLBACK_SAMPLE_RATE)
|
||||
first = round(start * rate)
|
||||
last = None if window["end"] is None else round(window["end"] * rate)
|
||||
resampler = av.AudioResampler(format="fltp", layout=stream.layout, rate=rate)
|
||||
chunks: list[np.ndarray] = []
|
||||
position = 0
|
||||
|
||||
def take(frame) -> None:
|
||||
nonlocal position
|
||||
for resampled in resampler.resample(frame):
|
||||
data = resampled.to_ndarray()
|
||||
begin = position
|
||||
position += data.shape[1]
|
||||
if position <= first:
|
||||
continue
|
||||
low = max(0, first - begin)
|
||||
high = data.shape[1] if last is None else min(data.shape[1], last - begin)
|
||||
if high > low:
|
||||
chunks.append(data[:, low:high])
|
||||
|
||||
for frame in container.decode(stream):
|
||||
raise_if_interrupted()
|
||||
take(frame)
|
||||
if last is not None and position >= last:
|
||||
break
|
||||
else:
|
||||
take(None) # the resampler hands back what it still holds
|
||||
if not chunks:
|
||||
if position == 0:
|
||||
raise ValueError(f"{path.name} has no sound in it.")
|
||||
raise ValueError(
|
||||
f"The start ({start:.2f} s) is past the end of {path.name}, "
|
||||
f"which is {position / rate:.2f} s long. Drag the start back into the sound."
|
||||
)
|
||||
data = np.concatenate(chunks, axis=1).astype(np.float32, copy=False)
|
||||
return {
|
||||
"waveform": torch.from_numpy(np.ascontiguousarray(data)).unsqueeze(0),
|
||||
"sample_rate": rate,
|
||||
}
|
||||
|
||||
|
||||
__all__ = [
|
||||
"AUDIO_EXTENSIONS",
|
||||
"MIN_WINDOW_SECONDS",
|
||||
"SOUND_IN_VIDEO_EXTENSIONS",
|
||||
"audio_window",
|
||||
"decode_audio_window",
|
||||
"list_input_audio",
|
||||
]
|
||||
@@ -170,16 +170,21 @@ def _core_node(key: str):
|
||||
return node if hasattr(node, "execute") else None
|
||||
|
||||
|
||||
def _model_stamp(name: str):
|
||||
path = folder_paths.get_full_path(MODEL_FOLDER, name) if folder_paths is not None else None
|
||||
if not path:
|
||||
raise FileNotFoundError(NOT_FOUND.format(name=name) if list_subject_models() else NEEDS_MODEL)
|
||||
info = os.stat(path)
|
||||
return (path, info.st_mtime_ns, info.st_size)
|
||||
|
||||
|
||||
def _load(name: str):
|
||||
"""The model, through ComfyUI's own loader node, as a workflow would
|
||||
load it. Kept while its file does not change."""
|
||||
loader = _core_node("LoadBackgroundRemovalModel")
|
||||
if loader is None or _core_node("RemoveBackground") is None:
|
||||
raise RuntimeError(NEEDS_NEWER)
|
||||
path = folder_paths.get_full_path(MODEL_FOLDER, name) if folder_paths is not None else None
|
||||
if not path:
|
||||
raise FileNotFoundError(NOT_FOUND.format(name=name) if list_subject_models() else NEEDS_MODEL)
|
||||
stamp = (path, os.path.getmtime(path), os.path.getsize(path))
|
||||
stamp = _model_stamp(name)
|
||||
kept = _MODELS.get(name)
|
||||
if kept is not None and kept[0] == stamp:
|
||||
_MODELS.move_to_end(name)
|
||||
@@ -206,7 +211,7 @@ def subject_matte(frame: torch.Tensor, choice, key: str | None = None) -> torch.
|
||||
set to. With `key` (the picture's own key) the answer is remembered: a
|
||||
picture is asked about once, however many picks follow."""
|
||||
name = subject_model_name(choice)
|
||||
slot = (name, key)
|
||||
slot = (name, _model_stamp(name), key)
|
||||
if key is not None and slot in _SUBJECTS:
|
||||
_SUBJECTS.move_to_end(slot)
|
||||
return _SUBJECTS[slot].float() / 255.0
|
||||
|
||||
+10
-8
@@ -100,8 +100,9 @@ def _torch_fill_holes(solid: torch.Tensor) -> torch.Tensor:
|
||||
reachable[:, :, -1] = background[:, :, -1]
|
||||
while True:
|
||||
grown = (
|
||||
functional.max_pool2d(
|
||||
reachable.float().unsqueeze(1), kernel_size=3, stride=1, padding=1
|
||||
torch.maximum(
|
||||
functional.max_pool2d(reachable.float().unsqueeze(1), (3, 1), 1, (1, 0)),
|
||||
functional.max_pool2d(reachable.float().unsqueeze(1), (1, 3), 1, (0, 1)),
|
||||
)
|
||||
.squeeze(1)
|
||||
.bool()
|
||||
@@ -129,10 +130,10 @@ def _hole_limit(max_hole_size: float, height: int, width: int) -> float | None:
|
||||
def _torch_hole_areas(holes: torch.Tensor) -> torch.Tensor:
|
||||
"""Each hole pixel's hole size in pixels, 0 elsewhere, for one HW frame.
|
||||
|
||||
Holes are 8-connected, the way _torch_fill_holes floods them. Every hole
|
||||
Holes are 4-connected, the way _torch_fill_holes floods them. Every hole
|
||||
pixel starts with its own index; each pass takes the largest index in
|
||||
its 3x3 neighbourhood, then the index held by the pixel that index names
|
||||
(both stay inside the same hole), until every hole holds one index.
|
||||
its cross-shaped neighbourhood, then the index held by the pixel that
|
||||
index names (both stay inside the same hole), until every hole holds one index.
|
||||
"""
|
||||
height, width = holes.shape
|
||||
inside = holes.reshape(-1)
|
||||
@@ -140,8 +141,9 @@ def _torch_hole_areas(holes: torch.Tensor) -> torch.Tensor:
|
||||
index = torch.arange(1, height * width + 1, dtype=torch.float64, device=holes.device)
|
||||
labels = torch.where(inside, index, zero)
|
||||
while True:
|
||||
spread = functional.max_pool2d(
|
||||
labels.view(1, 1, height, width), kernel_size=3, stride=1, padding=1
|
||||
spread = torch.maximum(
|
||||
functional.max_pool2d(labels.view(1, 1, height, width), (3, 1), 1, (1, 0)),
|
||||
functional.max_pool2d(labels.view(1, 1, height, width), (1, 3), 1, (0, 1)),
|
||||
).reshape(-1)
|
||||
spread = torch.where(inside, spread, zero)
|
||||
spread = torch.where(inside, spread[(spread.long() - 1).clamp(min=0)], zero)
|
||||
@@ -188,7 +190,7 @@ def fill_mask_holes(mask: torch.Tensor, max_hole_size: float = 0.0) -> torch.Ten
|
||||
).to(mask.device)
|
||||
else:
|
||||
filled = _torch_fill_holes(solid)
|
||||
return torch.maximum(mask, filled.to(mask.dtype))
|
||||
return torch.where(filled & ~solid, 1.0, mask)
|
||||
|
||||
|
||||
def blur_mask(mask: torch.Tensor, sigma: float) -> torch.Tensor:
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
"""Load Audio 🆎."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
|
||||
from ._audio_trim_helpers import decode_audio_window, list_input_audio
|
||||
from ._execution_helpers import ignore_extra_inputs
|
||||
from ._media_helpers import resolve_input_path
|
||||
|
||||
|
||||
class AusBossLoadAudio:
|
||||
CATEGORY = "🆎 AusBoss/Video"
|
||||
DESCRIPTION = (
|
||||
"Loads a sound file and hands on only the part you pick. The node shows the "
|
||||
"sound as a wave, so you can see where the loud parts are. Drag the two "
|
||||
"handles to set where it starts and stops, and press play to hear just that "
|
||||
"part. Set Max length to the longest sound the next step takes: anything "
|
||||
"longer shows in red as cut off, so you see exactly what comes out before "
|
||||
"you run anything."
|
||||
)
|
||||
SEARCH_ALIASES = [
|
||||
"load audio",
|
||||
"audio loader",
|
||||
"trim audio",
|
||||
"cut audio",
|
||||
"song",
|
||||
"voice",
|
||||
"music",
|
||||
"waveform",
|
||||
"ausboss",
|
||||
]
|
||||
|
||||
@classmethod
|
||||
def INPUT_TYPES(cls):
|
||||
return {
|
||||
"required": {
|
||||
"audio": (
|
||||
list_input_audio(),
|
||||
{
|
||||
"audio_upload": True,
|
||||
"tooltip": "A sound file in ComfyUI's input folder. Use Upload to add one.",
|
||||
},
|
||||
),
|
||||
"start_seconds": (
|
||||
"FLOAT",
|
||||
{
|
||||
"default": 0.0,
|
||||
"min": 0.0,
|
||||
"max": 86400.0,
|
||||
"step": 0.01,
|
||||
"tooltip": "Where the sound starts. Drag the wave's IN handle or type a time.",
|
||||
},
|
||||
),
|
||||
"end_seconds": (
|
||||
"FLOAT",
|
||||
{
|
||||
"default": 0.0,
|
||||
"min": 0.0,
|
||||
"max": 86400.0,
|
||||
"step": 0.01,
|
||||
"tooltip": "Where the sound stops. 0 plays to the end. Drag the OUT handle or type a time.",
|
||||
},
|
||||
),
|
||||
},
|
||||
"optional": {
|
||||
"max_seconds": (
|
||||
"FLOAT",
|
||||
{
|
||||
"default": 0.0,
|
||||
"min": 0.0,
|
||||
"max": 86400.0,
|
||||
"step": 0.1,
|
||||
"tooltip": (
|
||||
"The longest the sound may be. Anything past it is cut off and shows "
|
||||
"in red. 0 means no limit."
|
||||
),
|
||||
},
|
||||
),
|
||||
},
|
||||
}
|
||||
|
||||
RETURN_TYPES = ("AUDIO", "FLOAT")
|
||||
RETURN_NAMES = ("audio", "seconds")
|
||||
OUTPUT_TOOLTIPS = (
|
||||
"The part of the sound you picked, ready for any node that takes audio.",
|
||||
"How long that sound is, in seconds.",
|
||||
)
|
||||
FUNCTION = "load_audio"
|
||||
|
||||
async def load_audio(self, audio, start_seconds, end_seconds, max_seconds=0.0):
|
||||
path = resolve_input_path(audio)
|
||||
# Decoding blocks for as long as the pick is; a worker thread keeps
|
||||
# ComfyUI's event loop answering, and carries the context ComfyUI
|
||||
# reads to attribute an interrupt to this node.
|
||||
sound = await asyncio.to_thread(
|
||||
decode_audio_window, path, start_seconds, end_seconds, max_seconds
|
||||
)
|
||||
seconds = sound["waveform"].shape[-1] / float(sound["sample_rate"])
|
||||
return (sound, float(seconds))
|
||||
|
||||
@classmethod
|
||||
def IS_CHANGED(cls, audio, **_values):
|
||||
try:
|
||||
stat = resolve_input_path(audio).stat()
|
||||
except Exception:
|
||||
return float("nan")
|
||||
return f"{audio}:{stat.st_mtime_ns}:{stat.st_size}"
|
||||
|
||||
@classmethod
|
||||
@ignore_extra_inputs
|
||||
def VALIDATE_INPUTS(cls, audio):
|
||||
# Only the source is named: ComfyUI skips its own range checks for
|
||||
# every input named here. resolve_input_path takes a file inside the
|
||||
# input folder, or one named "[output]" or "[temp]", and nothing else.
|
||||
try:
|
||||
resolve_input_path(audio)
|
||||
except Exception as exc:
|
||||
return f"Load Audio: {exc}"
|
||||
return True
|
||||
|
||||
|
||||
NODE_CLASS_MAPPINGS = {"AUSBOSS_NODES_LoadAudio": AusBossLoadAudio}
|
||||
NODE_DISPLAY_NAME_MAPPINGS = {"AUSBOSS_NODES_LoadAudio": "Load Audio 🆎"}
|
||||
|
||||
__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
|
||||
@@ -220,9 +220,11 @@ def _tell(node_id, note: dict, end: bool) -> bool:
|
||||
if server is None or node_id is None:
|
||||
return False
|
||||
try:
|
||||
read_context = getattr(sys.modules.get("comfy_execution.utils"), "get_executing_context", lambda: None)
|
||||
prompt_id = getattr(read_context(), "prompt_id", None)
|
||||
server.send_sync(
|
||||
LOOK_EVENT,
|
||||
{"node": str(node_id), "note": note, "end": bool(end)},
|
||||
{"node": str(node_id), "note": note, "end": bool(end), "prompt_id": prompt_id},
|
||||
getattr(server, "client_id", None),
|
||||
)
|
||||
except Exception: # noqa: BLE001
|
||||
|
||||
@@ -67,6 +67,7 @@ PUBLIC_NODE_IDS = {
|
||||
"AUSBOSS_NODES_Krea2OutpaintModelPatch",
|
||||
"AUSBOSS_NODES_LaMaInpaint",
|
||||
"AUSBOSS_NODES_LayoutBoxes",
|
||||
"AUSBOSS_NODES_LoadAudio",
|
||||
"AUSBOSS_NODES_LoadImagePad",
|
||||
"AUSBOSS_NODES_LoadVideo",
|
||||
"AUSBOSS_NODES_LoraLoader",
|
||||
|
||||
@@ -3,8 +3,6 @@ import assert from "node:assert/strict";
|
||||
|
||||
import {
|
||||
BRUSH_SIZE,
|
||||
ADJUST_DEAD_ZONE,
|
||||
adjustAxis,
|
||||
adjustedBrush,
|
||||
brushAdjusts,
|
||||
brushFlips,
|
||||
@@ -17,7 +15,6 @@ import {
|
||||
moveAdjust,
|
||||
startAdjust,
|
||||
steppedBrushSize,
|
||||
steppedSoft,
|
||||
toolKey,
|
||||
} from "../js/shared/brush.mjs";
|
||||
|
||||
@@ -104,53 +101,3 @@ test("the brush under the pointer fades as its marks do", () => {
|
||||
assert.ok(brushProfile(brushReach(80, 1), 80, 1) < 0.01);
|
||||
for (let d = 0; d < 50; d += 5) assert.ok(brushProfile(d, 80, 0.6) >= brushProfile(d + 5, 80, 0.6), "never brighter further out");
|
||||
});
|
||||
|
||||
test("brush values round, clamp and fall back without producing NaN", () => {
|
||||
assert.equal(clampBrushSize("25.6"), 26);
|
||||
assert.equal(clampBrushSize(1), BRUSH_SIZE[0]);
|
||||
for (const value of [undefined, "large", NaN, Infinity, -Infinity]) {
|
||||
assert.equal(clampBrushSize(value, [4, 1000]), 4);
|
||||
assert.equal(clampSoft(value, 20), 20);
|
||||
}
|
||||
assert.equal(clampSoft("24.6"), 25);
|
||||
assert.equal(clampSoft(-5), 0);
|
||||
assert.equal(clampSoft(101), 100);
|
||||
assert.equal(clampSoft(undefined, 120), 100);
|
||||
});
|
||||
|
||||
test("brush keys change small sizes by at least two pixels and stop at the bounds", () => {
|
||||
assert.equal(steppedBrushSize(2, true), 4);
|
||||
assert.equal(steppedBrushSize(4, false), 2);
|
||||
assert.equal(steppedBrushSize(2, false), 2);
|
||||
assert.equal(steppedBrushSize(100, false), 84);
|
||||
assert.equal(steppedBrushSize(2000, true), 2000);
|
||||
assert.equal(steppedSoft(50, true), 75);
|
||||
assert.equal(steppedSoft(50, false), 25);
|
||||
assert.equal(steppedSoft(90, true), 100);
|
||||
assert.equal(steppedSoft(10, false), 0);
|
||||
});
|
||||
|
||||
test("brush adjustment starts at the dead-zone boundary and breaks diagonal ties by size", () => {
|
||||
const edge = ADJUST_DEAD_ZONE;
|
||||
assert.equal(adjustAxis(edge - 1, -(edge - 1)), null);
|
||||
for (const direction of [-1, 1]) {
|
||||
assert.equal(adjustAxis(direction * edge, 0), "size");
|
||||
assert.equal(adjustAxis(0, direction * edge), "soft");
|
||||
assert.equal(adjustAxis(direction * edge, -edge), "size");
|
||||
}
|
||||
});
|
||||
|
||||
test("a tiny blur keeps the hard-brush edge, while a soft brush scales with its size", () => {
|
||||
// Below a quarter pixel of blur the preview uses a solid disc.
|
||||
assert.equal(brushProfile(1, 2, 0.5), 1);
|
||||
assert.equal(brushProfile(1.01, 2, 0.5), 0);
|
||||
assert.equal(brushReach(2, 0.5), 1);
|
||||
for (const soft of [0.25, 0.5, 1]) {
|
||||
assert.equal(brushReach(160, soft), 2 * brushReach(80, soft));
|
||||
for (const distance of [0, 10, 20, 40, 80]) {
|
||||
const value = brushProfile(distance, 80, soft);
|
||||
assert.ok(value >= 0 && value <= 1);
|
||||
assert.equal(brushProfile(distance * 2, 160, soft), value);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
@@ -89,60 +89,3 @@ test("a failed lookup says why in plain words", () => {
|
||||
assert.equal(civitaiFailureText(new Error("Civitai answered 500.")), "Civitai answered 500.");
|
||||
assert.equal(civitaiFailureText(null), "The Civitai lookup failed.");
|
||||
});
|
||||
|
||||
test("parsing accepts an object at the size limit and rejects oversized or non-text bodies", () => {
|
||||
const body = '{"name":"' + "x".repeat(MAX_CIVITAI_BYTES - 11) + '"}';
|
||||
assert.equal(body.length, MAX_CIVITAI_BYTES);
|
||||
assert.equal(parseCivitaiBody(body).name.length, MAX_CIVITAI_BYTES - 11);
|
||||
assert.throws(() => parseCivitaiBody(body + " "), /too large/);
|
||||
for (const value of [null, undefined, {}, 1]) {
|
||||
assert.throws(() => parseCivitaiBody(value), /too large/);
|
||||
}
|
||||
for (const text of ["true", "false", "0", '"model"']) {
|
||||
assert.throws(() => parseCivitaiBody(text), /not what we expected/);
|
||||
}
|
||||
assert.throws(() => parseCivitaiBody('{"id":'), SyntaxError);
|
||||
});
|
||||
|
||||
test("numeric picture ratings take priority over legacy words and booleans", () => {
|
||||
for (const level of [1, 2, "2"]) {
|
||||
assert.equal(isMildPicture({ nsfwLevel: level, nsfw: "Mature" }), true);
|
||||
}
|
||||
for (const level of [4, 8, 16, 3]) {
|
||||
assert.equal(isMildPicture({ nsfwLevel: level, nsfw: false }), false);
|
||||
}
|
||||
assert.equal(isMildPicture({ nsfw: false }), true);
|
||||
assert.equal(isMildPicture({ nsfw: true }), false);
|
||||
assert.equal(isMildPicture({ nsfwLevel: 0, nsfw: "SOFT" }), true);
|
||||
assert.equal(isMildPicture(null), false);
|
||||
});
|
||||
|
||||
test("picture selection skips malformed entries even when any rating is allowed", () => {
|
||||
const still = { url: picture("still") };
|
||||
const info = { images: [
|
||||
null, {}, { url: 42 },
|
||||
{ url: picture("clip"), type: "video", nsfwLevel: 1 },
|
||||
{ url: "https://example.org/picture.jpeg", nsfwLevel: 1 },
|
||||
still,
|
||||
{ url: picture("later"), nsfwLevel: 1 },
|
||||
] };
|
||||
assert.equal(pickCivitaiPicture(info, true), still, "the first usable still wins without copying it");
|
||||
assert.equal(pickCivitaiPicture(info), info.images[6], "an unrated still is skipped in mild mode");
|
||||
for (const images of [null, {}, "pictures", []]) {
|
||||
assert.equal(pickCivitaiPicture({ images }, true), null);
|
||||
}
|
||||
});
|
||||
|
||||
test("picture resizing drops query and fragment and refuses incomplete picture paths", () => {
|
||||
assert.equal(smallPictureUrl(picture("a") + "?width=999&token=example#preview"),
|
||||
"https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/0b1c2d3e/width=450/a.jpeg");
|
||||
assert.equal(smallPictureUrl("https://image.civitai.com/a.jpeg"), null);
|
||||
assert.equal(smallPictureUrl("https://image.civitai.com/"), null);
|
||||
for (const url of [
|
||||
"https://civitai.com.example.org/file.jpeg",
|
||||
"https://civitai.com@other.example/file.jpeg",
|
||||
"file:///tmp/file.jpeg", "not a url",
|
||||
]) {
|
||||
assert.equal(isCivitaiAddress(url), false, url);
|
||||
}
|
||||
});
|
||||
|
||||
Vendored
+20
@@ -490,6 +490,26 @@
|
||||
]
|
||||
]
|
||||
},
|
||||
"AUSBOSS_NODES_LoadAudio": {
|
||||
"required": [
|
||||
"audio",
|
||||
"start_seconds",
|
||||
"end_seconds"
|
||||
],
|
||||
"optional": [
|
||||
"max_seconds"
|
||||
],
|
||||
"outputs": [
|
||||
[
|
||||
"AUDIO",
|
||||
"audio"
|
||||
],
|
||||
[
|
||||
"FLOAT",
|
||||
"seconds"
|
||||
]
|
||||
]
|
||||
},
|
||||
"AUSBOSS_NODES_LoadImagePad": {
|
||||
"required": [
|
||||
"image",
|
||||
|
||||
@@ -145,82 +145,3 @@ test("restoreOutputLinks hands back only the links a replacement took", () => {
|
||||
assert.equal(graph.links.get(saver.inputs[0].link).origin_id, 1);
|
||||
assert.equal(preview.inputs[0].link, untouched, "a link that was never taken stays as it is");
|
||||
});
|
||||
|
||||
test("lookupLink keeps link id zero and tolerates absent tables and stale ids", () => {
|
||||
const link = { id: 0 };
|
||||
for (const links of [new Map([[0, link]]), { 0: link }]) {
|
||||
assert.equal(lookupLink({ links }, 0), link);
|
||||
assert.equal(lookupLink({ links }, 99), null);
|
||||
assert.equal(lookupLink({ links }, undefined), null);
|
||||
}
|
||||
assert.equal(lookupLink({}, 0), null);
|
||||
});
|
||||
|
||||
test("snapshotLinks skips stale links in an older plain-object graph", () => {
|
||||
const graph = { links: {
|
||||
0: { origin_id: 1, origin_slot: 2, target_id: 5, target_slot: 0 },
|
||||
8: { origin_id: 5, origin_slot: 1, target_id: 9, target_slot: 3 },
|
||||
} };
|
||||
const node = {
|
||||
inputs: [{ name: "image", link: 0 }, { name: "empty", link: null }, { name: "stale", link: 99 }],
|
||||
outputs: [{ name: "unused" }, { name: "mask", links: [99, 8] }, { name: "stale", links: [77] }],
|
||||
};
|
||||
const snapshot = snapshotLinks(node, graph);
|
||||
assert.deepEqual(snapshot, {
|
||||
inputs: [{ name: "image", originId: 1, originSlot: 2 }],
|
||||
outputs: [{ name: "mask", slot: 1, targets: [{ nodeId: 9, slot: 3 }] }],
|
||||
});
|
||||
graph.links[0].origin_slot = 4;
|
||||
graph.links[8].target_slot = 0;
|
||||
node.inputs[0].name = "changed";
|
||||
assert.equal(snapshot.inputs[0].originSlot, 2, "the snapshot owns its slot values");
|
||||
assert.equal(snapshot.inputs[0].name, "image");
|
||||
assert.equal(snapshot.outputs[0].targets[0].slot, 3);
|
||||
assert.deepEqual(snapshotLinks({}, graph), { inputs: [], outputs: [] });
|
||||
});
|
||||
|
||||
test("linkSlots refuses redirects outside the target's inputs before calling connectSlots", () => {
|
||||
const { makeNode } = makeGraph();
|
||||
const source = makeNode(1, [], ["out"]);
|
||||
const sink = makeNode(2, ["in"], []);
|
||||
source.connectSlots = () => assert.fail("a refused redirect must not connect");
|
||||
for (const redirect of [null, false, "0", -1, 4, NaN]) {
|
||||
sink.onBeforeConnectInput = function (slot, requested) {
|
||||
assert.equal(this, sink);
|
||||
assert.equal(slot, 0);
|
||||
assert.equal(requested, 0);
|
||||
return redirect;
|
||||
};
|
||||
assert.equal(linkSlots(source, 0, sink, 0), null, String(redirect));
|
||||
}
|
||||
});
|
||||
|
||||
test("restoreOutputLinks skips missing targets and reconnects a disconnected input", () => {
|
||||
const { graph, makeNode } = makeGraph();
|
||||
const original = makeNode(1, [], ["image", "mask"]);
|
||||
const sink = makeNode(2, ["mask"], []);
|
||||
restoreOutputLinks(original, [{ slot: 1, targets: [
|
||||
{ nodeId: 99, slot: 0 }, { nodeId: 2, slot: 0 }, { nodeId: 2, slot: 99 },
|
||||
] }], graph);
|
||||
const link = lookupLink(graph, sink.inputs[0].link);
|
||||
assert.equal(link.origin_id, original.id);
|
||||
assert.equal(link.origin_slot, 1);
|
||||
assert.equal(graph.links.size, 1);
|
||||
});
|
||||
|
||||
test("restoreOutputLinks restores the output slot even when the source node is unchanged", () => {
|
||||
const { graph, makeNode } = makeGraph();
|
||||
const original = makeNode(1, [], ["first image", "second image"]);
|
||||
const sink = makeNode(2, ["image"], []);
|
||||
linkSlots(original, 1, sink, 0);
|
||||
const { outputs } = snapshotLinks(original, graph);
|
||||
linkSlots(original, 0, sink, 0);
|
||||
|
||||
restoreOutputLinks(original, outputs, graph);
|
||||
const restored = lookupLink(graph, sink.inputs[0].link);
|
||||
assert.equal(restored.origin_id, original.id);
|
||||
assert.equal(restored.origin_slot, 1);
|
||||
assert.deepEqual(original.outputs[0].links, []);
|
||||
assert.deepEqual(original.outputs[1].links, [restored.id]);
|
||||
assert.equal(graph.links.size, 1);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
|
||||
import { grabZone, outputSummary, outputWindow, wavePeaks } from "../js/load_audio/audio_window.mjs";
|
||||
|
||||
test("the face shows what the node hands on", () => {
|
||||
// Mirrors audio_window in nodes/_audio_trim_helpers.py.
|
||||
assert.deepEqual(outputWindow(40, 8, 30, 15), { start: 8, end: 30, keepEnd: 23, length: 15, cut: 7 });
|
||||
assert.deepEqual(outputWindow(40, 8, 12, 15), { start: 8, end: 12, keepEnd: 12, length: 4, cut: 0 });
|
||||
assert.equal(outputWindow(40, 5, 0, 0).end, 40, "OUT 0 means the end of the file");
|
||||
assert.equal(outputWindow(40, 30, 0, 20).keepEnd, 40, "a max past the end stops at the end");
|
||||
assert.equal(outputWindow(10, 50, 0).start, 10, "a start past the end is held at the end");
|
||||
assert.equal(outputWindow(10, "x", null, NaN).length, 10);
|
||||
});
|
||||
|
||||
test("the line between IN and OUT says how long and what is cut", () => {
|
||||
assert.equal(outputSummary(outputWindow(40, 8, 30, 15)), "15.0 s · cut 7.0 s");
|
||||
assert.equal(outputSummary(outputWindow(200, 0, 0, 0)), "3:20.0");
|
||||
assert.equal(outputSummary(outputWindow(40, 8, 30, 0), { maxFromLink: true }), "22.0 s · max wired");
|
||||
assert.equal(outputSummary(outputWindow(0, 0, 0)), "");
|
||||
});
|
||||
|
||||
test("a press grabs the nearest handle, the middle, or jumps", () => {
|
||||
const win = outputWindow(40, 10, 30);
|
||||
assert.equal(grabZone(win, 40, 0.25, 400), "start");
|
||||
assert.equal(grabZone(win, 40, 0.75, 400), "end");
|
||||
assert.equal(grabZone(win, 40, 0.5, 400), "move");
|
||||
assert.equal(grabZone(win, 40, 0.05, 400), "jump");
|
||||
assert.equal(grabZone(win, 0, 0.5, 400), "none");
|
||||
});
|
||||
|
||||
test("peaks keep the loudest sample of each slice, channels mixed", () => {
|
||||
const left = Float32Array.from([0, 0.5, -0.5, 0, 1, -1]);
|
||||
const right = Float32Array.from([0, 0.5, -0.5, 0, 1, -1]);
|
||||
const peaks = wavePeaks([left, right], 2);
|
||||
assert.deepEqual(Array.from(peaks), [-0.5, 0.5, -1, 1]);
|
||||
assert.equal(wavePeaks([], 3).length, 6);
|
||||
});
|
||||
@@ -116,6 +116,7 @@ test("a panel that should follow the node's height never declares computeSize",
|
||||
"image_folder",
|
||||
"input_preview",
|
||||
"layout_boxes",
|
||||
"load_audio",
|
||||
"load_image_pad",
|
||||
"load_video",
|
||||
"lora_loader",
|
||||
|
||||
@@ -4,7 +4,6 @@ import test from "node:test";
|
||||
import {
|
||||
ensureNodeMinHeight,
|
||||
fillNodeHeight,
|
||||
growToNodeFloor,
|
||||
holdNodeMinWidth,
|
||||
holdNodeMinHeight,
|
||||
holdVueNodeMinWidth,
|
||||
@@ -320,90 +319,3 @@ test("a new node hugs its floor and a loading workflow keeps its saved height",
|
||||
assert.equal(nodeHeightAfterCardChange({ floor: 469, current: 700, change: "x" }), 700);
|
||||
assert.equal(nodeHeightAfterCardChange(), 0);
|
||||
});
|
||||
|
||||
test("a failed width probe restores the widget and allows the next measurement", () => {
|
||||
const own = () => ({ minWidth: 320, minHeight: 80 });
|
||||
const widget = { computeLayoutSize: own };
|
||||
assert.equal(measureLayoutWidthPadding({ computeSize() { throw new Error("not laid out"); } }, widget), null);
|
||||
assert.equal(widget.computeLayoutSize, own);
|
||||
assert.equal(measureLayoutWidthPadding(frontendNode([widget]), widget), 104);
|
||||
assert.equal(widget.computeLayoutSize, own);
|
||||
});
|
||||
|
||||
test("a width probe cannot recursively start another probe", () => {
|
||||
const widget = { computeLayoutSize: () => ({ minWidth: 320, minHeight: 80 }) };
|
||||
const own = widget.computeLayoutSize;
|
||||
const node = {
|
||||
computeSize() {
|
||||
assert.equal(measureLayoutWidthPadding(this, widget), null);
|
||||
return [widget.computeLayoutSize().minWidth + 80, 200];
|
||||
},
|
||||
};
|
||||
assert.equal(measureLayoutWidthPadding(node, widget), 80);
|
||||
assert.equal(widget.computeLayoutSize, own);
|
||||
});
|
||||
|
||||
test("growing to a changing width floor preserves height and leaves wider nodes alone", () => {
|
||||
const sizes = [];
|
||||
const dirty = [];
|
||||
const host = { style: {} };
|
||||
const node = {
|
||||
size: [240, 480],
|
||||
setSize(size) { sizes.push(size); this.size = size; },
|
||||
setDirtyCanvas(...args) { dirty.push(args); },
|
||||
};
|
||||
const widget = { node, element: { closest: () => host } };
|
||||
let floor = 320;
|
||||
holdNodeMinWidth(widget, () => floor);
|
||||
assert.equal(growToNodeFloor(widget, 1), true);
|
||||
assert.deepEqual(node.size, [320, 480]);
|
||||
assert.equal(host.style.minWidth, "320px");
|
||||
assert.deepEqual(dirty, [[true, true]]);
|
||||
assert.equal(growToNodeFloor(widget, 1), false);
|
||||
floor = 280;
|
||||
assert.equal(growToNodeFloor(widget, 1), false);
|
||||
assert.equal(host.style.minWidth, "280px", "the CSS floor can shrink without shrinking the node");
|
||||
floor = 400;
|
||||
assert.equal(growToNodeFloor(widget, 1), true);
|
||||
assert.deepEqual(sizes, [[320, 480], [400, 480]]);
|
||||
node.size[0] = NaN;
|
||||
assert.equal(growToNodeFloor(widget, 1), false);
|
||||
assert.equal(growToNodeFloor({ node: { size: [100, 100] } }), false);
|
||||
assert.equal(growToNodeFloor(null), false);
|
||||
});
|
||||
|
||||
test("growing a node measures its floor again on the next frame with a bounded retry", () => {
|
||||
const saved = globalThis.requestAnimationFrame;
|
||||
const frames = [];
|
||||
globalThis.requestAnimationFrame = (callback) => { frames.push(callback); };
|
||||
try {
|
||||
let floor = 320;
|
||||
const node = { size: [240, 480], setSize(size) { this.size = size; } };
|
||||
const widget = { node };
|
||||
holdNodeMinWidth(widget, () => floor);
|
||||
assert.equal(growToNodeFloor(widget), true);
|
||||
assert.equal(frames.length, 1);
|
||||
floor = 360;
|
||||
frames.shift()();
|
||||
assert.deepEqual(node.size, [360, 480]);
|
||||
assert.equal(frames.length, 0, "the second pass must not schedule another frame");
|
||||
} finally {
|
||||
if (saved === undefined) delete globalThis.requestAnimationFrame;
|
||||
else globalThis.requestAnimationFrame = saved;
|
||||
}
|
||||
});
|
||||
|
||||
test("dynamic panel floors sanitize invalid sizes and retain unrelated options", () => {
|
||||
let width = "240";
|
||||
let height = "160";
|
||||
const widget = { options: { serialize: false } };
|
||||
fillNodeHeight(widget, { minWidth: () => width, minHeight: () => height });
|
||||
assert.deepEqual(widget.computeLayoutSize(), { minWidth: 240, minHeight: 160 });
|
||||
for (const invalid of [-4, NaN, Infinity, undefined, "wide"]) {
|
||||
width = invalid;
|
||||
height = invalid;
|
||||
assert.deepEqual(widget.computeLayoutSize(), { minWidth: 0, minHeight: 0 });
|
||||
}
|
||||
assert.equal(widget.options.serialize, false);
|
||||
assert.equal(fillNodeHeight(null), null);
|
||||
});
|
||||
|
||||
@@ -184,3 +184,18 @@ test("different problems, other kinds of error and other packs' nodes are left a
|
||||
assert.equal(errors[2].errors.length, 2);
|
||||
assert.equal(collapseRepeatedErrors(null), null);
|
||||
});
|
||||
|
||||
test("an empty Load Audio asks for a sound file", () => {
|
||||
const outputs = (classType) => (classType === "SaveAudio"
|
||||
? { output_node: true, input: { required: { audio: ["AUDIO"] } } }
|
||||
: definitionOf(classType));
|
||||
const prompt = {
|
||||
1: node("AUSBOSS_NODES_LoadAudio", { audio: "" }, "Song"),
|
||||
2: node("SaveAudio", { audio: ["1", 0] }),
|
||||
};
|
||||
const found = findEmptySources(prompt, outputs);
|
||||
assert.deepEqual(found.map((entry) => entry.input), ["audio"]);
|
||||
assert.equal(emptySourceMessage(found), "Load a sound file first: Song");
|
||||
prompt[1].inputs.audio = "song.mp3";
|
||||
assert.deepEqual(findEmptySources(prompt, outputs), []);
|
||||
});
|
||||
|
||||
@@ -214,71 +214,3 @@ test("a number box reads a typed sum only where a plain number fails", () => {
|
||||
const source = readFileSync(join(ROOT, "js", "shared", "scrub_input.mjs"), "utf-8");
|
||||
assert.match(source, /Number\.isFinite\(number\) \? number : sumValue\(input\.value\)/);
|
||||
});
|
||||
|
||||
test("formatting keeps significant digits while trimming only fractional zeroes", () => {
|
||||
for (const [value, options, expected] of [
|
||||
[undefined, {}, ""],
|
||||
["12.340", { decimals: 3, minDecimals: 0 }, "12.34"],
|
||||
[-120, { decimals: 3, minDecimals: 0 }, "-120"],
|
||||
[-1.2346, { decimals: 3, minDecimals: 1 }, "-1.235"],
|
||||
[0.0001, { decimals: 4, minDecimals: 0 }, "0.0001"],
|
||||
[12, { decimals: -2 }, "12"],
|
||||
[1, { decimals: 2, minDecimals: -1 }, "1"],
|
||||
]) {
|
||||
assert.equal(formatScrubValue(value, options), expected);
|
||||
}
|
||||
});
|
||||
|
||||
test("invalid scrub values use a finite floor or zero before rounding", () => {
|
||||
for (const value of [undefined, NaN, Infinity, -Infinity, "not a number"]) {
|
||||
assert.equal(quantizeScrubValue(value), 0);
|
||||
assert.equal(quantizeScrubValue(value, { min: -2, max: 4 }), -2);
|
||||
}
|
||||
assert.equal(quantizeScrubValue("2.718", { decimals: 2 }), 2.72);
|
||||
assert.equal(quantizeScrubValue(-10, { min: -2, max: 4 }), -2);
|
||||
assert.equal(quantizeScrubValue(10, { min: -2, max: 4 }), 4);
|
||||
});
|
||||
|
||||
test("snapped steps cross zero and take several steps from an off-grid value", () => {
|
||||
for (const [start, count, expected] of [
|
||||
[-9, 1, -8], [-9, -1, -16], [-9, 3, 8],
|
||||
[9, -3, -8], [9, 3, 32], [0, -1, -8], [9, 0, 9],
|
||||
]) {
|
||||
assert.equal(steppedValue(start, count, 8, true), expected, `${start}, ${count}`);
|
||||
}
|
||||
assert.equal(steppedValue("9", -2, 8), -7);
|
||||
});
|
||||
|
||||
test("gesture boundaries accept equal diagonal travel only past the dead zone", () => {
|
||||
for (const direction of [-1, 1]) {
|
||||
assert.equal(isScrubGesture(direction * SCRUB_DEAD_ZONE, 0), false);
|
||||
assert.equal(isScrubGesture(direction * 4, -4), true);
|
||||
assert.equal(isScrubGesture(direction * 4, 5), false);
|
||||
}
|
||||
});
|
||||
|
||||
test("Shift slows dragging when the supplied fine step is equal or larger", () => {
|
||||
const delta = SCRUB_DEAD_ZONE + SCRUB_PIXELS_PER_STEP * SCRUB_SLOW_FACTOR * 2;
|
||||
for (const fineStep of [null, 1, 2]) {
|
||||
const options = { step: 1, fineStep, decimals: 0 };
|
||||
assert.equal(scrubbedValue(10, delta, true, options), 12);
|
||||
assert.equal(scrubbedValue(10, -delta, true, options), 8);
|
||||
assert.equal(scrubbedValue(10, delta, false, options), 18);
|
||||
}
|
||||
});
|
||||
|
||||
test("step precision accepts negative and string increments and rounds at six decimals", () => {
|
||||
for (const [step, expected] of [[-0.025, 3], ["0.000001", 6], [0.1234567, 6], [0, 0], [undefined, 0]]) {
|
||||
assert.equal(stepDecimals(step), expected, String(step));
|
||||
}
|
||||
});
|
||||
|
||||
test("typed sums associate division and subtraction left to right", () => {
|
||||
assert.equal(sumValue("24/4/2"), 3);
|
||||
assert.equal(sumValue("10-3-2"), 5);
|
||||
assert.equal(sumValue("20%6*2"), 4);
|
||||
assert.equal(sumValue("\t-(2 + +3) * -2\t"), 10);
|
||||
assert.equal(sumValue("1" + " ".repeat(199)), 1);
|
||||
assert.equal(sumValue("1" + " ".repeat(200)), null);
|
||||
assert.equal(sumValue("1/(2-2)"), null);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
import assert from "node:assert/strict";
|
||||
import test from "node:test";
|
||||
|
||||
import { SEED_LOOK_PROPERTY, controlChip, nextControl, seedLook, setSeedLook } from "../js/shared/seed_look.mjs";
|
||||
|
||||
test("the look lives on the node, and full leaves nothing behind", () => {
|
||||
const node = { properties: {} };
|
||||
assert.equal(seedLook(node), "full");
|
||||
assert.equal(setSeedLook(node, "compact"), "compact");
|
||||
assert.equal(node.properties[SEED_LOOK_PROPERTY], "compact");
|
||||
assert.equal(setSeedLook(node, "full"), "full");
|
||||
assert.deepEqual(node.properties, {});
|
||||
assert.equal(seedLook(null), "full");
|
||||
assert.equal(seedLook({ properties: { [SEED_LOOK_PROPERTY]: "huge" } }), "full");
|
||||
});
|
||||
|
||||
test("the chip walks Random, Fixed, +1, -1 and back", () => {
|
||||
assert.equal(nextControl("randomize"), "fixed");
|
||||
assert.equal(nextControl("fixed"), "increment");
|
||||
assert.equal(nextControl("increment"), "decrement");
|
||||
assert.equal(nextControl("decrement"), "randomize");
|
||||
assert.equal(nextControl("something else"), "randomize");
|
||||
assert.equal(controlChip("randomize").text, "Random");
|
||||
assert.equal(controlChip("fixed").text, "Fixed");
|
||||
assert.equal(controlChip(undefined).text, "Fixed");
|
||||
});
|
||||
@@ -0,0 +1,90 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
import av
|
||||
import numpy as np
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
sys.path.insert(0, str(ROOT))
|
||||
if "nodes" in sys.modules and not hasattr(sys.modules["nodes"], "__path__"):
|
||||
del sys.modules["nodes"]
|
||||
|
||||
from nodes._audio_trim_helpers import audio_window, decode_audio_window
|
||||
|
||||
RATE = 8000
|
||||
|
||||
|
||||
def write_ramp(path: Path, seconds: float) -> None:
|
||||
"""A mono wav whose sample value tells the second it was written at."""
|
||||
samples = int(seconds * RATE)
|
||||
data = (np.arange(samples, dtype=np.float32) / RATE / 100.0).reshape(1, -1)
|
||||
with av.open(str(path), "w") as container:
|
||||
stream = container.add_stream("pcm_f32le", rate=RATE, layout="mono")
|
||||
frame = av.AudioFrame.from_ndarray(data, format="flt", layout="mono")
|
||||
frame.sample_rate = RATE
|
||||
for packet in stream.encode(frame):
|
||||
container.mux(packet)
|
||||
for packet in stream.encode(None):
|
||||
container.mux(packet)
|
||||
|
||||
|
||||
class AudioWindowTests(unittest.TestCase):
|
||||
def test_open_end_stays_open_until_the_length_is_known(self):
|
||||
self.assertEqual(audio_window(2, 0)["end"], None)
|
||||
self.assertEqual(audio_window(2, 0, duration=40)["end"], 40)
|
||||
|
||||
def test_max_keeps_the_start_and_cuts_the_rest(self):
|
||||
window = audio_window(8, 30, 15, duration=40)
|
||||
self.assertEqual((window["start"], window["end"], window["cut"]), (8, 23, 7))
|
||||
|
||||
def test_max_longer_than_the_pick_changes_nothing(self):
|
||||
window = audio_window(8, 12, 15, duration=40)
|
||||
self.assertEqual((window["end"], window["cut"]), (12, 0))
|
||||
|
||||
def test_max_with_an_open_end_caps_it(self):
|
||||
self.assertEqual(audio_window(5, 0, 10)["end"], 15)
|
||||
|
||||
def test_bad_values_fall_back(self):
|
||||
window = audio_window("x", None, float("nan"), duration=10)
|
||||
self.assertEqual((window["start"], window["end"], window["cut"]), (0, 10, 0))
|
||||
|
||||
def test_end_before_start_is_an_empty_pick(self):
|
||||
window = audio_window(6, 4, duration=10)
|
||||
self.assertEqual(window["end"], 6)
|
||||
|
||||
|
||||
class DecodeTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.folder = tempfile.TemporaryDirectory()
|
||||
self.path = Path(self.folder.name, "ramp.wav")
|
||||
write_ramp(self.path, 10.0)
|
||||
|
||||
def tearDown(self):
|
||||
self.folder.cleanup()
|
||||
|
||||
def test_takes_exactly_the_pick(self):
|
||||
audio = decode_audio_window(self.path, 2.0, 5.0)
|
||||
waveform = audio["waveform"]
|
||||
self.assertEqual(audio["sample_rate"], RATE)
|
||||
self.assertEqual(tuple(waveform.shape), (1, 1, 3 * RATE))
|
||||
self.assertAlmostEqual(float(waveform[0, 0, 0]) * 100, 2.0, places=3)
|
||||
|
||||
def test_max_cuts_the_end(self):
|
||||
audio = decode_audio_window(self.path, 1.0, 9.0, 2.5)
|
||||
self.assertEqual(audio["waveform"].shape[-1], int(2.5 * RATE))
|
||||
|
||||
def test_open_end_runs_to_the_end_of_the_file(self):
|
||||
audio = decode_audio_window(self.path, 7.5, 0.0)
|
||||
self.assertEqual(audio["waveform"].shape[-1], int(2.5 * RATE))
|
||||
|
||||
def test_start_past_the_end_says_so(self):
|
||||
with self.assertRaisesRegex(ValueError, "past the end"):
|
||||
decode_audio_window(self.path, 12.0, 0.0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -53,6 +53,7 @@ CORE_NODES = {
|
||||
INTERNALS = [
|
||||
("comfy.utils", "PROGRESS_BAR_HOOK", "Mask by Touch holds progress reports back while it looks at a picture"),
|
||||
("comfy_execution.progress", "get_progress_state", "Mask by Touch holds progress reports back while it looks at a picture"),
|
||||
("comfy_execution.utils", "get_executing_context", "Mask by Touch identifies the run sending an interim picture"),
|
||||
("comfy.model_management", "load_model_gpu", "Mask by Touch asks SAM 3 the quick way"),
|
||||
("comfy.model_management", "current_loaded_models", "Mask by Touch asks SAM 3 the quick way"),
|
||||
("comfy.model_management", "intermediate_dtype", "the pack's tensors take ComfyUI's working type"),
|
||||
|
||||
@@ -191,6 +191,18 @@ class AskTests(ModelCase):
|
||||
subject_matte(self.frame, OFF, key="two")
|
||||
self.assertEqual(len(Loader.calls), 2)
|
||||
|
||||
def test_replacing_a_model_invalidates_the_same_pictures_subject(self):
|
||||
Remover.answer = torch.full((1, 40, 60), 0.25)
|
||||
first = subject_matte(self.frame, OFF, key="one")
|
||||
self.file(PREFERRED, "replacement weights, longer")
|
||||
os.utime(self.folder / PREFERRED, (1, 1))
|
||||
Remover.answer = torch.full((1, 40, 60), 0.9)
|
||||
second = subject_matte(self.frame, OFF, key="one")
|
||||
self.assertEqual(len(Loader.calls), 2)
|
||||
self.assertEqual(len(Remover.calls), 2)
|
||||
self.assertLess(float(first.mean()), 0.3)
|
||||
self.assertGreater(float(second.mean()), 0.8)
|
||||
|
||||
def test_an_older_comfyui_gets_a_plain_message(self):
|
||||
self.nodes.NODE_CLASS_MAPPINGS = {"LoadBackgroundRemovalModel": Loader}
|
||||
with self.assertRaises(RuntimeError) as raised:
|
||||
|
||||
@@ -937,7 +937,7 @@ class RoundTests(TouchCase):
|
||||
self.addCleanup(sys.modules.pop, "server", None)
|
||||
sys.modules["server"] = server
|
||||
self.assertIs(node_module._tell(5, {"key": "k"}, True), True)
|
||||
self.assertEqual(sent, [("ausboss.mask_by_touch.look", {"node": "5", "note": {"key": "k"}, "end": True}, "a page")], "to the page that asked")
|
||||
self.assertEqual(sent, [("ausboss.mask_by_touch.look", {"node": "5", "note": {"key": "k"}, "end": True, "prompt_id": None}, "a page")], "to the page that asked")
|
||||
self.assertIs(node_module._tell(None, {}, True), False, "no id: nobody to tell")
|
||||
server.PromptServer = types.SimpleNamespace(instance=None)
|
||||
self.assertIs(node_module._tell(5, {}, True), False, "no page to tell")
|
||||
@@ -945,6 +945,20 @@ class RoundTests(TouchCase):
|
||||
self.assertIs(node_module._tell(5, {}, True), False, "outside ComfyUI")
|
||||
self.assertEqual(len(sent), 1)
|
||||
|
||||
def test_interim_notes_carry_the_executing_prompt_id(self):
|
||||
sent = []
|
||||
context = types.ModuleType("comfy_execution.utils")
|
||||
context.get_executing_context = lambda: types.SimpleNamespace(prompt_id="tab-a-prompt")
|
||||
prior = sys.modules.get("comfy_execution.utils")
|
||||
self.addCleanup(lambda: sys.modules.__setitem__("comfy_execution.utils", prior) if prior else sys.modules.pop("comfy_execution.utils", None))
|
||||
sys.modules["comfy_execution.utils"] = context
|
||||
server = types.ModuleType("server")
|
||||
server.PromptServer = types.SimpleNamespace(instance=types.SimpleNamespace(send_sync=lambda *args: sent.append(args)))
|
||||
self.addCleanup(sys.modules.pop, "server", None)
|
||||
sys.modules["server"] = server
|
||||
self.assertTrue(node_module._tell(5, {}, False))
|
||||
self.assertEqual(sent[0][1]["prompt_id"], "tab-a-prompt")
|
||||
|
||||
def test_a_first_look_stopped_half_way_is_gone_on_with(self):
|
||||
class Stopped(BaseException):
|
||||
pass
|
||||
@@ -1703,7 +1717,7 @@ class TellTests(TouchCase):
|
||||
self.assertEqual(asked_at, list(range(4, total + 1, 3)) + [total + 1], "after every third half-second question, and at the end")
|
||||
for event, data, sid in self.sent:
|
||||
self.assertEqual((event, sid), ("ausboss.mask_by_touch.look", "the page that asked"))
|
||||
self.assertEqual(sorted(data), ["end", "node", "note"])
|
||||
self.assertEqual(sorted(data), ["end", "node", "note", "prompt_id"])
|
||||
self.assertEqual(data["node"], "7", "the node's id, as text")
|
||||
json.dumps(data) # it has to travel as JSON
|
||||
self.assertEqual([data["end"] for _, data, _ in self.sent], [False] * (len(self.sent) - 1) + [True])
|
||||
|
||||
@@ -63,6 +63,33 @@ class GrowShrinkTests(unittest.TestCase):
|
||||
|
||||
|
||||
class FillHolesTests(unittest.TestCase):
|
||||
def test_fill_preserves_existing_soft_alpha(self):
|
||||
from nodes._mask_by_touch_helpers import finish_mask
|
||||
|
||||
mask = torch.full((1, 20, 20), 0.75)
|
||||
for limit in (0.0, 1.0):
|
||||
self.assertTrue(torch.equal(fill_mask_holes(mask, limit), mask))
|
||||
self.assertTrue(torch.equal(finish_mask(mask, fill_holes=True), mask))
|
||||
mask[:, 9:11, 9:11] = 0.2
|
||||
filled = fill_mask_holes(mask)
|
||||
self.assertTrue(torch.all(filled[:, 9:11, 9:11] == 1.0))
|
||||
self.assertEqual(float(filled[0, 0, 0]), 0.75)
|
||||
|
||||
def test_fallback_uses_the_same_diagonal_connectivity(self):
|
||||
mask = torch.ones(1, 20, 20)
|
||||
mask[0, 0, 0] = mask[0, 1, 1] = 0
|
||||
# Two diagonally touching enclosed holes are separate components.
|
||||
mask[0, 8, 8:11] = 0
|
||||
mask[0, 9, 11:14] = 0
|
||||
for limit in (0.0, 1.0):
|
||||
expected = fill_mask_holes(mask, limit)
|
||||
with mock.patch.object(mask_helpers, "_scipy_fill_holes", None):
|
||||
actual = fill_mask_holes(mask, limit)
|
||||
self.assertTrue(torch.equal(actual, expected))
|
||||
self.assertEqual(float(actual[0, 1, 1]), 1.0)
|
||||
self.assertEqual(float(actual[0, 8, 8]), 1.0)
|
||||
self.assertEqual(float(actual[0, 0, 0]), 0.0)
|
||||
|
||||
def test_enclosed_hole_is_filled_but_outside_stays_empty(self):
|
||||
filled = fill_mask_holes(donut_mask())
|
||||
self.assertTrue(torch.all(filled[:, 6:10, 6:10] == 1.0))
|
||||
|
||||
@@ -43,6 +43,7 @@ NAMED = {
|
||||
"AusBossImageCropRotatePad": ["image"],
|
||||
"AusBossImageFolder": ["source", "folder"],
|
||||
"AusBossLaMaInpaint": ["model"],
|
||||
"AusBossLoadAudio": ["audio"],
|
||||
"AusBossLoadImagePad": ["image", "source_image"],
|
||||
"AusBossLoadVideo": ["video"],
|
||||
"AusBossLoraLoader": ["loras", "on_missing"],
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { readFileSync } from "node:fs";
|
||||
import test from "node:test";
|
||||
import vm from "node:vm";
|
||||
import { outputRecordQuery } from "../js/shared/input_preview.mjs";
|
||||
|
||||
const strip = (text) => text.replace(/^import\s+[\s\S]*?\sfrom\s+["'][^"']+["'];\s*/gm, "").replace(/^export /gm, "");
|
||||
|
||||
function entry() {
|
||||
const events = new Map();
|
||||
const timers = new Map();
|
||||
let now = 1000, next = 0, queue = { queue_pending: [], queue_running: [] };
|
||||
const checked = [];
|
||||
const context = vm.createContext({
|
||||
console, Map, Set, Promise, performance: { now: () => now },
|
||||
setTimeout(fn, delay) {
|
||||
const id = ++next;
|
||||
timers.set(id, { fn: () => { timers.delete(id); return fn(); }, delay });
|
||||
return id;
|
||||
},
|
||||
clearTimeout(id) { timers.delete(id); },
|
||||
api: { addEventListener: (name, fn) => events.set(name, fn), fetchApi: async () => ({ json: async () => queue }) },
|
||||
app: { graph: {}, registerExtension() {} },
|
||||
executionIdOf: (_graph, node) => String(node.id),
|
||||
isForeignRun(id) { checked.push(id); return id === "foreign"; },
|
||||
});
|
||||
vm.runInContext(strip(readFileSync(new URL("../js/mask_by_touch/index.js", import.meta.url), "utf8")), context);
|
||||
vm.runInContext(`
|
||||
globalThis.taken = [];
|
||||
globalThis.face = {alive:true,inFlight:true,askedAt:0,node:{id:7},settle(){this.inFlight=false;},takeNote(note){taken.push(note.key);}};
|
||||
faces.add(face);
|
||||
`, context);
|
||||
return { context, events, timers, checked, advance: (value) => { now = value; }, queue: (value) => { queue = value; } };
|
||||
}
|
||||
|
||||
test("interim notes check their prompt's workflow before delivery", () => {
|
||||
const { context, events, checked } = entry();
|
||||
const look = events.get("ausboss.mask_by_touch.look");
|
||||
look({ detail: { node: "7", prompt_id: "foreign", note: { key: "wrong tab" } } });
|
||||
assert.equal(context.taken.length, 0);
|
||||
look({ detail: { node: "7", prompt_id: "current", note: { key: "this tab" } } });
|
||||
assert.deepEqual([...context.taken], ["this tab"]);
|
||||
assert.deepEqual(checked, ["foreign", "current"]);
|
||||
});
|
||||
|
||||
test("an early empty status rechecks a deleted request without another event", async () => {
|
||||
const { context, events, timers, advance } = entry();
|
||||
events.get("status")({ detail: { exec_info: { queue_remaining: 0 } } });
|
||||
assert.equal(context.face.inFlight, true);
|
||||
assert.equal(timers.size, 1);
|
||||
const { fn, delay } = [...timers.values()][0];
|
||||
assert.ok(delay > 0 && delay <= 501);
|
||||
advance(1600);
|
||||
await fn();
|
||||
assert.equal(context.face.inFlight, false);
|
||||
});
|
||||
|
||||
test("the delayed empty check leaves a running request waiting", async () => {
|
||||
const { context, events, timers, advance, queue } = entry();
|
||||
events.get("status")({ detail: { exec_info: { queue_remaining: 0 } } });
|
||||
assert.equal(timers.size, 1);
|
||||
queue({ queue_pending: [], queue_running: [[0, "current"]] });
|
||||
advance(1600);
|
||||
await [...timers.values()][0].fn();
|
||||
assert.equal(context.face.inFlight, true);
|
||||
});
|
||||
|
||||
test("a newer queue status wins over a delayed empty response", async () => {
|
||||
const { context, events, timers, advance, queue } = entry();
|
||||
let finish;
|
||||
queue(new Promise((resolve) => { finish = resolve; }));
|
||||
const status = events.get("status");
|
||||
status({ detail: { exec_info: { queue_remaining: 0 } } });
|
||||
advance(1600);
|
||||
const checking = [...timers.values()][0].fn();
|
||||
status({ detail: { exec_info: { queue_remaining: 1 } } });
|
||||
finish({ queue_pending: [], queue_running: [] });
|
||||
await checking;
|
||||
assert.equal(context.face.inFlight, true);
|
||||
assert.equal(timers.size, 0);
|
||||
});
|
||||
|
||||
test("a failed queue response never cancels a waiting request", async () => {
|
||||
const { context, events, timers, advance, queue } = entry();
|
||||
events.get("status")({ detail: { exec_info: { queue_remaining: 0 } } });
|
||||
queue({ error: "Unavailable" });
|
||||
advance(1600);
|
||||
await [...timers.values()][0].fn();
|
||||
assert.equal(context.face.inFlight, true);
|
||||
});
|
||||
|
||||
test("a count-only result cannot make an obsolete preview current", () => {
|
||||
let extension;
|
||||
const context = vm.createContext({
|
||||
console, Map, Set, WeakMap, Promise, queueMicrotask() {}, setTimeout: () => 1, clearTimeout() {},
|
||||
api: { addEventListener() {}, apiURL: (path) => path },
|
||||
app: { graph: {}, nodeOutputs: {}, registerExtension(value) { extension = value; } },
|
||||
chainCallback(target, name, fn) {
|
||||
const prior = target[name];
|
||||
target[name] = function (...args) { const result = prior?.apply(this, args); fn.apply(this, args); return result; };
|
||||
},
|
||||
isForeignRun: () => false, hideInputsInDef() {}, outputLocatorId: () => "7", outputRecordQuery,
|
||||
});
|
||||
vm.runInContext(strip(readFileSync(new URL("../js/input_preview/index.js", import.meta.url), "utf8")), context);
|
||||
vm.runInContext("scheduleRefresh = () => {}; setNote = () => {}; setReadout = () => {};", context);
|
||||
class PreviewNode {}
|
||||
extension.beforeRegisterNodeDef(PreviewNode, { name: "AUSBOSS_NODES_MaskByName" });
|
||||
const node = new PreviewNode();
|
||||
const state = node.__ausbossInputPreview = { node, alive: true, stale: true, resultGone: true };
|
||||
node.onExecuted({ ausboss_mask_by_name: [{ found: 1, name: "new search", sure: [0.9] }] });
|
||||
assert.equal(state.stale, true);
|
||||
assert.equal(state.resultGone, true);
|
||||
node.onExecuted({ images: [{ filename: "new.png", type: "temp" }] });
|
||||
assert.equal(state.stale, false);
|
||||
assert.equal(state.resultGone, false);
|
||||
});
|
||||
@@ -0,0 +1,205 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { readFileSync } from "node:fs";
|
||||
import test from "node:test";
|
||||
import vm from "node:vm";
|
||||
import * as math from "../js/shared/touch_math.mjs";
|
||||
import * as brush from "../js/shared/brush.mjs";
|
||||
|
||||
const source = readFileSync(new URL("../js/shared/touch_stage.mjs", import.meta.url), "utf8");
|
||||
const strip = (text) => text.replace(/^import\s+[\s\S]*?\sfrom\s+["'][^"']+["'];\s*/gm, "").replace(/^export /gm, "");
|
||||
|
||||
function stage() {
|
||||
const timers = new Map();
|
||||
let nextTimer = 0;
|
||||
const context = vm.createContext({
|
||||
...math, ...brush, console, URLSearchParams, Uint8Array, Uint32Array, Float32Array,
|
||||
Map, Set, WeakMap, WeakSet, Promise,
|
||||
performance: { now: () => 1000 },
|
||||
setTimeout(fn, delay) { const id = ++nextTimer; timers.set(id, { fn, delay }); return id; },
|
||||
clearTimeout(id) { timers.delete(id); },
|
||||
requestAnimationFrame: () => 1, cancelAnimationFrame() {}, queueMicrotask,
|
||||
api: { apiURL: (path) => path }, notifyAusbossChange() {},
|
||||
chainCallback(target, name, fn) {
|
||||
const prior = target[name];
|
||||
target[name] = function (...args) { const result = prior?.apply(this, args); fn.apply(this, args); return result; };
|
||||
},
|
||||
});
|
||||
vm.runInContext(strip(source), context);
|
||||
const run = (code) => vm.runInContext(code, context);
|
||||
return { context, timers, run };
|
||||
}
|
||||
|
||||
test("late piece and picture downloads cannot replace a newer note", async () => {
|
||||
const { context, run } = stage();
|
||||
const downloads = new Map();
|
||||
context.downloads = downloads;
|
||||
run(`
|
||||
loadImage = url => new Promise(resolve => downloads.set(new URLSearchParams(url.split('?')[1]).get('filename'), resolve));
|
||||
readPixels = (_image, w, h) => new Uint8Array(w*h*4).fill(255);
|
||||
syncState = () => {};
|
||||
show = (_face, entry) => { globalThis.shown = entry.pieces.list[0].name; };
|
||||
const face = {alive:true,flying:[],turn:0,sourceEpoch:0,node:{widgets:[]}};
|
||||
const base = {key:'4x4-picture',width:4,height:4,scale:1,stamp:''};
|
||||
globalThis.entry = pictureFor(base, face);
|
||||
const note = (name, more) => ({...base,picture:{filename:name+'.jpg'},pieces:{list:[{x:1,y:1,kind:'name',name,sure:1}],planes:[{filename:name+'.png'}],more}});
|
||||
globalThis.oldJob = takeNote(face, note('old', true));
|
||||
globalThis.newJob = takeNote(face, note('new', false));
|
||||
`);
|
||||
downloads.get("new.jpg")({});
|
||||
downloads.get("new.png")({});
|
||||
await context.newJob;
|
||||
downloads.get("old.jpg")({});
|
||||
downloads.get("old.png")({});
|
||||
await context.oldJob;
|
||||
assert.equal(context.shown, "new");
|
||||
assert.equal(context.entry.pieces.list[0].name, "new");
|
||||
assert.equal(context.entry.file, "new.jpg");
|
||||
assert.equal(context.entry.scoped, true);
|
||||
});
|
||||
|
||||
test("selection, area and fine caches belong to each face", () => {
|
||||
const { run } = stage();
|
||||
run(`
|
||||
const note = {key:'same-picture',width:2,height:2,scale:1};
|
||||
const first = pictureFor(note, {});
|
||||
const second = pictureFor(note, {});
|
||||
const text = encodeTouches(first.key,[{t:'subject',op:1}]);
|
||||
const state = {pic:first,items:decodeTouches(text).items,stamp:stampOf(text),stamps:prefixStamps(first.key,decodeTouches(text).items)};
|
||||
remember(first,state.stamp,Uint8Array.from([1,0,0,0]));
|
||||
keepArea(first,'subject',Uint8Array.from([1,0,0,0]));
|
||||
first.fine = {made:'first model'};
|
||||
remember(second,state.stamp,Uint8Array.from([0,0,0,1]));
|
||||
keepArea(second,'subject',Uint8Array.from([0,0,0,1]));
|
||||
second.fine = {made:'second model'};
|
||||
resolve(state);
|
||||
globalThis.result = {raw:Array.from(state.raw),area:Array.from(first.areas.get('subject')),fine:first.fine.made};
|
||||
`);
|
||||
const result = JSON.parse(run("JSON.stringify(result)"));
|
||||
assert.deepEqual(result, { raw: [1, 0, 0, 0], area: [1, 0, 0, 0], fine: "first model" });
|
||||
});
|
||||
|
||||
test("late selection and fine downloads cannot overwrite the current stamp", async () => {
|
||||
const { context, run } = stage();
|
||||
const downloads = context.downloads = new Map();
|
||||
run(`
|
||||
loadImage = url => new Promise(resolve => downloads.set(new URLSearchParams(url.split('?')[1]).get('filename'), resolve));
|
||||
readPixels = (image, w, h) => new Uint8Array(w*h*4).fill(image.value);
|
||||
syncState = () => {}; show = () => {};
|
||||
const face = {alive:true,flying:[],turn:0,sourceEpoch:0,node:{widgets:[]}};
|
||||
const base = {key:'2x2-picture',width:2,height:2,scale:1,stamp:'same',picture:{filename:'picture.jpg'}};
|
||||
globalThis.entry = pictureFor(base,face);
|
||||
entry.image = {}; entry.file = 'picture.jpg';
|
||||
const note = name => ({...base,selection:{filename:name+'-selection.png'},fine:{file:{filename:name+'-fine.png'},made:name}});
|
||||
globalThis.oldJob = takeNote(face,note('old'));
|
||||
globalThis.newJob = takeNote(face,note('new'));
|
||||
`);
|
||||
downloads.get("new-selection.png")({ value: 0 });
|
||||
downloads.get("new-fine.png")({ value: 0 });
|
||||
await context.newJob;
|
||||
downloads.get("old-selection.png")({ value: 255 });
|
||||
downloads.get("old-fine.png")({ value: 255 });
|
||||
await context.oldJob;
|
||||
assert.deepEqual([...context.entry.states.get("same")], [0, 0, 0, 0]);
|
||||
assert.equal(context.entry.fine.made, "new");
|
||||
});
|
||||
|
||||
test("restored picks never schedule fine processing", () => {
|
||||
const { context, timers, run } = stage();
|
||||
run(`
|
||||
adopt = () => false; readItems = () => {}; resolve = () => {};
|
||||
syncState = () => {}; refreshHover = () => {}; draw = () => {}; drawInk = () => {};
|
||||
settings = () => ({fine:'model.safetensors'}); fineOf = () => null;
|
||||
globalThis.requested = [];
|
||||
requestRun = (_face, ask) => requested.push(ask);
|
||||
const pic = {key:'picture',piecesTag:''};
|
||||
const face = {alive:true,pic,node:{},items:[{t:'paint',op:1,r:10,pts:[[1,1]]}],exact:true,stamp:'same',shownPieces:'',pending:[],inFlight:false};
|
||||
show(face,pic,{stamp:'same'},null,{restored:true});
|
||||
`);
|
||||
for (const { fn } of [...timers.values()]) fn();
|
||||
assert.deepEqual([...context.requested], []);
|
||||
});
|
||||
|
||||
test("source subscriptions release removed faces while the loader survives", () => {
|
||||
const { context, run } = stage();
|
||||
run(`
|
||||
globalThis.reads = 0;
|
||||
globalThis.priorCalls = 0;
|
||||
const loader = {widgets:[{name:'image',value:'picture.png',callback(){priorCalls++;}}]};
|
||||
ownLoaderNode = () => loader;
|
||||
for (let n=0;n<100;n++) {
|
||||
const face = {node:{},watchedSources:new WeakSet(),forgetSources:[],host:{},get alive(){reads++;return false;}};
|
||||
followOwnLoader(face);
|
||||
for (const forget of face.forgetSources) forget();
|
||||
}
|
||||
loader.widgets[0].callback();
|
||||
`);
|
||||
assert.equal(context.reads, 0);
|
||||
assert.equal(context.priorCalls, 1);
|
||||
});
|
||||
|
||||
test("plain Load Image subscriptions are removable too", async () => {
|
||||
const { context, run } = stage();
|
||||
run(`
|
||||
globalThis.reads = 0;
|
||||
const widget = {};
|
||||
loaderSource = () => null; loaderWidget = () => widget;
|
||||
for (let n=0;n<100;n++) {
|
||||
const face = {node:{},sourceUrl:'',watchedSources:new WeakSet(),forgetSources:[],get alive(){reads++;return false;}};
|
||||
syncSource(face);
|
||||
for (const forget of face.forgetSources) forget();
|
||||
}
|
||||
widget.callback();
|
||||
`);
|
||||
await Promise.resolve();
|
||||
assert.equal(context.reads, 0);
|
||||
});
|
||||
|
||||
test("destroy cancels the pending click and releases source subscriptions", () => {
|
||||
const { context, timers, run } = stage();
|
||||
run(`
|
||||
globalThis.forgotten = 0; globalThis.aborted = false;
|
||||
globalThis.face = {alive:true,pendingTimer:setTimeout(()=>{},500),forgetSources:[()=>forgotten++]};
|
||||
globalThis.abort = {abort(){aborted=true;}};
|
||||
`);
|
||||
const start = source.indexOf(" face.destroy = () => {");
|
||||
const end = source.indexOf("\n };", start) + "\n };".length;
|
||||
run(source.slice(start, end));
|
||||
context.face.destroy();
|
||||
assert.equal(context.face.alive, false);
|
||||
assert.equal(timers.size, 0);
|
||||
assert.equal(context.forgotten, 1);
|
||||
assert.equal(context.aborted, true);
|
||||
});
|
||||
|
||||
test("Clear is enabled for malformed stored touches and erases the text", () => {
|
||||
const { context, run } = stage();
|
||||
run(`
|
||||
const toggle = {toggle(){}};
|
||||
globalThis.face = {node:{},pic:null,items:[],pending:[],past:[],touches:{value:'{'},host:{},
|
||||
undo:{},clear:{},toolSwitch:{set(){},root:{classList:toggle}},softField:{classList:toggle},softBox:{set(){}},
|
||||
subjectButton:{},backgroundButton:{},eye:{classList:toggle},size:{set(){}},view:'tint'};
|
||||
syncTools(face);
|
||||
`);
|
||||
assert.equal(context.face.clear.disabled, false);
|
||||
run(`
|
||||
dropPending = () => {}; syncReadout = () => {}; syncState = () => {}; refreshHover = () => {};
|
||||
button = (_class, _text, _title, click) => ({click});
|
||||
globalThis.signal = null;
|
||||
`);
|
||||
const start = source.indexOf(" face.clear = button(");
|
||||
const end = source.indexOf(" }, signal);", start) + " }, signal);".length;
|
||||
run(source.slice(start, end));
|
||||
context.face.clear.click();
|
||||
assert.equal(context.face.touches.value, "");
|
||||
});
|
||||
|
||||
test("named pieces of one through four pixels can be added and removed", () => {
|
||||
for (let size = 1; size <= 4; size++) {
|
||||
const planes = [new Uint32Array(size).fill(1)];
|
||||
const sizes = math.pieceSizes(planes, 1);
|
||||
assert.equal(math.pieceAt(planes, 0, { sizes, inside: [0] }), 0);
|
||||
assert.equal(math.pieceAt(planes, 0, { sizes, inside: [size], adding: false }), 0);
|
||||
assert.equal(math.pieceAt(planes, 0, { sizes, inside: [size] }), -1);
|
||||
assert.equal(math.pieceAt(planes, 0, { sizes, inside: [0], adding: false }), -1);
|
||||
}
|
||||
});
|
||||
@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
|
||||
|
||||
import {
|
||||
CARD_PADDING, GROUP_HEIGHT, ROW_GAP, ROW_HEIGHT, SECTION_HEIGHT, SLOT_OFFSET, SOCKETLESS_CHOICE, SOCKETLESS_TEXT,
|
||||
cardHeight, choiceLabel, comboValues, commitWidgetValue, holdsUnknownValue, markSocketless, resetUnknownValues, rowHeight, rowInLook, rowKind, rowMuted, rowTops,
|
||||
cardHeight, choiceLabel, commitWidgetValue, holdsUnknownValue, markSocketless, resetUnknownValues, rowHeight, rowInLook, rowKind, rowMuted, rowTops,
|
||||
scrubSteps, segmentFits, socketWidgetY, visibleRows, widgetTooltip,
|
||||
} from "../js/shared/widget_card_math.mjs";
|
||||
|
||||
@@ -418,49 +418,3 @@ test("a choice's words come from the row: a map, or a function for lists only th
|
||||
// The pill or the list is chosen from the words a person reads, so two long file names still make a short pill.
|
||||
assert.equal(rowKind({ widget: "fine_edges", labels: row.labels }, { type: "combo", options: { values: ["off", "vitmatte-small-composition-1k/model.safetensors"] } }), "segment");
|
||||
});
|
||||
|
||||
test("dynamic combo values receive the widget and preserve numeric and boolean choices", () => {
|
||||
const values = [0, false, "0"];
|
||||
const widget = { type: "combo", value: 0, options: { values: (own) => {
|
||||
assert.equal(own, widget);
|
||||
return values;
|
||||
} } };
|
||||
assert.equal(comboValues(widget), values);
|
||||
assert.equal(holdsUnknownValue(widget), false);
|
||||
widget.value = false;
|
||||
assert.equal(holdsUnknownValue(widget), false);
|
||||
widget.value = true;
|
||||
assert.equal(holdsUnknownValue(widget), true);
|
||||
for (const value of [undefined, null, "choices", {}]) {
|
||||
assert.deepEqual(comboValues({ options: { values: () => value } }), []);
|
||||
}
|
||||
assert.deepEqual(comboValues(null), []);
|
||||
});
|
||||
|
||||
test("choice labels keep explicit empty and numeric labels and use values only as a fallback", () => {
|
||||
const row = { labels: { off: "", zero: 0, missing: null } };
|
||||
assert.equal(choiceLabel(row, "off"), "");
|
||||
assert.equal(choiceLabel(row, "zero"), 0);
|
||||
assert.equal(choiceLabel(row, "missing"), "missing");
|
||||
assert.equal(choiceLabel({ labels: () => undefined }, 0), "0");
|
||||
assert.equal(choiceLabel(null, false), "false");
|
||||
});
|
||||
|
||||
test("segmented choices include the exact label-length limit and reject the next character", () => {
|
||||
assert.equal(segmentFits(["a".repeat(13), "b".repeat(13)]), true);
|
||||
assert.equal(segmentFits(["a".repeat(13), "b".repeat(14)]), false);
|
||||
assert.equal(segmentFits([0, false]), true);
|
||||
assert.equal(segmentFits([]), false);
|
||||
assert.equal(segmentFits(null), false);
|
||||
});
|
||||
|
||||
test("scrub steps honor legacy increments, explicit precision and the pixel-range boundary", () => {
|
||||
assert.deepEqual(scrubSteps(), { step: 0.1, fineStep: 0.01, decimals: 2 });
|
||||
assert.deepEqual(scrubSteps({}, false), { step: 1, fineStep: 1, decimals: 0 });
|
||||
assert.deepEqual(scrubSteps({ step: 0.5 }), { step: 0.5, fineStep: 0.05, decimals: 2 });
|
||||
assert.deepEqual(scrubSteps({ step: 5, step2: 0.25, precision: 3, min: 0, max: 2 }),
|
||||
{ step: 0.25, fineStep: 0.25, decimals: 3 });
|
||||
assert.equal(scrubSteps({ min: 0, max: 2048 }, false, true).step, 1);
|
||||
assert.equal(scrubSteps({ min: 0, max: 2049 }, false, true).step, 8);
|
||||
assert.equal(scrubSteps({}, false, true).step, 1, "an unknown range is not assumed to be a wide pixel size");
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user