Jony
ba920f2b66
Replace the prior release tree with the current plugin, frontend, tests, and documentation. Document retired node IDs and the public Gitea update source.
4036 lines
172 KiB
JavaScript
4036 lines
172 KiB
JavaScript
import assert from "node:assert/strict";
|
||
import { webcrypto } from "node:crypto";
|
||
import { File } from "node:buffer";
|
||
import fs from "node:fs";
|
||
import vm from "node:vm";
|
||
|
||
|
||
const sourcePath = new URL("../web/js/o1keyImageGenerator.js", import.meta.url);
|
||
const rawSource = fs.readFileSync(sourcePath, "utf8");
|
||
const source = rawSource.replace(/^import .*;\s*$/gm, "");
|
||
const migrationPath = new URL("../web/js/migrateWorkflow.js", import.meta.url);
|
||
const migrationSource = fs.readFileSync(migrationPath, "utf8");
|
||
const nanoPromptOptimizerPath = new URL("../web/js/nanoBananaPromptOptimizer.js", import.meta.url);
|
||
assert.equal(fs.existsSync(nanoPromptOptimizerPath), false);
|
||
const batchReferenceLabelsPath = new URL("../web/js/batchNanoBananaReferenceLabels.js", import.meta.url);
|
||
const batchReferenceLabelsSource = fs.readFileSync(batchReferenceLabelsPath, "utf8");
|
||
const nanoRouteLabelsPath = new URL("../web/js/nanoBananaRouteLabels.js", import.meta.url);
|
||
const nanoRouteLabelsSource = fs.readFileSync(nanoRouteLabelsPath, "utf8");
|
||
const batchNanoQualityPath = new URL("../web/js/batchNanoBananaImageQuality.js", import.meta.url);
|
||
const batchNanoQualitySource = fs.readFileSync(batchNanoQualityPath, "utf8");
|
||
const seedanceMultiModalDynamicPath = new URL("../web/js/seedanceMultiModalDynamic.js", import.meta.url);
|
||
const seedanceMultiModalDynamicSource = fs.readFileSync(seedanceMultiModalDynamicPath, "utf8");
|
||
const seedanceAutoPassDynamicPath = new URL("../web/js/seedanceAutoPassDynamic.js", import.meta.url);
|
||
const seedanceAutoPassDynamicSource = fs.readFileSync(seedanceAutoPassDynamicPath, "utf8");
|
||
const seedanceResolutionGuardPath = new URL("../web/js/seedanceResolutionGuard.js", import.meta.url);
|
||
const seedanceResolutionGuardSource = fs.readFileSync(seedanceResolutionGuardPath, "utf8");
|
||
const minimaxH3ParameterGuardPath = new URL("../web/js/minimaxH3ParameterGuard.js", import.meta.url);
|
||
const minimaxH3ParameterGuardSource = fs.readFileSync(minimaxH3ParameterGuardPath, "utf8");
|
||
|
||
let batchReferenceLabelsExtension;
|
||
vm.runInNewContext(batchReferenceLabelsSource.replace(/^import .*;\s*$/gm, ""), {
|
||
app: { registerExtension(extension) { batchReferenceLabelsExtension = extension; } },
|
||
requestAnimationFrame(callback) { callback(); },
|
||
});
|
||
for (const comfyClass of ["BatchNanoBananaPro", "O1keyGPTImageBatch"]) {
|
||
const pathCountWidget = {
|
||
name: "图片路径数量",
|
||
value: "1个路径",
|
||
callback() { return "path-count-callback"; },
|
||
};
|
||
const inputs = [1, 2, 3].map(index => ({ name: `参考图组.参考图${index}` }));
|
||
const node = {
|
||
comfyClass,
|
||
widgets: [pathCountWidget],
|
||
inputs,
|
||
setDirtyCanvas() {},
|
||
};
|
||
|
||
batchReferenceLabelsExtension.nodeCreated(node);
|
||
assert.deepEqual(inputs.map(input => input.label), ["参考图2", "参考图3", "参考图4"]);
|
||
pathCountWidget.value = "3个路径";
|
||
assert.equal(pathCountWidget.callback(), "path-count-callback");
|
||
assert.deepEqual(inputs.map(input => input.label), ["参考图4", "参考图5", "参考图6"]);
|
||
assert.deepEqual(inputs.map(input => input.name), [
|
||
"参考图组.参考图1", "参考图组.参考图2", "参考图组.参考图3",
|
||
]);
|
||
}
|
||
|
||
class ClassList {
|
||
constructor(element) {
|
||
this.element = element;
|
||
this.values = new Set();
|
||
}
|
||
add(value) { this.values.add(value); }
|
||
remove(value) { this.values.delete(value); }
|
||
contains(value) { return this.values.has(value); }
|
||
toggle(value, force) {
|
||
const enabled = force ?? !this.values.has(value);
|
||
if (enabled) this.values.add(value);
|
||
else this.values.delete(value);
|
||
return enabled;
|
||
}
|
||
}
|
||
|
||
class Element {
|
||
constructor(tagName) {
|
||
this.tagName = tagName.toUpperCase();
|
||
this.children = [];
|
||
this.className = "";
|
||
this.classList = new ClassList(this);
|
||
this.style = { setProperty(name, value) { this[name] = value; } };
|
||
this.options = {};
|
||
this.textContent = "";
|
||
this.disabled = false;
|
||
this.listeners = new Map();
|
||
this.dataset = {};
|
||
}
|
||
append(...items) { this.children.push(...items); }
|
||
prepend(...items) { this.children.unshift(...items); }
|
||
replaceChildren(...items) { this.children = [...items]; }
|
||
addEventListener(type, listener) { this.listeners.set(type, listener); }
|
||
setAttribute(name, value) { this[name] = value; }
|
||
dispatch(type, event = { stopPropagation() {} }) { return this.listeners.get(type)?.(event); }
|
||
focus() { document.activeElement = this; }
|
||
}
|
||
|
||
const createdElements = [];
|
||
const elementsById = new Map();
|
||
const document = {
|
||
activeElement: null,
|
||
head: {
|
||
append(element) {
|
||
if (element.id) elementsById.set(element.id, element);
|
||
},
|
||
appendChild(element) {
|
||
if (element.id) elementsById.set(element.id, element);
|
||
},
|
||
},
|
||
body: {
|
||
append(element) {
|
||
if (element.id) elementsById.set(element.id, element);
|
||
},
|
||
},
|
||
createElement(tagName) {
|
||
const element = new Element(tagName);
|
||
createdElements.push(element);
|
||
return element;
|
||
},
|
||
createElementNS(_namespace, tagName) {
|
||
const element = new Element(tagName);
|
||
createdElements.push(element);
|
||
return element;
|
||
},
|
||
getElementById(id) { return elementsById.get(id) || null; },
|
||
querySelector(selector) { return this._querySelector?.(selector) || null; },
|
||
addEventListener() {},
|
||
removeEventListener() {},
|
||
};
|
||
|
||
let nextNodeId = 1;
|
||
let nextLinkId = 1;
|
||
const graph = {
|
||
nodes: new Map(),
|
||
links: new Map(),
|
||
add(node) {
|
||
node.id = nextNodeId++;
|
||
node.graph = this;
|
||
this.nodes.set(node.id, node);
|
||
},
|
||
getNodeById(id) { return this.nodes.get(id); },
|
||
beforeChange() {},
|
||
afterChange() {},
|
||
setDirtyCanvas() {},
|
||
};
|
||
|
||
const LiteGraph = {
|
||
createNode(type) {
|
||
return {
|
||
type,
|
||
comfyClass: type,
|
||
pos: [0, 0],
|
||
size: [300, 260],
|
||
properties: {},
|
||
inputs: [{ link: null }],
|
||
widgets: [],
|
||
};
|
||
},
|
||
};
|
||
|
||
const app = {
|
||
graph,
|
||
registerExtension(extension) { this.extension = extension; },
|
||
extensionManager: {},
|
||
};
|
||
const executedEvents = [];
|
||
const statusEvents = [];
|
||
const apiListeners = new Map();
|
||
const api = {
|
||
apiURL: (value) => value,
|
||
dispatchCustomEvent(type, detail) {
|
||
if (type === "executed") {
|
||
executedEvents.push(detail);
|
||
app.nodeOutputs ??= {};
|
||
app.nodeOutputs[String(detail.display_node)] = detail.output;
|
||
graph.getNodeById(detail.display_node)?.onExecuted?.(detail.output);
|
||
} else if (type === "status") {
|
||
statusEvents.push(detail);
|
||
}
|
||
for (const listener of apiListeners.get(type) || []) listener({ detail });
|
||
},
|
||
addEventListener(type, listener) {
|
||
if (!apiListeners.has(type)) apiListeners.set(type, []);
|
||
apiListeners.get(type).push(listener);
|
||
},
|
||
getQueue: async () => ({
|
||
Running: [],
|
||
Pending: [{ id: "native-pending", status: "pending", create_time: 1, priority: 1 }],
|
||
}),
|
||
getHistory: async () => [
|
||
{ id: "native-completed", status: "completed", create_time: 1, priority: 1 },
|
||
],
|
||
getJobDetail: async () => undefined,
|
||
cancelJob: async () => {},
|
||
cancelJobs: async () => {},
|
||
deleteItem: async () => {},
|
||
clearItems: async () => {},
|
||
};
|
||
const editorRequests = [];
|
||
const openReferenceImageEditor = async (options) => {
|
||
editorRequests.push(options);
|
||
return null;
|
||
};
|
||
|
||
const context = vm.createContext({
|
||
app,
|
||
api,
|
||
document,
|
||
window: { LiteGraph },
|
||
URL,
|
||
URLSearchParams,
|
||
FormData,
|
||
File,
|
||
Event,
|
||
openReferenceImageEditor,
|
||
crypto: webcrypto,
|
||
console,
|
||
clearTimeout,
|
||
setTimeout,
|
||
requestAnimationFrame: (callback) => callback(),
|
||
});
|
||
vm.runInContext(source, context, { filename: sourcePath.pathname });
|
||
|
||
{
|
||
const nodeData = {
|
||
name: "O1keyImageGenerator",
|
||
input: { optional: { external_prompt: ["STRING", {}], keep: ["IMAGE", {}] } },
|
||
};
|
||
await app.extension.beforeRegisterNodeDef(function GeneratorNode() {}, nodeData);
|
||
assert.equal("external_prompt" in nodeData.input.optional, false);
|
||
assert.equal("keep" in nodeData.input.optional, true);
|
||
}
|
||
|
||
const setStatus = vm.runInContext("setStatus", context);
|
||
const makeDropdown = vm.runInContext("makeDropdown", context);
|
||
const isGeneratedSeedControl = vm.runInContext("isGeneratedSeedControl", context);
|
||
const hideBackendWidgets = vm.runInContext("hideBackendWidgets", context);
|
||
const queueGeneration = vm.runInContext("queueGeneration", context);
|
||
const modelOptions = vm.runInContext("MODEL_OPTIONS", context);
|
||
const routeOptions = vm.runInContext("ROUTES", context);
|
||
const maxReferences = vm.runInContext("MAX_REFERENCES", context);
|
||
const maxRequestReferences = vm.runInContext("MAX_REQUEST_REFERENCES", context);
|
||
const referenceLimit = vm.runInContext("referenceLimit", context);
|
||
const syncModelOptions = vm.runInContext("syncModelOptions", context);
|
||
const syncGeneratorOutputVisibility = vm.runInContext("syncGeneratorOutputVisibility", context);
|
||
const syncGptOutputOptions = vm.runInContext("syncGptOutputOptions", context);
|
||
const optimizePrompt = vm.runInContext("optimizePrompt", context);
|
||
const applyGeneratorDefaultSize = vm.runInContext("applyGeneratorDefaultSize", context);
|
||
const createSaveNodeForBatch = vm.runInContext("createSaveNodeForBatch", context);
|
||
const acquireSaveNodeForBatch = vm.runInContext("acquireSaveNodeForBatch", context);
|
||
const acquireLayerSaveNodeForBatch = vm.runInContext("acquireLayerSaveNodeForBatch", context);
|
||
const splitLayerSaveResults = vm.runInContext("splitLayerSaveResults", context);
|
||
const prepareStandardQueue = vm.runInContext("prepareStandardQueue", context);
|
||
const startNextStandardExecution = vm.runInContext("startNextStandardExecution", context);
|
||
const finishStandardQueue = vm.runInContext("finishStandardQueue", context);
|
||
const takeStandardQueueRoutes = vm.runInContext("takeStandardQueueRoutes", context);
|
||
const filterStandardQueueOutputs = vm.runInContext("filterStandardQueueOutputs", context);
|
||
const reroutePartialExecutionTargets = vm.runInContext("reroutePartialExecutionTargets", context);
|
||
const buildSavePanel = vm.runInContext("buildSavePanel", context);
|
||
const generatorSaveSettings = vm.runInContext("generatorSaveSettings", context);
|
||
const beginGenerationBatch = vm.runInContext("beginGenerationBatch", context);
|
||
const finishGenerationBatch = vm.runInContext("finishGenerationBatch", context);
|
||
const handleParallelImageJob = vm.runInContext("handleParallelImageJob", context);
|
||
const recoverParallelBatch = vm.runInContext("recoverParallelBatch", context);
|
||
const detachParallelBatchNode = vm.runInContext("detachParallelBatchNode", context);
|
||
const installNativeTaskQueueBridge = vm.runInContext("installNativeTaskQueueBridge", context);
|
||
const updateNativeQueueJob = vm.runInContext("updateNativeQueueJob", context);
|
||
const acceptFiles = vm.runInContext("acceptFiles", context);
|
||
const validateSeedreamReferenceDimensions = vm.runInContext("validateSeedreamReferenceDimensions", context);
|
||
const validateSeedreamReferenceFile = vm.runInContext("validateSeedreamReferenceFile", context);
|
||
const bindImageFileDropTarget = vm.runInContext("bindImageFileDropTarget", context);
|
||
const canvasImageCandidates = vm.runInContext("canvasImageCandidates", context);
|
||
const importCanvasImage = vm.runInContext("importCanvasImage", context);
|
||
const readCanvasImageFile = vm.runInContext("readCanvasImageFile", context);
|
||
const renderSaveResults = vm.runInContext("renderSaveResults", context);
|
||
const storedSaveResults = vm.runInContext("storedSaveResults", context);
|
||
const storedSaveSlots = vm.runInContext("storedSaveSlots", context);
|
||
const reconcileSaveSlotsWithResults = vm.runInContext("reconcileSaveSlotsWithResults", context);
|
||
const expandPanelPromptTasks = vm.runInContext("expandPanelPromptTasks", context);
|
||
const expandPanelGenerationTasks = vm.runInContext("expandPanelGenerationTasks", context);
|
||
const referenceBadgeDetails = vm.runInContext("referenceBadgeDetails", context);
|
||
const referenceDropDestination = vm.runInContext("referenceDropDestination", context);
|
||
const moveReference = vm.runInContext("moveReference", context);
|
||
const renderReferenceRole = vm.runInContext("renderReferenceRole", context);
|
||
const editReference = vm.runInContext("editReference", context);
|
||
const replaceReference = vm.runInContext("replaceReference", context);
|
||
const updateBatchReferenceHint = vm.runInContext("updateBatchReferenceHint", context);
|
||
const updateBatchSummary = vm.runInContext("updateBatchSummary", context);
|
||
const initializeSaveSlots = vm.runInContext("initializeSaveSlots", context);
|
||
const updateSaveSlotsForState = vm.runInContext("updateSaveSlotsForState", context);
|
||
const applyPartialSaveSlots = vm.runInContext("applyPartialSaveSlots", context);
|
||
const applyCompletedSaveSlots = vm.runInContext("applyCompletedSaveSlots", context);
|
||
const retryFailedSaveSlot = vm.runInContext("retryFailedSaveSlot", context);
|
||
const saveSlotsWidgetHeight = vm.runInContext("saveSlotsWidgetHeight", context);
|
||
const syncSaveSlotsWidget = vm.runInContext("syncSaveSlotsWidget", context);
|
||
const preferredNativeSavePreviewHeight = vm.runInContext("preferredNativeSavePreviewHeight", context);
|
||
const fitSaveNodeToNativeImages = vm.runInContext("fitSaveNodeToNativeImages", context);
|
||
const syncNativeQueueCounts = vm.runInContext("syncNativeQueueCounts", context);
|
||
const restoreNativeSavePreview = vm.runInContext("restoreNativeSavePreview", context);
|
||
const regenerateFromSaveNode = vm.runInContext("regenerateFromSaveNode", context);
|
||
const syncNativePreviewAction = vm.runInContext("syncNativePreviewAction", context);
|
||
const formatImageGenerationError = vm.runInContext("formatImageGenerationError", context);
|
||
const formatSeedanceGenerationError = vm.runInContext("formatSeedanceGenerationError", context);
|
||
const seedanceErrorNodeTypes = vm.runInContext("SEEDANCE_ERROR_NODE_TYPES", context);
|
||
const updateExecutionErrorOverlay = vm.runInContext("updateExecutionErrorOverlay", context);
|
||
|
||
installNativeTaskQueueBridge();
|
||
|
||
function createRecoveryNodes(batchId, generatorId, saveNodeId) {
|
||
const linkId = nextLinkId++;
|
||
const generator = {
|
||
id: generatorId,
|
||
type: "O1keyImageGenerator",
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
outputs: [{ links: [linkId] }],
|
||
widgets: [
|
||
{ name: "模型", value: "Nano Banana 2" },
|
||
{ name: "filename_prefix", value: "o1key" },
|
||
{ name: "格式", value: "原始" },
|
||
{ name: "保存位置", value: "" },
|
||
{ name: "命名规则", value: "自定义前缀" },
|
||
],
|
||
};
|
||
const saveNode = {
|
||
id: saveNodeId,
|
||
type: "O1keyImageSave",
|
||
comfyClass: "O1keyImageSave",
|
||
graph,
|
||
inputs: [{ link: linkId }],
|
||
properties: {
|
||
o1keyBatchId: batchId,
|
||
o1keyGeneratorNodeId: generatorId,
|
||
},
|
||
widgets: [],
|
||
_o1igsLastResults: [],
|
||
setDirtyCanvas() {},
|
||
};
|
||
graph.nodes.set(generatorId, generator);
|
||
graph.nodes.set(saveNodeId, saveNode);
|
||
graph.links.set(linkId, { origin_id: generatorId, target_id: saveNodeId });
|
||
return { generator, saveNode, linkId };
|
||
}
|
||
|
||
{
|
||
const seed = { name: "seed", value: 123, options: {} };
|
||
const generatedControl = {
|
||
name: "control_after_generate",
|
||
value: "randomize",
|
||
options: {},
|
||
};
|
||
const prefixedGeneratedControl = {
|
||
name: "O1keyImageGenerator control_after_generate",
|
||
value: "randomize",
|
||
options: {},
|
||
};
|
||
const unrelatedControl = { name: "control_before_generate", options: {} };
|
||
const node = {
|
||
widgets: [seed, generatedControl, prefixedGeneratedControl, unrelatedControl],
|
||
};
|
||
|
||
assert.equal(isGeneratedSeedControl(generatedControl), true);
|
||
assert.equal(isGeneratedSeedControl(prefixedGeneratedControl), true);
|
||
assert.equal(isGeneratedSeedControl(unrelatedControl), false);
|
||
hideBackendWidgets(node);
|
||
assert.equal(seed.hidden, true);
|
||
assert.equal(generatedControl.hidden, true);
|
||
assert.equal(generatedControl.options.hidden, true);
|
||
const hiddenSize = generatedControl.computeSize();
|
||
assert.equal(hiddenSize[0], 0);
|
||
assert.equal(hiddenSize[1], -4);
|
||
assert.equal(prefixedGeneratedControl.hidden, true);
|
||
assert.equal(unrelatedControl.hidden, undefined);
|
||
}
|
||
|
||
{
|
||
const linkId = 8800;
|
||
const generator = {
|
||
id: 880,
|
||
type: "O1keyImageGenerator",
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
inputs: [],
|
||
outputs: [{ links: [linkId] }],
|
||
widgets: [],
|
||
_o1igPrompt: { value: "", focus() {} },
|
||
_o1igModel: { value: "Nano Banana 2" },
|
||
_o1igRoute: { value: "畅速" },
|
||
_o1igThinking: { value: "低" },
|
||
_o1igResolution: { value: "智能" },
|
||
_o1igRatio: { value: "智能" },
|
||
_o1igCount: { value: "1" },
|
||
_o1igSeed: { value: "0" },
|
||
_o1igReferences: [],
|
||
_o1igModelReferences: [],
|
||
_o1igMask: null,
|
||
_o1igQuality: { value: "自动" },
|
||
_o1igOutputFormat: { value: "jpeg" },
|
||
_o1igResize: { value: "不缩放" },
|
||
_o1igBackground: { value: "auto" },
|
||
_o1igBatchEnabled: false,
|
||
_o1igBatchMode: { value: "一组搭配+多模特" },
|
||
_o1igNamingRule: { value: "自定义前缀" },
|
||
_o1igFilenamePrefix: { value: "o1key" },
|
||
_o1igSaveFormat: { value: "原始" },
|
||
_o1igSaveLocation: { value: "" },
|
||
_o1igLayerDecomposition: { value: "关闭" },
|
||
_o1igPending: [],
|
||
_o1igModelPending: [],
|
||
_o1igMaskPending: false,
|
||
_o1igGenerate: new Element("button"),
|
||
_o1igStatus: new Element("div"),
|
||
_o1igPanel: new Element("div"),
|
||
};
|
||
const saveNode = {
|
||
id: 881,
|
||
type: "O1keyImageSave",
|
||
comfyClass: "O1keyImageSave",
|
||
graph,
|
||
inputs: [{ link: linkId }],
|
||
widgets: [],
|
||
properties: {},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
graph.nodes.set(saveNode.id, saveNode);
|
||
graph.links.set(linkId, {
|
||
origin_id: generator.id,
|
||
origin_slot: 0,
|
||
target_id: saveNode.id,
|
||
target_slot: 0,
|
||
});
|
||
const queueCalls = [];
|
||
const originalQueuePrompt = app.queuePrompt;
|
||
app.queuePrompt = async (...args) => {
|
||
queueCalls.push(args);
|
||
return true;
|
||
};
|
||
|
||
await queueGeneration(generator);
|
||
assert.deepEqual(queueCalls, []);
|
||
assert.equal(generator._o1igStatus.textContent, "请输入提示词");
|
||
|
||
generator._o1igPrompt.value = "测试替换等待";
|
||
generator._o1igReplacing = new Map([[{}, "replacement.png"]]);
|
||
await queueGeneration(generator);
|
||
assert.deepEqual(queueCalls, []);
|
||
assert.equal(generator._o1igStatus.textContent, "请等待图片上传完成");
|
||
|
||
app.queuePrompt = originalQueuePrompt;
|
||
graph.links.delete(linkId);
|
||
graph.nodes.delete(generator.id);
|
||
graph.nodes.delete(saveNode.id);
|
||
}
|
||
|
||
{
|
||
const raw = "status_code=400, content rejected: the image was flagged as unsafe by the content safety system";
|
||
assert.equal(
|
||
formatImageGenerationError(raw),
|
||
"内容被拒绝：该图像被内容安全系统标记为不安全。",
|
||
);
|
||
assert.equal(
|
||
formatImageGenerationError("status_code=400, Your request was rejected by the safety system"),
|
||
"您的请求已被安全系统拒绝",
|
||
);
|
||
assert.equal(
|
||
formatImageGenerationError("status_code=403, insufficient balance"),
|
||
"上游额度不足！",
|
||
);
|
||
assert.equal(
|
||
formatImageGenerationError("status_code=502, Image generation returned empty response"),
|
||
"图片生成过程中被内容审查机制拒绝！",
|
||
);
|
||
assert.equal(
|
||
formatImageGenerationError("status_code=451, The provided prompt is considered unsafe and it cannot be used to generate content"),
|
||
"提供的提示被认为是不安全的，不能用于生成内容。",
|
||
);
|
||
assert.equal(formatImageGenerationError("其他生成错误"), "其他生成错误");
|
||
}
|
||
|
||
{
|
||
const raw = "The request failed because the output video may be related to copyright restriction";
|
||
const policyRaw = "OutputVideoSensitiveContentDetected.PolicyViolation: The request failed because the output video may be related to copyright restrictions";
|
||
assert.equal(
|
||
formatSeedanceGenerationError(`生成失败，响应：${raw}`),
|
||
"输出视频触发版权审查被拒绝生成！",
|
||
);
|
||
assert.equal(
|
||
formatSeedanceGenerationError(policyRaw),
|
||
"输出视频触发版权审查被拒绝生成！",
|
||
);
|
||
assert.equal(formatSeedanceGenerationError("其他视频错误"), "其他视频错误");
|
||
assert.equal(seedanceErrorNodeTypes.has("SeedanceAutoPass"), true);
|
||
assert.equal(seedanceErrorNodeTypes.has("SeedanceMultiModal"), true);
|
||
assert.equal(seedanceErrorNodeTypes.has("SeedanceAutoPassBatch"), false);
|
||
}
|
||
|
||
{
|
||
const messageElement = new Element("p");
|
||
const messageContainer = {
|
||
querySelector(selector) {
|
||
return selector === "p" ? messageElement : null;
|
||
},
|
||
};
|
||
const overlay = {
|
||
querySelector(selector) {
|
||
return selector === '[data-testid="error-overlay-messages"]'
|
||
? messageContainer
|
||
: null;
|
||
},
|
||
};
|
||
const root = {
|
||
querySelector(selector) {
|
||
return selector === '[data-testid="error-overlay"]' ? overlay : null;
|
||
},
|
||
};
|
||
|
||
assert.equal(updateExecutionErrorOverlay("上游额度不足！", root), true);
|
||
assert.equal(messageElement.textContent, "上游额度不足！");
|
||
assert.equal(updateExecutionErrorOverlay("不会写入", { querySelector: () => null }), false);
|
||
}
|
||
|
||
{
|
||
const requests = [];
|
||
api.fetchApi = (_path, options) => new Promise((resolve) => {
|
||
requests.push({
|
||
path: _path,
|
||
body: options.body,
|
||
resolve,
|
||
});
|
||
});
|
||
const firstFile = new Blob(["first"], { type: "image/jpeg" });
|
||
const secondFile = new Blob(["second"], { type: "image/jpeg" });
|
||
Object.defineProperty(firstFile, "name", { value: "same.jpg" });
|
||
Object.defineProperty(secondFile, "name", { value: "same.jpg" });
|
||
const uploadNode = {
|
||
_o1igReferences: [],
|
||
_o1igPending: [],
|
||
_o1igRefs: new Element("div"),
|
||
_o1igAdd: new Element("button"),
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
widgets: [{ name: "参考图清单", value: "[]" }],
|
||
};
|
||
const uploads = acceptFiles(uploadNode, [firstFile, secondFile]);
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(requests.length, 1);
|
||
assert.equal(requests[0].path, "/upload/image");
|
||
assert.equal(requests[0].body.get("subfolder"), null);
|
||
assert.equal(requests[0].body.get("type"), "input");
|
||
assert.equal(requests[0].body.get("overwrite"), "false");
|
||
requests[0].resolve({
|
||
ok: true,
|
||
json: async () => ({ name: "same.jpg", subfolder: "" }),
|
||
});
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(requests.length, 2);
|
||
assert.equal(requests[1].body.get("subfolder"), null);
|
||
requests[1].resolve({
|
||
ok: true,
|
||
json: async () => ({ name: "same (1).jpg", subfolder: "" }),
|
||
});
|
||
await uploads;
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(uploadNode._o1igReferences)),
|
||
[
|
||
{ name: "same.jpg", subfolder: "", type: "input" },
|
||
{ name: "same (1).jpg", subfolder: "", type: "input" },
|
||
],
|
||
);
|
||
}
|
||
|
||
{
|
||
const previousFetchApi = api.fetchApi;
|
||
api.fetchApi = async (path) => {
|
||
assert.equal(path, "/upload/image");
|
||
return {
|
||
ok: true,
|
||
json: async () => ({ name: "dropped.png", subfolder: "" }),
|
||
};
|
||
};
|
||
const dropTarget = new Element("div");
|
||
const dropNode = {
|
||
_o1igReferences: [],
|
||
_o1igPending: [],
|
||
_o1igRefs: dropTarget,
|
||
_o1igAdd: new Element("button"),
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
widgets: [{ name: "参考图清单", value: "[]" }],
|
||
};
|
||
bindImageFileDropTarget(dropNode, dropTarget);
|
||
|
||
let prevented = 0;
|
||
let stopped = 0;
|
||
dropTarget.dispatch("dragover", {
|
||
dataTransfer: { types: ["text/plain"], files: [] },
|
||
preventDefault() { prevented += 1; },
|
||
stopPropagation() { stopped += 1; },
|
||
});
|
||
assert.equal(prevented, 0);
|
||
assert.equal(stopped, 0);
|
||
assert.equal(dropTarget.classList.contains("drag"), false);
|
||
|
||
const droppedFile = new Blob(["pixels"], { type: "image/png" });
|
||
Object.defineProperty(droppedFile, "name", { value: "dropped.png" });
|
||
const dataTransfer = { types: ["Files"], files: [droppedFile], dropEffect: "none" };
|
||
dropTarget.dispatch("dragover", {
|
||
dataTransfer,
|
||
preventDefault() { prevented += 1; },
|
||
stopPropagation() { stopped += 1; },
|
||
});
|
||
assert.equal(prevented, 1);
|
||
assert.equal(stopped, 1);
|
||
assert.equal(dataTransfer.dropEffect, "copy");
|
||
assert.equal(dropTarget.classList.contains("drag"), true);
|
||
dropTarget.dispatch("drop", {
|
||
dataTransfer,
|
||
preventDefault() { prevented += 1; },
|
||
stopPropagation() { stopped += 1; },
|
||
});
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
await dropNode._o1igReferenceCommit;
|
||
assert.equal(prevented, 2);
|
||
assert.equal(stopped, 2);
|
||
assert.equal(dropTarget.classList.contains("drag"), false);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(dropNode._o1igReferences)),
|
||
[{ name: "dropped.png", subfolder: "", type: "input" }],
|
||
);
|
||
|
||
const nestedUploadTarget = new Element("button");
|
||
dropTarget.append(nestedUploadTarget);
|
||
bindImageFileDropTarget(dropNode, nestedUploadTarget);
|
||
const nestedTransfer = { types: ["Files"], files: [], dropEffect: "none" };
|
||
dropTarget.dispatch("dragover", {
|
||
dataTransfer: nestedTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
nestedUploadTarget.dispatch("dragover", {
|
||
dataTransfer: nestedTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(dropTarget.classList.contains("drag"), true);
|
||
assert.equal(nestedUploadTarget.classList.contains("drag"), true);
|
||
nestedUploadTarget.dispatch("drop", {
|
||
dataTransfer: nestedTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(dropTarget.classList.contains("drag"), false);
|
||
assert.equal(nestedUploadTarget.classList.contains("drag"), false);
|
||
api.fetchApi = previousFetchApi;
|
||
}
|
||
|
||
{
|
||
const target = { id: 910, comfyClass: "O1keyImageGenerator" };
|
||
const cropNode = {
|
||
id: 911,
|
||
title: "快速裁剪",
|
||
imgs: [{ src: "/view?filename=crop-preview.png&type=temp&subfolder=preview" }],
|
||
};
|
||
const saveNode = {
|
||
id: 912,
|
||
comfyClass: "SaveImage",
|
||
_o1igsLastResults: [
|
||
{ filename: "saved.png", subfolder: "session", type: "output" },
|
||
],
|
||
};
|
||
target.graph = { _nodes: [target, cropNode, saveNode] };
|
||
const previousOutputs = app.nodeOutputs;
|
||
app.nodeOutputs = {
|
||
"911": {
|
||
images: [
|
||
{ filename: "cropped.png", subfolder: "", type: "temp" },
|
||
{ filename: "cropped.png", subfolder: "", type: "temp" },
|
||
],
|
||
},
|
||
};
|
||
|
||
const candidates = canvasImageCandidates(target);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(candidates)),
|
||
[
|
||
{
|
||
nodeId: "911",
|
||
sourceLabel: "快速裁剪",
|
||
descriptor: { filename: "cropped.png", subfolder: "", type: "temp" },
|
||
},
|
||
{
|
||
nodeId: "911",
|
||
sourceLabel: "快速裁剪",
|
||
descriptor: { filename: "crop-preview.png", subfolder: "preview", type: "temp" },
|
||
},
|
||
{
|
||
nodeId: "912",
|
||
sourceLabel: "SaveImage",
|
||
descriptor: { filename: "saved.png", subfolder: "session", type: "output" },
|
||
},
|
||
],
|
||
);
|
||
app.nodeOutputs = previousOutputs;
|
||
}
|
||
|
||
{
|
||
const calls = [];
|
||
const previousFetchApi = api.fetchApi;
|
||
api.fetchApi = async (path, options) => {
|
||
calls.push({ path, options });
|
||
if (path.startsWith("/view?")) {
|
||
return {
|
||
ok: true,
|
||
blob: async () => new Blob(["cropped-pixels"], { type: "image/png" }),
|
||
};
|
||
}
|
||
assert.equal(path, "/upload/image");
|
||
return {
|
||
ok: true,
|
||
json: async () => ({ name: "cropped (1).png", subfolder: "" }),
|
||
};
|
||
};
|
||
const target = {
|
||
_o1igReferences: [],
|
||
_o1igPending: [],
|
||
_o1igRefs: new Element("div"),
|
||
_o1igAdd: new Element("button"),
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
widgets: [{ name: "参考图清单", value: "[]" }],
|
||
};
|
||
|
||
await importCanvasImage(target, {
|
||
filename: "cropped.png",
|
||
subfolder: "preview",
|
||
type: "temp",
|
||
});
|
||
|
||
assert.match(calls[0].path, /^\/view\?/);
|
||
assert.match(calls[0].path, /filename=cropped\.png/);
|
||
assert.match(calls[0].path, /subfolder=preview/);
|
||
assert.match(calls[0].path, /type=temp/);
|
||
assert.equal(calls[1].path, "/upload/image");
|
||
assert.equal(calls[1].options.body.get("image").name, "cropped.png");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(target._o1igReferences)),
|
||
[{ name: "cropped (1).png", subfolder: "", type: "input" }],
|
||
);
|
||
api.fetchApi = previousFetchApi;
|
||
}
|
||
|
||
{
|
||
const node = {
|
||
_o1igGenerate: { disabled: true, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
};
|
||
setStatus(node, "", "busy");
|
||
assert.equal(node._o1igGenerate.disabled, false);
|
||
assert.equal(node._o1igGenerate.textContent, "开始生成");
|
||
assert.equal(node._o1igStatus.textContent, "");
|
||
assert.doesNotMatch(node._o1igStatus.className, /visible/);
|
||
}
|
||
|
||
{
|
||
const firstId = "77777777-7777-4777-8777-777777777777";
|
||
const secondId = "88888888-8888-4888-8888-888888888888";
|
||
updateNativeQueueJob({
|
||
batch_id: firstId,
|
||
generator_node_id: 701,
|
||
save_node_id: 702,
|
||
state: "queued",
|
||
});
|
||
updateNativeQueueJob({
|
||
batch_id: secondId,
|
||
generator_node_id: 703,
|
||
save_node_id: 704,
|
||
state: "queued",
|
||
});
|
||
let queue = await api.getQueue();
|
||
assert.equal(queue.Pending.filter((job) => job.id.startsWith("o1key:")).length, 2);
|
||
assert.equal(queue.Pending.some((job) => job.id === "native-pending"), true);
|
||
|
||
updateNativeQueueJob({
|
||
batch_id: firstId,
|
||
generator_node_id: 701,
|
||
save_node_id: 702,
|
||
state: "running",
|
||
});
|
||
queue = await api.getQueue();
|
||
assert.equal(queue.Running.some((job) => job.id === `o1key:${firstId}`), true);
|
||
assert.equal(queue.Pending.some((job) => job.id === `o1key:${secondId}`), true);
|
||
|
||
updateNativeQueueJob({
|
||
batch_id: firstId,
|
||
generator_node_id: 701,
|
||
save_node_id: 702,
|
||
state: "completed",
|
||
images: [{ filename: "queue-result.png", subfolder: "", type: "output" }],
|
||
});
|
||
updateNativeQueueJob({
|
||
batch_id: secondId,
|
||
generator_node_id: 703,
|
||
save_node_id: 704,
|
||
state: "failed",
|
||
error: "test failure",
|
||
});
|
||
const persistedId = "66666666-6666-4666-8666-666666666666";
|
||
const previousFetchApi = api.fetchApi;
|
||
api.fetchApi = async (path) => {
|
||
assert.equal(path, "/o1key/image/jobs/history?limit=64");
|
||
return {
|
||
ok: true,
|
||
json: async () => ({
|
||
items: [{
|
||
batch_id: persistedId,
|
||
generator_node_id: 699,
|
||
save_node_id: 700,
|
||
state: "completed",
|
||
images: [{ filename: "persisted.png", subfolder: "", type: "output" }],
|
||
total_count: 1,
|
||
create_time: 1000,
|
||
execution_start_time: 1100,
|
||
execution_end_time: 1200,
|
||
}],
|
||
}),
|
||
};
|
||
};
|
||
const history = await api.getHistory();
|
||
api.fetchApi = previousFetchApi;
|
||
assert.equal(history.some((job) => job.id === "native-completed"), true);
|
||
assert.equal(history.find((job) => job.id === `o1key:${firstId}`).status, "completed");
|
||
assert.equal(history.find((job) => job.id === `o1key:${secondId}`).status, "failed");
|
||
assert.equal(history.find((job) => job.id === `o1key:${persistedId}`).preview_output.filename, "persisted.png");
|
||
assert.equal(history.find((job) => job.id === `o1key:${persistedId}`).execution_end_time, 1200);
|
||
const detail = await api.getJobDetail(`o1key:${firstId}`);
|
||
assert.equal(detail.outputs["702"].images[0].filename, "queue-result.png");
|
||
assert.equal(statusEvents.some((item) => item?.o1key_virtual_queue_update), true);
|
||
let deletedHistoryBatch = null;
|
||
api.fetchApi = async (path, options) => {
|
||
assert.equal(path, "/o1key/image/jobs/history");
|
||
assert.equal(options.method, "POST");
|
||
deletedHistoryBatch = JSON.parse(options.body).batch_id;
|
||
return { ok: true, json: async () => ({ ok: true }) };
|
||
};
|
||
await api.deleteItem("history", `o1key:${persistedId}`);
|
||
api.fetchApi = previousFetchApi;
|
||
assert.equal(deletedHistoryBatch, persistedId);
|
||
assert.equal((await api.getHistory()).some((job) => job.id === `o1key:${persistedId}`), false);
|
||
|
||
const countId = "99999999-9999-4999-8999-999999999999";
|
||
const queueItem = new Element("div");
|
||
queueItem.querySelector = (selector) => queueItem.children.find(
|
||
(child) => selector.includes(child.dataset?.o1keyQueueCount),
|
||
) || null;
|
||
const queueRow = new Element("div");
|
||
queueRow.append(queueItem);
|
||
document.querySelectorAll = (selector) => selector.includes(`o1key:${countId}`) ? [queueRow] : [];
|
||
updateNativeQueueJob({
|
||
batch_id: countId,
|
||
generator_node_id: 705,
|
||
save_node_id: 706,
|
||
state: "queued",
|
||
total_count: 9,
|
||
});
|
||
syncNativeQueueCounts();
|
||
const countBadge = queueItem.children.find((child) => child.dataset?.o1keyQueueCount === `o1key:${countId}`);
|
||
assert.equal(countBadge.tagName, "BUTTON");
|
||
assert.match(countBadge.className, /\bbg-secondary-background\b/);
|
||
assert.match(countBadge.className, /\bh-8\b/);
|
||
assert.match(countBadge.className, /\brounded-lg\b/);
|
||
assert.match(countBadge.className, /\bgap-2\b/);
|
||
assert.match(countBadge.className, /\bfont-medium\b/);
|
||
assert.equal(countBadge.children[0].className, "icon-[lucide--layers] size-4");
|
||
assert.equal(countBadge.children[1].textContent, "9");
|
||
assert.equal(countBadge.title, "批次共 9 张");
|
||
delete document.querySelectorAll;
|
||
}
|
||
|
||
{
|
||
const calls = [];
|
||
let resolveRequest;
|
||
api.fetchApi = async (path, options) => {
|
||
calls.push({ path, body: JSON.parse(options.body) });
|
||
return new Promise((resolve) => {
|
||
resolveRequest = () => resolve({
|
||
ok: true,
|
||
status: 200,
|
||
async json() { return { prompt: "优化后的视觉提示词" }; },
|
||
});
|
||
});
|
||
};
|
||
const prompt = new Element("textarea");
|
||
prompt.value = "让参考图人物站在雨夜街头";
|
||
const optimizeButton = new Element("button");
|
||
const optimizeStatus = new Element("div");
|
||
const generateButton = new Element("button");
|
||
const node = {
|
||
widgets: [{ name: "prompt", value: prompt.value }],
|
||
_o1igPrompt: prompt,
|
||
_o1igPromptOptimize: optimizeButton,
|
||
_o1igPromptOptimizeStatus: optimizeStatus,
|
||
_o1igGenerate: generateButton,
|
||
_o1igStatus: new Element("div"),
|
||
_o1igPanel: new Element("div"),
|
||
_o1igReferences: [
|
||
{ name: "person.png", subfolder: "o1key_uploads/test", type: "input" },
|
||
],
|
||
_o1igPending: [],
|
||
_o1igMaskPending: false,
|
||
_o1igRunning: false,
|
||
};
|
||
|
||
const optimization = optimizePrompt(node);
|
||
await Promise.resolve();
|
||
assert.equal(optimizeStatus.textContent, "AI帮写中…");
|
||
assert.match(optimizeStatus.className, /visible busy/);
|
||
assert.equal(node._o1igStatus.textContent, "");
|
||
resolveRequest();
|
||
await optimization;
|
||
assert.equal(calls.length, 1);
|
||
assert.equal(calls[0].path, "/o1key/image/prompt-optimize");
|
||
assert.equal(calls[0].body.prompt, "让参考图人物站在雨夜街头");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(calls[0].body.references)),
|
||
[{ name: "person.png", subfolder: "o1key_uploads/test", type: "input" }],
|
||
);
|
||
assert.equal(prompt.value, "优化后的视觉提示词");
|
||
assert.equal(node.widgets[0].value, "优化后的视觉提示词");
|
||
assert.equal(prompt.readOnly, false);
|
||
assert.equal(optimizeButton.disabled, false);
|
||
assert.equal(optimizeButton.classList.contains("busy"), false);
|
||
assert.equal(optimizeStatus.textContent, "AI帮写完成");
|
||
assert.match(optimizeStatus.className, /visible ok/);
|
||
assert.equal(node._o1igStatus.textContent, "");
|
||
}
|
||
|
||
{
|
||
const dropdown = makeDropdown(["1K", "2K"], "1K", "分辨率");
|
||
const trigger = dropdown.children[0];
|
||
const selectedDescription = trigger.children[1];
|
||
const caret = trigger.children[trigger.children.length - 1];
|
||
const caretIcon = caret.children[0];
|
||
const caretPath = caretIcon.children[0];
|
||
assert.equal(caret.tagName, "SPAN");
|
||
assert.equal(caretIcon.tagName, "SVG");
|
||
assert.equal(caretIcon.viewBox, "0 0 12 12");
|
||
assert.equal(caretPath.d, "M2.25 4.25 6 8l3.75-3.75");
|
||
assert.equal(caretPath["stroke-linecap"], "round");
|
||
assert.equal(selectedDescription.textContent, "");
|
||
assert.equal(caret.textContent, "");
|
||
}
|
||
|
||
{
|
||
const dropdown = makeDropdown(modelOptions, "Nano Banana 2", "模型");
|
||
const descriptions = [...dropdown._o1igMenu.children].map((button) => ({
|
||
model: button.children[0].textContent,
|
||
description: button.children[1].textContent,
|
||
styled: button.classList.contains("has-description"),
|
||
}));
|
||
assert.deepEqual(JSON.parse(JSON.stringify(descriptions)), [
|
||
{ model: "Nano Banana 2", description: "快速，批量", styled: true },
|
||
{ model: "Nano Banana Pro", description: "高质量资产", styled: true },
|
||
{ model: "GPT Image 2", description: "高质量，编辑", styled: true },
|
||
{ model: "GPT Image 2.5 Sunburst", description: "最新，高质量", styled: true },
|
||
{ model: "GPT Image 2.5 Flare", description: "快速，日常", styled: true },
|
||
{ model: "Seedream 5.0 Pro", description: "高质量，参考图，分层", styled: true },
|
||
{ model: "Nano Banana 2 Lite", description: "快速，草稿", styled: true },
|
||
{ model: "Nano Banana", description: "快速，草稿", styled: true },
|
||
]);
|
||
assert.equal(dropdown._o1igValueLabel.textContent, "Nano Banana 2");
|
||
assert.equal(dropdown._o1igValueDescription.textContent, "快速，批量");
|
||
assert.equal(dropdown._o1igTrigger.title, "Nano Banana 2 · 快速，批量");
|
||
}
|
||
|
||
{
|
||
assert.doesNotThrow(() => validateSeedreamReferenceDimensions(15, 15, "reference.png"));
|
||
assert.doesNotThrow(() => validateSeedreamReferenceDimensions(240, 15, "reference.png"));
|
||
assert.throws(
|
||
() => validateSeedreamReferenceDimensions(14, 240, "reference.png"),
|
||
/宽和高都必须大于 14px/,
|
||
);
|
||
assert.throws(
|
||
() => validateSeedreamReferenceDimensions(241, 15, "reference.png"),
|
||
/宽高比必须在 1:16～16:1/,
|
||
);
|
||
assert.throws(
|
||
() => validateSeedreamReferenceDimensions(6001, 6000, "reference.png"),
|
||
/总像素不能超过/,
|
||
);
|
||
assert.throws(
|
||
() => validateSeedreamReferenceDimensions(
|
||
511,
|
||
512,
|
||
"layers.png",
|
||
{ layerDecomposition: true },
|
||
),
|
||
/总像素必须在 512×512/,
|
||
);
|
||
|
||
let bitmapClosed = false;
|
||
context.createImageBitmap = async () => ({
|
||
width: 14,
|
||
height: 240,
|
||
close() { bitmapClosed = true; },
|
||
});
|
||
await assert.rejects(
|
||
() => validateSeedreamReferenceFile(
|
||
{
|
||
_o1igModel: { value: "Seedream 5.0 Pro" },
|
||
_o1igLayerDecomposition: { value: "关闭" },
|
||
},
|
||
new File(["image"], "tiny.png", { type: "image/png" }),
|
||
),
|
||
/宽和高都必须大于 14px/,
|
||
);
|
||
assert.equal(bitmapClosed, true);
|
||
await assert.rejects(
|
||
() => validateSeedreamReferenceFile(
|
||
{
|
||
_o1igModel: { value: "Seedream 5.0 Pro" },
|
||
_o1igLayerDecomposition: { value: "关闭" },
|
||
},
|
||
{ name: "large.png", size: 30 * 1024 * 1024 + 1 },
|
||
),
|
||
/文件不能超过 30MB/,
|
||
);
|
||
}
|
||
|
||
{
|
||
const dropdown = makeDropdown(routeOptions, "直连", "模型线路");
|
||
assert.equal(dropdown.value, "直连");
|
||
assert.equal(dropdown._o1igValueLabel.textContent, "优质");
|
||
assert.equal(dropdown._o1igValueDescription.textContent, "小贵");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(dropdown._o1igOptions)),
|
||
[
|
||
{ value: "畅速", label: "特价", description: "便宜" },
|
||
{ value: "直连", label: "优质", description: "小贵" },
|
||
{ value: "专线", label: "企业", description: "贵" },
|
||
],
|
||
);
|
||
}
|
||
|
||
{
|
||
const widgets = [
|
||
{ name: "模型", value: "Nano Banana 2" },
|
||
{ name: "分辨率", value: "512" },
|
||
{ name: "宽高比", value: "智能" },
|
||
{ name: "输出格式", value: "jpeg" },
|
||
{ name: "背景", value: "auto" },
|
||
{ name: "在线搜索", value: "关闭" },
|
||
{ name: "命名规则", value: "自定义前缀" },
|
||
{ name: "filename_prefix", value: "catalog" },
|
||
{ name: "格式", value: "webp" },
|
||
{ name: "保存位置", value: "project/session" },
|
||
{ name: "图层拆分", value: false },
|
||
{ name: "生图数量", value: "1" },
|
||
];
|
||
const node = {
|
||
widgets,
|
||
_o1igModel: { value: "Nano Banana 2" },
|
||
_o1igResolution: makeDropdown(["512", "1K", "2K", "4K"], "512"),
|
||
_o1igRatio: makeDropdown(["智能", "1:1"], "智能"),
|
||
_o1igRatioField: { style: {} },
|
||
_o1igCount: makeDropdown(["1", "2", "4", "9"], "1"),
|
||
_o1igCountField: { style: {} },
|
||
_o1igThinkingField: { style: {} },
|
||
_o1igOnlineSearch: makeDropdown(["关闭", "打开"], "关闭"),
|
||
_o1igOnlineSearchField: { style: {} },
|
||
_o1igLayerDecomposition: makeDropdown(["关闭", "开启"], "关闭"),
|
||
_o1igLayerDecompositionField: { style: {} },
|
||
_o1igQuality: makeDropdown(["高", "中", "低", "自动"], "自动"),
|
||
_o1igQualityField: { style: {} },
|
||
_o1igOutputFormat: makeDropdown([
|
||
{ value: "png", label: "PNG" },
|
||
{ value: "webp", label: "WebP" },
|
||
{ value: "jpeg", label: "JPEG" },
|
||
], "jpeg"),
|
||
_o1igOutputFormatField: { style: {} },
|
||
_o1igBackground: makeDropdown([
|
||
{ value: "auto", label: "自动" },
|
||
{ value: "transparent", label: "透明" },
|
||
{ value: "opaque", label: "不透明" },
|
||
], "auto"),
|
||
_o1igBackgroundField: { style: {} },
|
||
_o1igResize: { value: "智能缩放" },
|
||
_o1igResizeField: { style: {} },
|
||
_o1igResizeWarning: new Element("div"),
|
||
_o1igMaskField: { style: {} },
|
||
_o1igNamingRule: makeDropdown([
|
||
{ value: "自定义前缀", label: "自定义" },
|
||
{ value: "自然数字", label: "自然数字" },
|
||
], "自定义前缀"),
|
||
_o1igFilenamePrefix: { value: "catalog" },
|
||
_o1igFilenamePrefixField: { style: {} },
|
||
_o1igSaveFormat: makeDropdown(["原始", "png", "jpg", "webp"], "webp"),
|
||
_o1igSaveFormatField: { style: {} },
|
||
_o1igSaveLocation: { value: "project/session" },
|
||
_o1igBatchBar: { style: {} },
|
||
_o1igBatchEnabled: false,
|
||
};
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K", "2K", "4K"],
|
||
);
|
||
assert.equal(node._o1igResolution.value, "智能");
|
||
assert.equal(node._o1igThinkingField.style.display, "");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "");
|
||
assert.equal(node._o1igQualityField.style.display, "none");
|
||
assert.equal(node._o1igOutputFormatField.style.display, "none");
|
||
assert.equal(node._o1igBackgroundField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
assert.equal(node._o1igFilenamePrefixField.style.display, "");
|
||
assert.equal(node._o1igSaveFormatField.style.display, "");
|
||
assert.equal(node._o1igResizeWarning.classList.contains("visible"), true);
|
||
|
||
node._o1igModel.value = "Nano Banana 2 Lite";
|
||
syncModelOptions(node);
|
||
assert.equal(node._o1igResolution._o1igOptions.some((option) => option.value === "512"), true);
|
||
assert.equal(node._o1igThinkingField.style.display, "none");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "none");
|
||
assert.equal(node._o1igQualityField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
|
||
node._o1igModel.value = "Nano Banana Pro";
|
||
syncModelOptions(node);
|
||
assert.equal(node._o1igResolution._o1igOptions.some((option) => option.value === "512"), false);
|
||
assert.equal(node._o1igRatio._o1igOptions.some((option) => option.value === "1:8"), false);
|
||
assert.equal(node._o1igThinkingField.style.display, "none");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "none");
|
||
assert.equal(node._o1igQualityField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
|
||
node._o1igModel.value = "Nano Banana";
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K"],
|
||
);
|
||
assert.equal(node._o1igThinkingField.style.display, "none");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "none");
|
||
assert.equal(node._o1igQualityField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
|
||
node._o1igModel.value = "gpt-image-2";
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K", "2K", "4K"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igRatio._o1igOptions.map((option) => option.value))),
|
||
["智能", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16"],
|
||
);
|
||
assert.equal(node._o1igRatioField.style.display, "");
|
||
assert.equal(node._o1igThinkingField.style.display, "none");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "none");
|
||
assert.equal(node._o1igQualityField.style.display, "");
|
||
assert.equal(node._o1igOutputFormatField.style.display, "");
|
||
assert.equal(node._o1igBackgroundField.style.display, "");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "");
|
||
assert.equal(node._o1igSaveFormatField.style.display, "none");
|
||
assert.equal(node._o1igResizeWarning.classList.contains("visible"), true);
|
||
assert.equal(node._o1igQuality.value, "自动");
|
||
assert.equal(node._o1igOutputFormat.value, "jpeg");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igCount._o1igOptions.map((option) => option.value))),
|
||
["1", "2", "3", "4", "5", "6", "7", "8"],
|
||
);
|
||
node._o1igCount.value = "3";
|
||
syncModelOptions(node);
|
||
assert.equal(widgets.find((widget) => widget.name === "生图数量").value, "3");
|
||
assert.deepEqual(JSON.parse(JSON.stringify(generatorSaveSettings(node))), {
|
||
filename_prefix: "catalog",
|
||
format: "原始",
|
||
save_location: "project/session",
|
||
naming_rule: "自定义前缀",
|
||
});
|
||
for (const model of ["gpt-image-2.5-sunburst", "gpt-image-2.5-flare"]) {
|
||
node._o1igModel.value = model;
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K", "2K", "4K"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igRatio._o1igOptions.map((option) => option.value))),
|
||
["智能", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16"],
|
||
);
|
||
assert.equal(node._o1igQualityField.style.display, "");
|
||
assert.equal(node._o1igOutputFormatField.style.display, "");
|
||
assert.equal(node._o1igBackgroundField.style.display, "");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igQuality._o1igOptions.map((option) => option.value))),
|
||
["高", "中", "低", "自动", "超高", "最高"],
|
||
);
|
||
assert.equal(node._o1igMaskField.style.display, "");
|
||
}
|
||
node._o1igQuality.value = "最高";
|
||
node._o1igModel.value = "gpt-image-2";
|
||
syncModelOptions(node);
|
||
assert.equal(node._o1igQuality.value, "自动");
|
||
node._o1igApplyGptDefaults = true;
|
||
node._o1igOutputTouched = false;
|
||
node._o1igResizeTouched = false;
|
||
syncModelOptions(node);
|
||
assert.equal(node._o1igOutputFormat.value, "png");
|
||
assert.equal(node._o1igResize.value, "智能缩放");
|
||
node._o1igBackground.value = "transparent";
|
||
syncGptOutputOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igOutputFormat._o1igOptions.map((option) => option.value))),
|
||
["png", "webp"],
|
||
);
|
||
assert.equal(node._o1igOutputFormat.value, "png");
|
||
assert.equal(widgets.find((widget) => widget.name === "背景").value, "transparent");
|
||
|
||
node._o1igModel.value = "Seedream 5.0 Pro";
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K", "2K"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igRatio._o1igOptions.map((option) => option.value))),
|
||
["智能", "1:1", "4:3", "3:4", "16:9", "9:16", "3:2", "2:3", "21:9"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igOutputFormat._o1igOptions.map((option) => option.value))),
|
||
["png", "jpeg"],
|
||
);
|
||
assert.equal(node._o1igOutputFormatField.style.display, "");
|
||
assert.equal(node._o1igBackgroundField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "none");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
assert.equal(node._o1igSaveFormatField.style.display, "none");
|
||
assert.deepEqual(JSON.parse(JSON.stringify(generatorSaveSettings(node))), {
|
||
filename_prefix: "catalog",
|
||
format: "原始",
|
||
save_location: "project/session",
|
||
naming_rule: "自定义前缀",
|
||
});
|
||
assert.equal(node._o1igLayerDecompositionField.style.display, "");
|
||
node._o1igLayerDecomposition.value = "开启";
|
||
syncModelOptions(node);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(node._o1igResolution._o1igOptions.map((option) => option.value))),
|
||
["智能", "1K", "1.5K", "2K"],
|
||
);
|
||
assert.equal(node._o1igRatioField.style.display, "none");
|
||
assert.equal(node._o1igCountField.style.display, "none");
|
||
assert.equal(node._o1igOutputFormatField.style.display, "none");
|
||
assert.equal(node._o1igBatchBar.style.display, "none");
|
||
assert.equal(node._o1igOutputFormat.value, "png");
|
||
assert.equal(widgets.find((widget) => widget.name === "图层拆分").value, true);
|
||
|
||
node._o1igModel.value = "Nano Banana 2";
|
||
syncModelOptions(node);
|
||
assert.equal(node._o1igThinkingField.style.display, "");
|
||
assert.equal(node._o1igOnlineSearchField.style.display, "");
|
||
assert.equal(node._o1igQualityField.style.display, "none");
|
||
assert.equal(node._o1igOutputFormatField.style.display, "none");
|
||
assert.equal(node._o1igBackgroundField.style.display, "none");
|
||
assert.equal(node._o1igResizeField.style.display, "");
|
||
assert.equal(node._o1igMaskField.style.display, "none");
|
||
assert.equal(node._o1igResize.value, "智能缩放");
|
||
assert.equal(node._o1igResizeWarning.classList.contains("visible"), true);
|
||
}
|
||
|
||
{
|
||
const node = {
|
||
size: [320, 200],
|
||
setSize(size) { this.size = size; },
|
||
setDirtyCanvas() {},
|
||
};
|
||
applyGeneratorDefaultSize(node);
|
||
assert.deepEqual(JSON.parse(JSON.stringify(node.size)), [560, 1035]);
|
||
node.size = [520, 420];
|
||
applyGeneratorDefaultSize(node);
|
||
assert.deepEqual(node.size, [520, 420]);
|
||
}
|
||
|
||
{
|
||
const outputs = [
|
||
{ name: "IMAGE", links: [] },
|
||
{ name: "LAYERS", links: [] },
|
||
{ name: "LAYER_MASKS", links: [] },
|
||
{ name: "LAYER_INFO", links: [] },
|
||
];
|
||
const node = {
|
||
outputs,
|
||
_o1igModel: { value: "Nano Banana 2" },
|
||
_o1igLayerDecomposition: { value: "关闭" },
|
||
setDirtyCanvas() {},
|
||
};
|
||
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.deepEqual(node.outputs.map((output) => output.name), ["IMAGE"]);
|
||
|
||
const restoredImageOutput = { name: "IMAGE", links: [41] };
|
||
node.outputs = [restoredImageOutput];
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.equal(node.outputs[0], restoredImageOutput);
|
||
|
||
node._o1igModel.value = "Seedream 5.0 Pro";
|
||
node._o1igLayerDecomposition.value = "开启";
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.equal(node.outputs[0], restoredImageOutput);
|
||
assert.deepEqual(node.outputs.map((output) => output.name), [
|
||
"IMAGE", "LAYERS", "LAYER_MASKS",
|
||
]);
|
||
|
||
outputs[3].links.push(98);
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.deepEqual(node.outputs.map((output) => output.name), [
|
||
"IMAGE", "LAYERS", "LAYER_MASKS", "LAYER_INFO",
|
||
]);
|
||
outputs[3].links.length = 0;
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.equal(node.outputs.length, 3);
|
||
|
||
node._o1igLayerDecomposition.value = "关闭";
|
||
outputs[1].links.push(99);
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.deepEqual(node.outputs.map((output) => output.name), ["IMAGE", "LAYERS"]);
|
||
|
||
outputs[1].links.length = 0;
|
||
syncGeneratorOutputVisibility(node);
|
||
assert.deepEqual(node.outputs.map((output) => output.name), ["IMAGE"]);
|
||
}
|
||
|
||
{
|
||
const generator = {
|
||
id: 10100,
|
||
type: "O1keyImageGenerator",
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
pos: [30, 40],
|
||
size: [500, 1025],
|
||
outputs: [
|
||
{ name: "IMAGE", links: [] },
|
||
{ name: "LAYERS", links: [] },
|
||
{ name: "LAYER_MASKS", links: [] },
|
||
{ name: "LAYER_INFO", links: [] },
|
||
],
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
connect(originSlot, target) {
|
||
const linkId = nextLinkId++;
|
||
graph.links.set(linkId, {
|
||
origin_id: this.id,
|
||
origin_slot: originSlot,
|
||
target_id: target.id,
|
||
target_slot: 0,
|
||
});
|
||
this.outputs[originSlot].links.push(linkId);
|
||
target.inputs[0].link = linkId;
|
||
},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
|
||
const batchId = "12121212-1212-4212-8212-121212121212";
|
||
const imageSaveNode = createSaveNodeForBatch(generator, batchId, 0);
|
||
const layerSaveNode = acquireLayerSaveNodeForBatch(generator, imageSaveNode);
|
||
assert.equal(generator.outputs[0].links.length, 1);
|
||
assert.equal(generator.outputs[1].links.length, 1);
|
||
assert.notEqual(imageSaveNode.id, layerSaveNode.id);
|
||
assert.equal(layerSaveNode.title, "o1key 保存图层");
|
||
assert.equal(layerSaveNode.properties.o1keySaveRole, "layers");
|
||
assert.equal(layerSaveNode.properties.o1keyImageSaveNodeId, imageSaveNode.id);
|
||
assert.equal(acquireLayerSaveNodeForBatch(generator, imageSaveNode), layerSaveNode);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(splitLayerSaveResults([
|
||
{ filename: "base.png", type: "output", layer: { z_index: 0, name: "底图" } },
|
||
{ filename: "subject.png", type: "output", layer: { z_index: 1, name: "主体" } },
|
||
{ filename: "text.png", type: "output", layer: { z_index: 2, name: "文字" } },
|
||
]))),
|
||
{
|
||
imageResults: [
|
||
{ filename: "base.png", subfolder: "", type: "output", layer: { z_index: 0, name: "底图" } },
|
||
],
|
||
layerResults: [
|
||
{ filename: "subject.png", subfolder: "", type: "output", layer: { z_index: 1, name: "主体" } },
|
||
{ filename: "text.png", subfolder: "", type: "output", layer: { z_index: 2, name: "文字" } },
|
||
],
|
||
},
|
||
);
|
||
|
||
let imageMessage = null;
|
||
let layerMessage = null;
|
||
imageSaveNode.onExecuted = (message) => {
|
||
imageMessage = message;
|
||
finishGenerationBatch(imageSaveNode, "生成完成", batchId);
|
||
};
|
||
layerSaveNode.onExecuted = (message) => {
|
||
layerMessage = message;
|
||
finishGenerationBatch(layerSaveNode, "生成完成", batchId);
|
||
};
|
||
beginGenerationBatch(generator, imageSaveNode, batchId);
|
||
context.testLayerGenerator = generator;
|
||
context.testImageSaveNode = imageSaveNode;
|
||
context.testLayerSaveNode = layerSaveNode;
|
||
vm.runInContext(
|
||
`parallelBatches.set("${batchId}", {
|
||
source: testLayerGenerator,
|
||
saveNode: testImageSaveNode,
|
||
generatorNodeId: testLayerGenerator.id,
|
||
saveNodeId: testImageSaveNode.id,
|
||
layerSaveNode: testLayerSaveNode,
|
||
layerSaveNodeId: testLayerSaveNode.id,
|
||
layerDecomposition: true
|
||
})`,
|
||
context,
|
||
);
|
||
handleParallelImageJob({
|
||
batch_id: batchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: imageSaveNode.id,
|
||
state: "completed",
|
||
images: [
|
||
{ batch_id: batchId, filename: "base.png", type: "output", result_index: 1 },
|
||
{ batch_id: batchId, filename: "subject.png", type: "output", result_index: 2 },
|
||
{ batch_id: batchId, filename: "text.png", type: "output", result_index: 3 },
|
||
],
|
||
});
|
||
assert.deepEqual(imageMessage.images.map((item) => item.filename), ["base.png"]);
|
||
assert.deepEqual(layerMessage.images.map((item) => item.filename), ["subject.png", "text.png"]);
|
||
assert.deepEqual(
|
||
executedEvents.slice(-2).map((event) => event.display_node),
|
||
[layerSaveNode.id, imageSaveNode.id],
|
||
);
|
||
}
|
||
|
||
{
|
||
const generator = {
|
||
id: 100,
|
||
graph,
|
||
pos: [20, 30],
|
||
size: [410, 340],
|
||
outputs: [{ links: [] }],
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
connect(_originSlot, target) {
|
||
const linkId = nextLinkId++;
|
||
graph.links.set(linkId, { origin_id: this.id, target_id: target.id });
|
||
this.outputs[0].links.push(linkId);
|
||
target.inputs[0].link = linkId;
|
||
},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
|
||
const firstBatchId = "11111111-1111-4111-8111-111111111111";
|
||
const secondBatchId = "22222222-2222-4222-8222-222222222222";
|
||
const first = createSaveNodeForBatch(generator, firstBatchId);
|
||
const second = createSaveNodeForBatch(generator, secondBatchId);
|
||
assert.notEqual(first, second);
|
||
assert.deepEqual(first.widgets, []);
|
||
assert.equal(generator.outputs[0].links.length, 2);
|
||
assert.equal(first.properties.o1keyBatchIndex, 1);
|
||
assert.equal(second.properties.o1keyBatchIndex, 2);
|
||
assert.notDeepEqual(first.pos, second.pos);
|
||
|
||
beginGenerationBatch(generator, first);
|
||
beginGenerationBatch(generator, second);
|
||
assert.equal(generator._o1igPendingBatchIds.size, 2);
|
||
assert.equal(generator._o1igGenerate.disabled, false);
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
assert.equal(generator._o1igGenerate.textContent, "开始生成");
|
||
|
||
finishGenerationBatch(first, "生成完成");
|
||
assert.equal(generator._o1igPendingBatchIds.size, 1);
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
|
||
finishGenerationBatch(second, "生成完成");
|
||
assert.equal(generator._o1igPendingBatchIds.size, 0);
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
assert.equal(generator._o1igGenerate.textContent, "开始生成");
|
||
|
||
let received = null;
|
||
let receivedCount = 0;
|
||
second.onExecuted = (message) => {
|
||
received = message;
|
||
receivedCount += 1;
|
||
finishGenerationBatch(second, "生成完成");
|
||
};
|
||
beginGenerationBatch(generator, second);
|
||
const progressBody = new Element("div");
|
||
progressBody.querySelector = () => progressBody.children.find(
|
||
(child) => child.dataset.o1keySaveProgress === String(second.id),
|
||
) || null;
|
||
const progressContainer = new Element("div");
|
||
progressContainer.querySelector = () => progressBody;
|
||
document._querySelector = (selector) => selector.includes(`data-node-id="${second.id}"`)
|
||
? progressContainer
|
||
: null;
|
||
context.testGenerator = generator;
|
||
context.testSaveNode = second;
|
||
vm.runInContext(
|
||
`parallelBatches.set("${secondBatchId}", { source: testGenerator, saveNode: testSaveNode })`,
|
||
context,
|
||
);
|
||
handleParallelImageJob({
|
||
batch_id: secondBatchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: second.id,
|
||
state: "running",
|
||
progress: 0.37,
|
||
images: [],
|
||
});
|
||
const progressTrack = progressBody.children[0];
|
||
assert.equal(progressBody.classList.contains("o1igs-progress-host"), true);
|
||
assert.equal(progressContainer.classList.contains("o1key-image-save-node"), true);
|
||
assert.equal(progressTrack.style["--o1igs-progress"], "37%");
|
||
assert.equal(progressTrack.classList.contains("busy"), true);
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
assert.equal(generator._o1igGenerate.textContent, "开始生成");
|
||
handleParallelImageJob({
|
||
batch_id: secondBatchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: second.id,
|
||
state: "queued",
|
||
queue_position: 2,
|
||
progress: 0,
|
||
});
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
|
||
handleParallelImageJob({
|
||
batch_id: secondBatchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: first.id,
|
||
state: "completed",
|
||
images: [{ batch_id: secondBatchId, filename: "wrong.png", type: "output" }],
|
||
});
|
||
assert.equal(received, null);
|
||
|
||
handleParallelImageJob({
|
||
batch_id: secondBatchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: second.id,
|
||
state: "completed",
|
||
images: [
|
||
{ batch_id: firstBatchId, filename: "wrong-batch.png", type: "output" },
|
||
{ batch_id: secondBatchId, filename: "correct.png", type: "output" },
|
||
],
|
||
});
|
||
assert.equal(received.images.length, 1);
|
||
assert.equal(received.images[0].filename, "correct.png");
|
||
assert.equal(executedEvents.at(-1).display_node, second.id);
|
||
assert.equal(executedEvents.at(-1).output.images[0].filename, "correct.png");
|
||
assert.equal(app.nodeOutputs[String(second.id)].images[0].filename, "correct.png");
|
||
const nativeHistory = await api.getHistory();
|
||
const nativeCompleted = nativeHistory.find((job) => job.id === `o1key:${secondBatchId}`);
|
||
assert.equal(nativeCompleted.status, "completed");
|
||
assert.equal(nativeCompleted.preview_output.filename, "correct.png");
|
||
handleParallelImageJob({
|
||
batch_id: secondBatchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: second.id,
|
||
state: "completed",
|
||
images: [{ batch_id: secondBatchId, filename: "duplicate.png", type: "output" }],
|
||
});
|
||
assert.equal(receivedCount, 1);
|
||
document._querySelector = null;
|
||
}
|
||
|
||
{
|
||
const batchId = "66666666-6666-4666-8666-666666666666";
|
||
const oldNodes = createRecoveryNodes(batchId, 9100, 9101);
|
||
let staleExecutions = 0;
|
||
oldNodes.saveNode.onExecuted = () => { staleExecutions += 1; };
|
||
beginGenerationBatch(oldNodes.generator, oldNodes.saveNode);
|
||
context.testDetachedGenerator = oldNodes.generator;
|
||
context.testDetachedSaveNode = oldNodes.saveNode;
|
||
vm.runInContext(
|
||
`parallelBatches.set("${batchId}", {
|
||
source: testDetachedGenerator,
|
||
saveNode: testDetachedSaveNode,
|
||
generatorNodeId: 9100,
|
||
saveNodeId: 9101
|
||
})`,
|
||
context,
|
||
);
|
||
|
||
detachParallelBatchNode(oldNodes.generator);
|
||
detachParallelBatchNode(oldNodes.saveNode);
|
||
graph.nodes.delete(oldNodes.generator.id);
|
||
graph.nodes.delete(oldNodes.saveNode.id);
|
||
graph.links.delete(oldNodes.linkId);
|
||
const previousFetchApi = api.fetchApi;
|
||
let saveRequests = 0;
|
||
api.fetchApi = async (path) => {
|
||
assert.equal(path, "/o1key/image/save");
|
||
saveRequests += 1;
|
||
return {
|
||
ok: true,
|
||
status: 200,
|
||
json: async () => ({
|
||
images: [{ batch_id: batchId, filename: "while-away.png", type: "output" }],
|
||
}),
|
||
};
|
||
};
|
||
handleParallelImageJob({
|
||
batch_id: batchId,
|
||
generator_node_id: 9100,
|
||
save_node_id: 9101,
|
||
state: "completed",
|
||
images: [{ batch_id: batchId, filename: `${batchId}_0001_01.png`, type: "temp" }],
|
||
});
|
||
assert.equal(staleExecutions, 0);
|
||
assert.equal(saveRequests, 0);
|
||
assert.equal(
|
||
vm.runInContext(`parallelBatches.get("${batchId}").lastDetail.state`, context),
|
||
"completed",
|
||
);
|
||
|
||
const activeNodes = createRecoveryNodes(batchId, 9100, 9101);
|
||
let restored = null;
|
||
activeNodes.saveNode.onExecuted = (message) => {
|
||
restored = message;
|
||
finishGenerationBatch(activeNodes.saveNode, "生成完成");
|
||
};
|
||
await recoverParallelBatch(activeNodes.saveNode);
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(saveRequests, 1);
|
||
assert.equal(restored.images[0].filename, "while-away.png");
|
||
assert.equal(staleExecutions, 0);
|
||
assert.equal(vm.runInContext(`parallelBatches.has("${batchId}")`, context), false);
|
||
graph.nodes.delete(activeNodes.generator.id);
|
||
graph.nodes.delete(activeNodes.saveNode.id);
|
||
graph.links.delete(activeNodes.linkId);
|
||
api.fetchApi = previousFetchApi;
|
||
}
|
||
|
||
{
|
||
const batchId = "77777777-7777-4777-8777-777777777777";
|
||
const activeNodes = createRecoveryNodes(batchId, 9200, 9201);
|
||
let restored = null;
|
||
activeNodes.saveNode.onExecuted = (message) => {
|
||
restored = message;
|
||
finishGenerationBatch(activeNodes.saveNode, "生成完成");
|
||
};
|
||
const previousFetchApi = api.fetchApi;
|
||
let statusRequest = "";
|
||
api.fetchApi = async (path) => {
|
||
statusRequest = path;
|
||
return {
|
||
ok: true,
|
||
status: 200,
|
||
json: async () => ({
|
||
batch_id: batchId,
|
||
generator_node_id: 9200,
|
||
save_node_id: 9201,
|
||
state: "completed",
|
||
images: [{ batch_id: batchId, filename: "after-refresh.png", type: "output" }],
|
||
}),
|
||
};
|
||
};
|
||
vm.runInContext(`parallelBatches.delete("${batchId}")`, context);
|
||
await recoverParallelBatch(activeNodes.saveNode);
|
||
assert.match(statusRequest, new RegExp(`/o1key/image/jobs/${batchId}\\?`));
|
||
assert.match(statusRequest, /generator_node_id=9200/);
|
||
assert.match(statusRequest, /save_node_id=9201/);
|
||
assert.equal(restored.images[0].filename, "after-refresh.png");
|
||
assert.equal(activeNodes.saveNode._o1igsBusy, false);
|
||
api.fetchApi = previousFetchApi;
|
||
graph.nodes.delete(activeNodes.generator.id);
|
||
graph.nodes.delete(activeNodes.saveNode.id);
|
||
graph.links.delete(activeNodes.linkId);
|
||
}
|
||
|
||
{
|
||
const batchId = "44444444-4444-4444-8444-444444444444";
|
||
const generator = {
|
||
id: 145,
|
||
graph,
|
||
pos: [0, 0],
|
||
size: [400, 300],
|
||
outputs: [{ links: [] }],
|
||
_o1igGenerate: new Element("button"),
|
||
_o1igStatus: new Element("div"),
|
||
_o1igPanel: new Element("div"),
|
||
connect(_originSlot, target) {
|
||
const linkId = nextLinkId++;
|
||
graph.links.set(linkId, { origin_id: this.id, target_id: target.id });
|
||
this.outputs[0].links.push(linkId);
|
||
target.inputs[0].link = linkId;
|
||
},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
const saveNode = createSaveNodeForBatch(generator, batchId);
|
||
beginGenerationBatch(generator, saveNode);
|
||
context.testCancelGenerator = generator;
|
||
context.testCancelSaveNode = saveNode;
|
||
vm.runInContext(
|
||
`parallelBatches.set("${batchId}", { source: testCancelGenerator, saveNode: testCancelSaveNode })`,
|
||
context,
|
||
);
|
||
updateNativeQueueJob({
|
||
batch_id: batchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: saveNode.id,
|
||
state: "queued",
|
||
});
|
||
const queued = await api.getQueue();
|
||
assert.equal(queued.Pending.some((job) => job.id === `o1key:${batchId}`), true);
|
||
api.fetchApi = async (path, options) => {
|
||
assert.equal(path, `/o1key/image/jobs/${batchId}/cancel`);
|
||
assert.equal(options.method, "POST");
|
||
return {
|
||
ok: true,
|
||
json: async () => ({
|
||
batch_id: batchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: saveNode.id,
|
||
state: "cancelled",
|
||
error: "任务已取消",
|
||
}),
|
||
};
|
||
};
|
||
await api.cancelJob(`o1key:${batchId}`);
|
||
assert.equal(generator._o1igPendingBatchIds.size, 0);
|
||
assert.equal(generator._o1igStatus.textContent, "");
|
||
assert.equal(generator._o1igGenerate.textContent, "开始生成");
|
||
const afterCancel = await api.getQueue();
|
||
assert.equal(afterCancel.Pending.some((job) => job.id === `o1key:${batchId}`), false);
|
||
const cancelledHistory = await api.getHistory();
|
||
assert.equal(
|
||
cancelledHistory.find((job) => job.id === `o1key:${batchId}`).status,
|
||
"cancelled",
|
||
);
|
||
}
|
||
|
||
{
|
||
const generator = {
|
||
id: 120,
|
||
type: "O1keyImageGenerator",
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
pos: [0, 0],
|
||
size: [400, 300],
|
||
outputs: [{ links: [] }],
|
||
connect(_originSlot, target) {
|
||
const linkId = nextLinkId++;
|
||
graph.links.set(linkId, { origin_id: this.id, target_id: target.id });
|
||
this.outputs[0].links.push(linkId);
|
||
target.inputs[0].link = linkId;
|
||
},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
|
||
const filled = createSaveNodeForBatch(generator, "filled-batch");
|
||
filled.properties.o1keyImageSaveResults = [
|
||
{ filename: "filled.png", subfolder: "", type: "output" },
|
||
];
|
||
const blank = createSaveNodeForBatch(generator, "old-empty-batch");
|
||
const reused = acquireSaveNodeForBatch(generator, "new-batch");
|
||
assert.equal(reused, blank);
|
||
assert.equal(reused.properties.o1keyBatchId, "new-batch");
|
||
assert.equal(generator.outputs[0].links.length, 2);
|
||
|
||
const rerouted = reroutePartialExecutionTargets([filled.id, 987654]);
|
||
assert.deepEqual(JSON.parse(JSON.stringify(rerouted)), [blank.id, 987654]);
|
||
assert.equal(generator._o1igsRequestedStandardSaveNodeId, blank.id);
|
||
assert.equal(
|
||
prepareStandardQueue(generator, { isPartialExecution: true }),
|
||
blank,
|
||
);
|
||
const routes = takeStandardQueueRoutes();
|
||
const promptResult = {
|
||
output: {
|
||
[generator.id]: { class_type: "O1keyImageGenerator" },
|
||
[filled.id]: { class_type: "O1keyImageSave" },
|
||
[blank.id]: { class_type: "O1keyImageSave" },
|
||
987652: {
|
||
class_type: "FilledBranchOutput",
|
||
inputs: { image: [filled.id, 0] },
|
||
},
|
||
987653: {
|
||
class_type: "BlankBranchOutput",
|
||
inputs: { image: [blank.id, 0] },
|
||
},
|
||
987654: { class_type: "OtherOutput" },
|
||
},
|
||
};
|
||
filterStandardQueueOutputs(promptResult, routes);
|
||
assert.equal(promptResult.output[filled.id], undefined);
|
||
assert.equal(promptResult.output[987652], undefined);
|
||
assert.equal(promptResult.output[blank.id].class_type, "O1keyImageSave");
|
||
assert.equal(promptResult.output[987653].class_type, "BlankBranchOutput");
|
||
assert.equal(promptResult.output[987654].class_type, "OtherOutput");
|
||
assert.equal(startNextStandardExecution(generator), blank);
|
||
assert.equal(blank._o1igsBusy, true);
|
||
assert.equal(blank._o1igsStandardExecutionPending, true);
|
||
assert.notEqual(filled._o1igsBusy, true);
|
||
finishGenerationBatch(blank, "生成完成");
|
||
assert.equal(blank._o1igsBusy, false);
|
||
assert.equal(blank._o1igsStandardExecutionPending, undefined);
|
||
finishStandardQueue(generator);
|
||
|
||
blank.properties.o1keyImageSaveResults = [
|
||
{ filename: "now-filled.jpg", subfolder: "", type: "output" },
|
||
];
|
||
const downstreamLinkId = nextLinkId++;
|
||
const downstream = {
|
||
id: 121,
|
||
type: "OtherOutput",
|
||
graph,
|
||
inputs: [{ link: downstreamLinkId }],
|
||
};
|
||
graph.nodes.set(downstream.id, downstream);
|
||
graph.links.set(downstreamLinkId, {
|
||
origin_id: blank.id,
|
||
target_id: downstream.id,
|
||
});
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(reroutePartialExecutionTargets([downstream.id]))),
|
||
[downstream.id],
|
||
);
|
||
assert.equal(generator._o1igsRequestedStandardSaveNodeId, blank.id);
|
||
assert.equal(prepareStandardQueue(generator, { isPartialExecution: true }), blank);
|
||
assert.equal(startNextStandardExecution(generator), blank);
|
||
finishGenerationBatch(blank, "生成完成");
|
||
finishStandardQueue(generator);
|
||
|
||
const created = prepareStandardQueue(generator, { isPartialExecution: false });
|
||
assert.notEqual(created, filled);
|
||
assert.notEqual(created, blank);
|
||
assert.equal(generator.outputs[0].links.length, 3);
|
||
assert.deepEqual(created.widgets, []);
|
||
finishStandardQueue(generator);
|
||
}
|
||
|
||
{
|
||
const generator = {
|
||
id: 140,
|
||
type: "O1keyImageGenerator",
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
pos: [0, 0],
|
||
size: [400, 300],
|
||
outputs: [{ links: [] }],
|
||
_o1igGenerate: { disabled: false, textContent: "" },
|
||
_o1igStatus: { className: "", textContent: "" },
|
||
_o1igPanel: { classList: new ClassList({}) },
|
||
widgets: [
|
||
{ name: "模型", value: "Nano Banana 2" },
|
||
{ name: "filename_prefix", value: "catalog" },
|
||
{ name: "格式", value: "webp" },
|
||
{ name: "保存位置", value: "D:/renders/session-a" },
|
||
{ name: "命名规则", value: "自定义前缀" },
|
||
],
|
||
connect(_originSlot, target) {
|
||
const linkId = nextLinkId++;
|
||
graph.links.set(linkId, { origin_id: this.id, target_id: target.id });
|
||
this.outputs[0].links.push(linkId);
|
||
target.inputs[0].link = linkId;
|
||
},
|
||
};
|
||
graph.nodes.set(generator.id, generator);
|
||
const batchId = "33333333-3333-4333-8333-333333333333";
|
||
const saveNode = createSaveNodeForBatch(generator, batchId);
|
||
let received = null;
|
||
saveNode.onExecuted = (message) => {
|
||
received = message;
|
||
finishGenerationBatch(saveNode, "生成完成");
|
||
};
|
||
beginGenerationBatch(generator, saveNode);
|
||
context.testTempGenerator = generator;
|
||
context.testTempSaveNode = saveNode;
|
||
vm.runInContext(
|
||
`parallelBatches.set("${batchId}", { source: testTempGenerator, saveNode: testTempSaveNode })`,
|
||
context,
|
||
);
|
||
let saveRequest = null;
|
||
let fallbackSerializeCalls = 0;
|
||
app.graphToPrompt = async () => ({
|
||
output: { 140: { class_type: "O1keyImageGenerator" } },
|
||
workflow: { nodes: [{ id: 140 }, { id: saveNode.id }] },
|
||
});
|
||
graph.serialize = () => {
|
||
fallbackSerializeCalls += 1;
|
||
return { nodes: [{ id: "stale-fallback" }] };
|
||
};
|
||
api.fetchApi = async (path, options) => {
|
||
assert.equal(path, "/o1key/image/save");
|
||
saveRequest = JSON.parse(options.body);
|
||
return {
|
||
ok: true,
|
||
json: async () => ({
|
||
images: [{ filename: "provider.jpg", type: "temp", external_saved: true }],
|
||
}),
|
||
};
|
||
};
|
||
handleParallelImageJob({
|
||
batch_id: batchId,
|
||
generator_node_id: generator.id,
|
||
save_node_id: saveNode.id,
|
||
state: "completed",
|
||
images: [{ batch_id: batchId, filename: `${batchId}.jpg`, type: "temp" }],
|
||
});
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(saveRequest.filename_prefix, "catalog");
|
||
assert.equal(saveRequest.format, "webp");
|
||
assert.equal(saveRequest.save_location, "D:/renders/session-a");
|
||
assert.equal(saveRequest.naming_rule, "自定义前缀");
|
||
assert.equal(saveRequest.extra_pnginfo.workflow.nodes.length, 2);
|
||
assert.equal(saveRequest.prompt[140].class_type, "O1keyImageGenerator");
|
||
assert.equal(fallbackSerializeCalls, 0);
|
||
assert.equal(received.images[0].filename, "provider.jpg");
|
||
assert.equal(received.images[0].type, "temp");
|
||
assert.equal(received.images[0].external_saved, true);
|
||
}
|
||
|
||
{
|
||
createdElements.length = 0;
|
||
const saveNode = {
|
||
id: 776,
|
||
graph,
|
||
properties: {},
|
||
size: [300, 260],
|
||
widgets: [],
|
||
addDOMWidget() { throw new Error("save preview must not reserve DOM widget layout space"); },
|
||
setSize(size) { this.size = size; },
|
||
setDirtyCanvas() {},
|
||
};
|
||
buildSavePanel(saveNode);
|
||
assert.equal(saveNode._o1igsPanelReady, true);
|
||
assert.equal(saveNode._o1igsProgressTrack, undefined);
|
||
assert.deepEqual(saveNode.widgets, []);
|
||
|
||
saveNode.imgs = [{ src: "native-preview" }];
|
||
saveNode.imageIndex = 0;
|
||
renderSaveResults(saveNode, [
|
||
{ filename: "one.png", type: "output" },
|
||
{ filename: "two.png", type: "output" },
|
||
{ filename: "three.png", type: "output" },
|
||
{ filename: "four.png", type: "output" },
|
||
]);
|
||
assert.equal(createdElements.filter((element) => element.tagName === "IMG").length, 0);
|
||
assert.deepEqual(saveNode.imgs, [{ src: "native-preview" }]);
|
||
assert.equal(saveNode.imageIndex, 0);
|
||
assert.equal(saveNode.properties.o1keyImageSaveResults.length, 4);
|
||
assert.equal(saveNode.properties.o1keyImageSaveResults[1].filename, "two.png");
|
||
}
|
||
|
||
{
|
||
createdElements.length = 0;
|
||
const slotContainer = new Element("div");
|
||
const saveNode = {
|
||
id: 780,
|
||
comfyClass: "O1keyImageSave",
|
||
graph,
|
||
properties: {},
|
||
size: [300, 260],
|
||
inputs: [{ link: 7800 }],
|
||
widgets: [],
|
||
addDOMWidget(_name, _type, element, options) {
|
||
this.slotWidgetOptions = options;
|
||
const owner = this;
|
||
const widget = {
|
||
options,
|
||
onRemove() { owner.slotWidgetRemoveCount = (owner.slotWidgetRemoveCount || 0) + 1; },
|
||
};
|
||
this.widgets.push(widget);
|
||
return widget;
|
||
},
|
||
removeWidget(widget) {
|
||
const index = this.widgets.indexOf(widget);
|
||
assert.notEqual(index, -1);
|
||
widget.onRemove?.();
|
||
this.widgets.splice(index, 1);
|
||
},
|
||
setSize(size) { this.size = size; },
|
||
setDirtyCanvas() {},
|
||
};
|
||
const sourceNode = {
|
||
id: 781,
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
widgets: [{ name: "seed", value: 0 }],
|
||
_o1igSeed: { value: "0" },
|
||
_o1igPrompt: { value: "甲\n---\n乙" },
|
||
};
|
||
graph.nodes.set(saveNode.id, saveNode);
|
||
graph.nodes.set(sourceNode.id, sourceNode);
|
||
graph.links.set(7800, { origin_id: sourceNode.id, target_id: saveNode.id });
|
||
document._querySelector = (selector) => selector.includes('data-node-id="780"')
|
||
? slotContainer
|
||
: null;
|
||
|
||
const prompts = expandPanelPromptTasks("甲\n---\n乙", 2);
|
||
assert.deepEqual(JSON.parse(JSON.stringify(prompts)), ["甲", "甲", "乙", "乙"]);
|
||
const outfits = Array.from({ length: 10 }, (_, index) => ({ name: `outfit-${index}.png` }));
|
||
const models = Array.from({ length: 10 }, (_, index) => ({ name: `model-${index}.png` }));
|
||
const groupedTasks = expandPanelGenerationTasks({
|
||
prompt: "换装",
|
||
imageCount: 1,
|
||
batchEnabled: true,
|
||
batchMode: "一组搭配+多模特",
|
||
references: outfits.slice(0, 3),
|
||
modelReferences: models,
|
||
});
|
||
assert.equal(groupedTasks.length, 10);
|
||
assert.equal(groupedTasks[0].references.length, 4);
|
||
assert.equal(groupedTasks[9].references[3].name, "model-9.png");
|
||
const cartesianTasks = expandPanelGenerationTasks({
|
||
prompt: "换装",
|
||
imageCount: 1,
|
||
batchEnabled: true,
|
||
batchMode: "全部搭配×全部模特",
|
||
references: outfits,
|
||
modelReferences: models,
|
||
});
|
||
assert.equal(cartesianTasks.length, 100);
|
||
assert.equal(cartesianTasks[0].references[0].name, "outfit-0.png");
|
||
assert.equal(cartesianTasks[9].references[1].name, "model-9.png");
|
||
assert.equal(cartesianTasks[10].references[0].name, "outfit-1.png");
|
||
const singleReferenceTasks = expandPanelGenerationTasks({
|
||
prompt: "换个动作",
|
||
imageCount: 1,
|
||
batchEnabled: true,
|
||
batchMode: "单图素材批量",
|
||
references: outfits.slice(0, 3),
|
||
modelReferences: models,
|
||
});
|
||
assert.equal(singleReferenceTasks.length, 3);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(singleReferenceTasks.map((task) => task.references.map((item) => item.name)))),
|
||
[["outfit-0.png"], ["outfit-1.png"], ["outfit-2.png"]],
|
||
);
|
||
|
||
const groupedBadgeNode = {
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "一组搭配+多模特" },
|
||
_o1igReferences: outfits.slice(0, 3),
|
||
};
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(referenceBadgeDetails(groupedBadgeNode, "references", 1))),
|
||
{ label: "图2", title: "素材图2 · 在各自请求中是图2" },
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(referenceBadgeDetails(groupedBadgeNode, "models", 7))),
|
||
{ label: "图4", title: "目标图8 · 在各自请求中是图4" },
|
||
);
|
||
const cartesianBadgeNode = {
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "全部搭配×全部模特" },
|
||
_o1igReferences: outfits,
|
||
};
|
||
assert.equal(referenceBadgeDetails(cartesianBadgeNode, "references", 6).label, "图1");
|
||
assert.equal(referenceBadgeDetails(cartesianBadgeNode, "models", 6).label, "图2");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(referenceBadgeDetails({
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "单图素材批量" },
|
||
}, "references", 1))),
|
||
{ label: "图1", title: "素材图2 · 作为单张参考图独立生成" },
|
||
);
|
||
assert.equal(referenceBadgeDetails({ _o1igBatchEnabled: false }, "references", 2).label, "图3");
|
||
assert.equal(
|
||
referenceBadgeDetails({ _o1igBatchEnabled: false }, "references", 0).title,
|
||
"图1 · 主图/色彩基准（按当前顺序）",
|
||
);
|
||
|
||
assert.equal(referenceDropDestination(0, 2, false), 1);
|
||
assert.equal(referenceDropDestination(0, 2, true), 2);
|
||
assert.equal(referenceDropDestination(2, 0, false), 0);
|
||
|
||
const sortableReferences = [
|
||
{ name: "first.png", subfolder: "", type: "input" },
|
||
{ name: "second.png", subfolder: "", type: "input" },
|
||
{ name: "third.png", subfolder: "", type: "input" },
|
||
];
|
||
const sortableWidget = { name: "参考图清单", value: JSON.stringify(sortableReferences) };
|
||
const sortableNode = {
|
||
_o1igRefs: new Element("div"),
|
||
_o1igAdd: new Element("button"),
|
||
_o1igReferences: sortableReferences,
|
||
_o1igPending: [],
|
||
widgets: [sortableWidget],
|
||
};
|
||
assert.equal(moveReference(sortableNode, "references", 0, 2), true);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(sortableNode._o1igReferences.map((item) => item.name))),
|
||
["second.png", "third.png", "first.png"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(sortableWidget.value).map((item) => item.name),
|
||
["second.png", "third.png", "first.png"],
|
||
);
|
||
const firstSortTarget = sortableNode._o1igReferenceHandles.references[0];
|
||
const firstSortTile = sortableNode._o1igRefs.children[0];
|
||
assert.equal(firstSortTarget.className, "o1ig-previewable");
|
||
assert.equal(firstSortTile.draggable, true);
|
||
assert.equal(firstSortTile.listeners.has("dragstart"), true);
|
||
assert.equal(firstSortTile.listeners.has("drop"), true);
|
||
firstSortTarget.dispatch("keydown", {
|
||
key: "End",
|
||
altKey: true,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(sortableNode._o1igReferences.map((item) => item.name))),
|
||
["third.png", "first.png", "second.png"],
|
||
);
|
||
|
||
const dragTile = sortableNode._o1igRefs.children[0];
|
||
const dropTile = sortableNode._o1igRefs.children[2];
|
||
dropTile.getBoundingClientRect = () => ({ left: 0, width: 100 });
|
||
const dataTransfer = { setData() {} };
|
||
dragTile.dispatch("dragstart", {
|
||
dataTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(dragTile.classList.contains("o1ig-dragging"), true);
|
||
assert.equal(sortableNode._o1igRefs.classList.contains("o1ig-reordering"), true);
|
||
dragTile.children[0].dispatch("click", {
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(document.getElementById("o1key-image-reference-lightbox"), null);
|
||
dropTile.dispatch("dragover", {
|
||
clientX: 90,
|
||
dataTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(dropTile.classList.contains("o1ig-drop-after"), true);
|
||
dropTile.dispatch("drop", {
|
||
clientX: 90,
|
||
dataTransfer,
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(sortableNode._o1igReferences.map((item) => item.name))),
|
||
["first.png", "second.png", "third.png"],
|
||
);
|
||
|
||
sortableNode._o1igPending.push({ name: "uploading.png", url: "blob:uploading" });
|
||
renderReferenceRole(sortableNode, "references");
|
||
assert.equal(sortableNode._o1igRefs.children[0].draggable, false);
|
||
assert.equal(sortableNode._o1igRefs.children[0].classList.contains("sort-locked"), true);
|
||
assert.equal(moveReference(sortableNode, "references", 0, 1), false);
|
||
|
||
const independentNode = {
|
||
_o1igReferences: [{ name: "source.png", subfolder: "", type: "input" }],
|
||
_o1igPending: [],
|
||
_o1igModelReferences: [
|
||
{ name: "target-a.png", subfolder: "", type: "input" },
|
||
{ name: "target-b.png", subfolder: "", type: "input" },
|
||
],
|
||
_o1igModelPending: [],
|
||
widgets: [
|
||
{ name: "参考图清单", value: "[]" },
|
||
{ name: "模特图清单", value: "[]" },
|
||
],
|
||
};
|
||
assert.equal(moveReference(independentNode, "models", 0, 1), true);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(independentNode._o1igReferences.map((item) => item.name))),
|
||
["source.png"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(independentNode._o1igModelReferences.map((item) => item.name))),
|
||
["target-b.png", "target-a.png"],
|
||
);
|
||
|
||
const referenceList = new Element("div");
|
||
const addReference = new Element("button");
|
||
renderReferenceRole({
|
||
_o1igRefs: referenceList,
|
||
_o1igAdd: addReference,
|
||
_o1igReferences: [
|
||
{ name: "large.png", subfolder: "product", type: "input" },
|
||
{ name: "second.png", subfolder: "product", type: "input" },
|
||
],
|
||
_o1igPending: [],
|
||
});
|
||
assert.equal(referenceList.children.length, 3);
|
||
const trailingUpload = referenceList.children[2];
|
||
assert.equal(trailingUpload.className, "o1ig-empty-reference");
|
||
assert.equal(trailingUpload.children[1].textContent, "添加参考图");
|
||
assert.equal(trailingUpload.listeners.has("drop"), true);
|
||
const uploadedImage = referenceList.children[0].children[0];
|
||
const editButton = referenceList.children[0].children[1];
|
||
assert.equal(editButton.className, "o1ig-edit");
|
||
assert.equal(editButton.title, "编辑图片");
|
||
assert.equal(editButton["aria-label"], "编辑参考图1");
|
||
assert.equal(uploadedImage["aria-label"], "查看大图；按住拖动可排序");
|
||
assert.equal(
|
||
uploadedImage.src,
|
||
"/o1key/image/thumbnail?filename=large.png&type=input&subfolder=product",
|
||
);
|
||
assert.equal(uploadedImage.loading, "lazy");
|
||
assert.equal(uploadedImage.decoding, "async");
|
||
uploadedImage.dispatch("click");
|
||
const lightbox = document.getElementById("o1key-image-reference-lightbox");
|
||
assert.equal(lightbox["aria-hidden"], "false");
|
||
assert.equal(lightbox._o1igImage.src, "/view?filename=large.png&type=input&subfolder=product");
|
||
assert.equal(lightbox._o1igPrevious.hidden, false);
|
||
lightbox.dispatch("keydown", {
|
||
key: "ArrowRight",
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(lightbox._o1igImage.src, "/view?filename=second.png&type=input&subfolder=product");
|
||
lightbox.dispatch("keydown", {
|
||
key: "Escape",
|
||
preventDefault() {},
|
||
stopPropagation() {},
|
||
});
|
||
assert.equal(lightbox["aria-hidden"], "true");
|
||
createdElements.length = 0;
|
||
|
||
const editableReferences = [{ name: "portrait.jpg", subfolder: "people", type: "input" }];
|
||
const editableWidget = { name: "参考图清单", value: JSON.stringify(editableReferences) };
|
||
const editableNode = {
|
||
_o1igRefs: new Element("div"),
|
||
_o1igAdd: new Element("button"),
|
||
_o1igReferences: editableReferences,
|
||
_o1igPending: [],
|
||
widgets: [editableWidget],
|
||
};
|
||
editorRequests.length = 0;
|
||
await editReference(editableNode, "references", 0);
|
||
assert.equal(editorRequests.length, 1);
|
||
assert.equal(editorRequests[0].sourceUrl, "/view?filename=portrait.jpg&type=input&subfolder=people");
|
||
assert.equal(editorRequests[0].filename, "portrait.jpg");
|
||
const previousEditorFetch = api.fetchApi;
|
||
api.fetchApi = async (path, options) => {
|
||
assert.equal(path, "/upload/image");
|
||
assert.equal(options.method, "POST");
|
||
return {
|
||
ok: true,
|
||
json: async () => ({ name: "portrait_edited.png", subfolder: "", type: "input" }),
|
||
};
|
||
};
|
||
await editorRequests[0].onConfirm({
|
||
blob: new Blob(["edited"], { type: "image/png" }),
|
||
filename: "portrait_edited.png",
|
||
});
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(editableNode._o1igReferences)),
|
||
[{ name: "portrait_edited.png", subfolder: "", type: "input" }],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(editableWidget.value),
|
||
JSON.parse(JSON.stringify(editableNode._o1igReferences)),
|
||
);
|
||
api.fetchApi = previousEditorFetch;
|
||
createdElements.length = 0;
|
||
|
||
const replacementReferences = [
|
||
{ name: "first.png", subfolder: "", type: "input" },
|
||
{ name: "middle.png", subfolder: "", type: "input" },
|
||
{ name: "last.png", subfolder: "", type: "input" },
|
||
];
|
||
const replacementWidget = { name: "参考图清单", value: JSON.stringify(replacementReferences) };
|
||
const replacementInput = new Element("input");
|
||
let pickerClicks = 0;
|
||
replacementInput.click = () => { pickerClicks += 1; };
|
||
const replacementNode = {
|
||
_o1igRefs: new Element("div"),
|
||
_o1igAdd: new Element("button"),
|
||
_o1igReplaceInput: replacementInput,
|
||
_o1igReferences: replacementReferences,
|
||
_o1igPending: [],
|
||
widgets: [replacementWidget],
|
||
};
|
||
renderReferenceRole(replacementNode, "references");
|
||
const replaceButton = replacementNode._o1igRefs.children[1].children.find(
|
||
(child) => child.className === "o1ig-replace",
|
||
);
|
||
assert.equal(replaceButton.textContent, "替换");
|
||
assert.equal(replaceButton["aria-label"], "替换参考图2");
|
||
replaceButton.dispatch("click", { preventDefault() {}, stopPropagation() {} });
|
||
assert.equal(pickerClicks, 1);
|
||
assert.equal(replacementNode._o1igReplaceTarget.original, replacementReferences[1]);
|
||
|
||
let finishUpload;
|
||
api.fetchApi = (_path, options) => new Promise((resolve) => {
|
||
assert.equal(_path, "/upload/image");
|
||
assert.equal(options.body.get("overwrite"), "false");
|
||
finishUpload = resolve;
|
||
});
|
||
const replacementFile = new File(["new image"], "replacement.png", { type: "image/png" });
|
||
const replacing = replaceReference(replacementNode, "references", replacementReferences[1], replacementFile);
|
||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||
assert.equal(replacementNode._o1igReplacing.size, 1);
|
||
assert.deepEqual(replacementReferences.map((item) => item.name), ["first.png", "middle.png", "last.png"]);
|
||
assert.equal(replacementNode._o1igRefs.children[1].className.includes("replacing"), true);
|
||
finishUpload({ ok: true, json: async () => ({ name: "replacement.png", subfolder: "" }) });
|
||
assert.equal(await replacing, true);
|
||
assert.deepEqual(replacementReferences.map((item) => item.name), ["first.png", "replacement.png", "last.png"]);
|
||
assert.deepEqual(JSON.parse(replacementWidget.value).map((item) => item.name), ["first.png", "replacement.png", "last.png"]);
|
||
|
||
api.fetchApi = async () => ({ ok: false });
|
||
const failedFile = new File(["broken"], "broken.png", { type: "image/png" });
|
||
assert.equal(await replaceReference(replacementNode, "references", replacementReferences[1], failedFile), false);
|
||
assert.deepEqual(replacementReferences.map((item) => item.name), ["first.png", "replacement.png", "last.png"]);
|
||
const targetImages = [
|
||
{ name: "target-a.png", subfolder: "", type: "input" },
|
||
{ name: "target-b.png", subfolder: "", type: "input" },
|
||
];
|
||
const targetWidget = { name: "模特图清单", value: JSON.stringify(targetImages) };
|
||
const targetNode = {
|
||
_o1igReferences: replacementReferences,
|
||
_o1igModelReferences: targetImages,
|
||
_o1igModelRefs: new Element("div"),
|
||
_o1igModelAdd: new Element("button"),
|
||
_o1igModelPending: [],
|
||
widgets: [targetWidget],
|
||
};
|
||
api.fetchApi = async () => ({
|
||
ok: true,
|
||
json: async () => ({ name: "new-target.png", subfolder: "" }),
|
||
});
|
||
assert.equal(await replaceReference(
|
||
targetNode, "models", targetImages[0],
|
||
new File(["target"], "new-target.png", { type: "image/png" }),
|
||
), true);
|
||
assert.deepEqual(targetImages.map((item) => item.name), ["new-target.png", "target-b.png"]);
|
||
assert.deepEqual(replacementReferences.map((item) => item.name), ["first.png", "replacement.png", "last.png"]);
|
||
assert.deepEqual(JSON.parse(targetWidget.value).map((item) => item.name), ["new-target.png", "target-b.png"]);
|
||
api.fetchApi = previousEditorFetch;
|
||
|
||
const emptyReferenceList = new Element("div");
|
||
renderReferenceRole({
|
||
_o1igRefs: emptyReferenceList,
|
||
_o1igAdd: new Element("button"),
|
||
_o1igReferences: [],
|
||
_o1igPending: [],
|
||
});
|
||
assert.equal(emptyReferenceList.children.length, 1);
|
||
assert.equal(emptyReferenceList.children[0].className, "o1ig-empty-reference");
|
||
assert.equal(emptyReferenceList.children[0].children[1].textContent, "添加参考图");
|
||
|
||
const summaryNode = {
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "一组搭配+多模特" },
|
||
_o1igReferences: [],
|
||
_o1igModelReferences: [],
|
||
_o1igCount: { value: "2" },
|
||
_o1igPrompt: { value: "甲\n---\n乙" },
|
||
_o1igBatchSummary: new Element("div"),
|
||
_o1igReferenceHint: new Element("span"),
|
||
};
|
||
updateBatchSummary(summaryNode);
|
||
assert.equal(summaryNode._o1igBatchSummary.textContent, "");
|
||
assert.equal(summaryNode._o1igBatchSummary.classList.contains("visible"), false);
|
||
summaryNode._o1igModelReferences = models.slice(0, 2);
|
||
updateBatchSummary(summaryNode);
|
||
assert.equal(summaryNode._o1igBatchSummary.classList.contains("visible"), false);
|
||
summaryNode._o1igReferences = outfits.slice(0, 3);
|
||
updateBatchSummary(summaryNode);
|
||
assert.equal(summaryNode._o1igBatchSummary.classList.contains("visible"), true);
|
||
assert.equal(
|
||
summaryNode._o1igBatchSummary.textContent,
|
||
"1 组素材 × 2 个目标 = 2 个组合 × 每组 2 张 × 2 条提示词，共 8 张",
|
||
);
|
||
summaryNode._o1igBatchMode.value = "全部搭配×全部模特";
|
||
updateBatchSummary(summaryNode);
|
||
assert.equal(
|
||
summaryNode._o1igBatchSummary.textContent,
|
||
"3 个素材 × 2 个目标 = 6 个组合 × 每组 2 张 × 2 条提示词，共 24 张",
|
||
);
|
||
summaryNode._o1igBatchMode.value = "单图素材批量";
|
||
updateBatchSummary(summaryNode);
|
||
assert.equal(
|
||
summaryNode._o1igBatchSummary.textContent,
|
||
"3 张素材（每张独立） × 每组 2 张 × 2 条提示词，共 12 张",
|
||
);
|
||
const hintNode = {
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "一组搭配+多模特" },
|
||
_o1igReferences: outfits.slice(0, 3),
|
||
_o1igModelReferences: models.slice(0, 2),
|
||
_o1igReferenceTitle: new Element("strong"),
|
||
_o1igReferenceHint: new Element("span"),
|
||
_o1igModelHint: new Element("span"),
|
||
};
|
||
updateBatchReferenceHint(hintNode);
|
||
assert.equal(hintNode._o1igReferenceTitle.textContent, "素材图");
|
||
assert.equal(hintNode._o1igReferenceHint.textContent, "3 张 · 整组参与");
|
||
assert.equal(hintNode._o1igModelHint.textContent, "2 张 · 每张目标图单独参与组合");
|
||
hintNode._o1igBatchMode.value = "全部搭配×全部模特";
|
||
updateBatchReferenceHint(hintNode);
|
||
assert.equal(hintNode._o1igReferenceHint.textContent, "3 张 · 匹配时每张独立");
|
||
hintNode._o1igBatchMode.value = "单图素材批量";
|
||
updateBatchReferenceHint(hintNode);
|
||
assert.equal(hintNode._o1igReferenceHint.textContent, "3 张 · 每张独立生成");
|
||
hintNode._o1igBatchEnabled = false;
|
||
updateBatchReferenceHint(hintNode);
|
||
assert.equal(hintNode._o1igReferenceTitle.textContent, "参考图");
|
||
assert.equal(hintNode._o1igReferenceHint.textContent, "3 张 · 最多 10 张");
|
||
initializeSaveSlots(saveNode, prompts.map((prompt, index) => ({
|
||
prompt,
|
||
references: [{
|
||
name: `pair-${index + 1}.png`,
|
||
subfolder: "batch",
|
||
type: "input",
|
||
url: "https://signed.invalid/secret",
|
||
}],
|
||
})));
|
||
assert.equal(saveNode._o1igsSlotsElement.children.length, 4);
|
||
assert.equal(saveNode.properties.o1keyImageSlots.length, 4);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(saveNode.properties.o1keyImageSlots[1].references)),
|
||
[{ name: "pair-2.png", subfolder: "batch", type: "input" }],
|
||
);
|
||
assert.equal(saveNode._o1igsSlotsWidget.computeSize(300)[1] > 0, true);
|
||
|
||
updateSaveSlotsForState(saveNode, { state: "running" });
|
||
assert.equal(saveNode._o1igsSlots.every((slot) => slot.state === "running"), true);
|
||
applyPartialSaveSlots(saveNode, [
|
||
{ filename: "third-preview.png", type: "temp", request_index: 3, result_index: 1 },
|
||
]);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(saveNode._o1igsSlots.map((slot) => slot.state))),
|
||
["running", "running", "success", "running"],
|
||
);
|
||
assert.equal(saveNode._o1igsSlots[2].image.filename, "third-preview.png");
|
||
assert.equal(saveNode._o1igsSlotsElement.children[2].children[1].tagName, "IMG");
|
||
createdElements.length = 0;
|
||
const completeImages = applyCompletedSaveSlots(saveNode, {
|
||
total_count: 4,
|
||
failed_items: [
|
||
{ request_index: 2, error: "第二张失败" },
|
||
{ request_index: 4, error: "第四张失败" },
|
||
],
|
||
}, [
|
||
{ filename: "first.png", type: "output", request_index: 1 },
|
||
{ filename: "third.png", type: "output", request_index: 3 },
|
||
]);
|
||
assert.equal(completeImages.length, 2);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(saveNode._o1igsSlots.map((slot) => slot.state))),
|
||
["success", "failed", "success", "failed"],
|
||
);
|
||
assert.equal(saveNode._o1igsSlotsElement.children.length, 4);
|
||
assert.equal(createdElements.filter((element) => element.tagName === "IMG").length, 2);
|
||
assert.equal(storedSaveSlots(saveNode)[1].error, "第二张失败");
|
||
assert.equal(slotContainer.classList.contains("o1key-slots-visible"), true);
|
||
|
||
context.retryCalls = [];
|
||
vm.runInContext(
|
||
"queueGeneration = async (node, imageCount, options) => retryCalls.push({ node, imageCount, options })",
|
||
context,
|
||
);
|
||
await retryFailedSaveSlot(saveNode, 2);
|
||
assert.equal(context.retryCalls.length, 1);
|
||
assert.equal(context.retryCalls[0].node, sourceNode);
|
||
assert.equal(context.retryCalls[0].imageCount, 1);
|
||
assert.equal(context.retryCalls[0].options.targetSaveNode, saveNode);
|
||
assert.equal(context.retryCalls[0].options.retrySlotIndex, 2);
|
||
assert.equal(context.retryCalls[0].options.promptOverride, "甲");
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(context.retryCalls[0].options.referenceOverride)),
|
||
[{ name: "pair-2.png", subfolder: "batch", type: "input" }],
|
||
);
|
||
|
||
context.retryCalls = [];
|
||
saveNode._o1igsBusy = true;
|
||
syncSaveSlotsWidget(saveNode);
|
||
const failedRetryButtons = saveNode._o1igsSlotsElement.children
|
||
.filter((card) => card.className.includes("failed"))
|
||
.map((card) => card.children.find((child) => child.className === "o1igs-slot-retry"));
|
||
assert.equal(failedRetryButtons.every((button) => button.disabled === false), true);
|
||
await Promise.all([
|
||
retryFailedSaveSlot(saveNode, 2),
|
||
retryFailedSaveSlot(saveNode, 4),
|
||
]);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(context.retryCalls.map((call) => call.options.retrySlotIndex))),
|
||
[2, 4],
|
||
);
|
||
|
||
const firstRetryBatch = "12121212-1212-4212-8212-121212121212";
|
||
const secondRetryBatch = "13131313-1313-4313-8313-131313131313";
|
||
beginGenerationBatch(sourceNode, saveNode, firstRetryBatch);
|
||
beginGenerationBatch(sourceNode, saveNode, secondRetryBatch);
|
||
finishGenerationBatch(saveNode, "第一张完成", firstRetryBatch);
|
||
assert.equal(saveNode._o1igsBusy, true);
|
||
assert.equal(sourceNode._o1igPendingBatchIds.has(saveNode.id), true);
|
||
finishGenerationBatch(saveNode, "第二张完成", secondRetryBatch);
|
||
assert.equal(saveNode._o1igsBusy, false);
|
||
assert.equal(sourceNode._o1igPendingBatchIds.has(saveNode.id), false);
|
||
|
||
saveNode._o1igsBusy = false;
|
||
saveNode._o1igsSlots = saveNode._o1igsSlots.map((slot) => ({
|
||
...slot,
|
||
state: "success",
|
||
image: slot.image || { filename: `completed-${slot.index}.png`, type: "output" },
|
||
}));
|
||
syncSaveSlotsWidget(saveNode);
|
||
assert.equal(saveNode._o1igsSlotsWidget, null);
|
||
assert.equal(saveNode._o1igsSlotsElement, null);
|
||
assert.equal(saveNode.widgets.length, 0);
|
||
assert.equal(saveNode.slotWidgetRemoveCount, 1);
|
||
assert.equal(slotContainer.classList.contains("o1key-slots-visible"), false);
|
||
document._querySelector = null;
|
||
}
|
||
|
||
{
|
||
const exactGridNode = {
|
||
size: [407, 413],
|
||
_o1igsSlots: [
|
||
{ index: 1, state: "failed" },
|
||
{ index: 2, state: "failed" },
|
||
],
|
||
_o1igsSlotsElement: { offsetWidth: 383 },
|
||
};
|
||
assert.equal(saveSlotsWidgetHeight(exactGridNode), 195);
|
||
|
||
const previewWidget = {
|
||
type: "custom",
|
||
serialize: false,
|
||
computedHeight: 424,
|
||
};
|
||
const squareNode = {
|
||
size: [407, 620],
|
||
imageIndex: 0,
|
||
imgs: [{ naturalWidth: 2048, naturalHeight: 2048 }],
|
||
widgets: [previewWidget],
|
||
setSize(size) { this.size = size; },
|
||
setDirtyCanvas() {},
|
||
};
|
||
assert.equal(preferredNativeSavePreviewHeight(squareNode), 422);
|
||
assert.equal(fitSaveNodeToNativeImages(squareNode), true);
|
||
assert.deepEqual(JSON.parse(JSON.stringify(squareNode.size)), [407, 618]);
|
||
|
||
squareNode.size = [407, 618];
|
||
previewWidget.computedHeight = 422;
|
||
squareNode.imgs = [{ naturalWidth: 2048, naturalHeight: 1152 }];
|
||
assert.equal(preferredNativeSavePreviewHeight(squareNode), 244);
|
||
assert.equal(fitSaveNodeToNativeImages(squareNode), true);
|
||
assert.deepEqual(JSON.parse(JSON.stringify(squareNode.size)), [407, 440]);
|
||
}
|
||
|
||
{
|
||
createdElements.length = 0;
|
||
const savedImages = [
|
||
{ filename: "kept-one.png", subfolder: "o1key", type: "output" },
|
||
{ filename: "kept-two.png", subfolder: "o1key", type: "output" },
|
||
];
|
||
let restoredMessage = null;
|
||
const restoredNode = {
|
||
id: 778,
|
||
graph,
|
||
properties: { o1keyImageSaveResults: savedImages },
|
||
_o1igsLastResults: storedSaveResults(null, {
|
||
properties: { o1keyImageSaveResults: savedImages },
|
||
}),
|
||
onExecuted(message) { restoredMessage = message; },
|
||
};
|
||
graph.nodes.set(restoredNode.id, restoredNode);
|
||
app.nodeOutputs = {};
|
||
restoreNativeSavePreview(restoredNode);
|
||
assert.equal(restoredMessage.images.length, 2);
|
||
assert.equal(restoredMessage.images[0].filename, "kept-one.png");
|
||
assert.equal(app.nodeOutputs[String(restoredNode.id)].images[1].filename, "kept-two.png");
|
||
assert.equal(createdElements.filter((element) => element.tagName === "IMG").length, 0);
|
||
}
|
||
|
||
{
|
||
class ReloadedSaveNode {
|
||
constructor() {
|
||
this.id = 779;
|
||
this.comfyClass = "O1keyImageSave";
|
||
this.graph = graph;
|
||
this.properties = {};
|
||
this.size = [300, 260];
|
||
this.widgets = [];
|
||
}
|
||
addDOMWidget() { return {}; }
|
||
setSize(size) { this.size = size; }
|
||
setDirtyCanvas() {}
|
||
onExecuted(message) { this.nativeExecutedMessage = message; }
|
||
}
|
||
await app.extension.beforeRegisterNodeDef(ReloadedSaveNode, { name: "O1keyImageSave" });
|
||
const reloadedNode = new ReloadedSaveNode();
|
||
graph.nodes.set(reloadedNode.id, reloadedNode);
|
||
const savedImages = [{ filename: "lifecycle.png", type: "output" }];
|
||
reloadedNode.onConfigure({ properties: { o1keyImageSaveResults: savedImages } });
|
||
app.extension.loadedGraphNode(reloadedNode);
|
||
assert.equal(reloadedNode.nativeExecutedMessage.images[0].filename, "lifecycle.png");
|
||
assert.equal(app.nodeOutputs[String(reloadedNode.id)].images[0].filename, "lifecycle.png");
|
||
const serialized = {};
|
||
reloadedNode.onSerialize(serialized);
|
||
assert.equal(serialized.properties.o1keyImageSaveResults[0].filename, "lifecycle.png");
|
||
assert.equal(serialized.o1key_image_save_results[0].filename, "lifecycle.png");
|
||
reloadedNode.onExecutionStart();
|
||
assert.equal(reloadedNode._o1igsBusy, false);
|
||
reloadedNode._o1igsStandardQueueReserved = true;
|
||
reloadedNode.onExecutionStart();
|
||
assert.equal(reloadedNode._o1igsBusy, true);
|
||
}
|
||
|
||
{
|
||
const nativeIcon = { className: "icon-[lucide--download] size-4" };
|
||
const nativeButton = new Element("button");
|
||
nativeButton.className = "native-white-background black-icon";
|
||
nativeButton.querySelector = (selector) => selector.includes("lucide--download") ? nativeIcon : null;
|
||
const preview = {
|
||
querySelectorAll: () => [nativeButton],
|
||
querySelector: () => ({ src: "/view?filename=two.png&type=output" }),
|
||
};
|
||
const saveNode = {
|
||
id: 777,
|
||
_o1igsBusy: false,
|
||
_o1igsLastResults: [
|
||
{ filename: "one.png", type: "output" },
|
||
{ filename: "two.png", type: "output" },
|
||
],
|
||
};
|
||
document._querySelector = (selector) => selector.includes('data-node-id="777"') ? preview : null;
|
||
syncNativePreviewAction(saveNode);
|
||
assert.equal(nativeButton.className, "native-white-background black-icon");
|
||
assert.equal(nativeButton.title, "重新生成");
|
||
assert.equal(nativeButton["aria-label"], "重新生成");
|
||
assert.match(nativeIcon.className, /lucide--refresh-cw/);
|
||
assert.doesNotMatch(nativeIcon.className, /lucide--download/);
|
||
assert.equal(nativeButton.dataset.o1keyRegenerate, "777");
|
||
document._querySelector = null;
|
||
}
|
||
|
||
{
|
||
const sourceNode = {
|
||
id: 900,
|
||
comfyClass: "O1keyImageGenerator",
|
||
graph,
|
||
widgets: [{ name: "seed", value: 0 }],
|
||
_o1igSeed: { value: "0" },
|
||
};
|
||
const saveNode = {
|
||
id: 901,
|
||
comfyClass: "O1keyImageSave",
|
||
graph,
|
||
inputs: [{ link: 9090 }],
|
||
};
|
||
graph.nodes.set(sourceNode.id, sourceNode);
|
||
graph.nodes.set(saveNode.id, saveNode);
|
||
graph.links.set(9090, { origin_id: sourceNode.id, target_id: saveNode.id });
|
||
context.regenerationCalls = [];
|
||
vm.runInContext(
|
||
"queueGeneration = async (node, imageCount) => regenerationCalls.push({ node, imageCount })",
|
||
context,
|
||
);
|
||
await regenerateFromSaveNode(saveNode, 2);
|
||
assert.equal(context.regenerationCalls.length, 1);
|
||
assert.equal(context.regenerationCalls[0].node, sourceNode);
|
||
assert.equal(context.regenerationCalls[0].imageCount, 1);
|
||
}
|
||
|
||
assert.match(source, /await queueGeneration\(source, 1\)/);
|
||
assert.match(source, /: acquireSaveNodeForBatch\(node, batchId\)/);
|
||
assert.match(source, /installStandardQueueRouting\(\)/);
|
||
assert.match(source, /reroutePartialExecutionTargets\(queueNodeIds\)/);
|
||
assert.match(source, /for \(const nodeId of removed\) delete output\[nodeId\]/);
|
||
assert.match(source, /startNextStandardExecution\(this\)/);
|
||
assert.match(source, /Promise\.allSettled/);
|
||
assert.match(source, /imageUploadQueue\.then\(\(\) => uploadImage\(file\)\)/);
|
||
assert.doesNotMatch(source, /URL\.createObjectURL|URL\.revokeObjectURL/);
|
||
assert.match(source, /function thumbnailUrl\(item\)/);
|
||
assert.match(rawSource, /import \{ openReferenceImageEditor \} from "\.\/o1keyReferenceImageEditor\.js"/);
|
||
assert.match(source, /className = "o1ig-edit"/);
|
||
assert.match(source, /sourceUrl: viewUrl\(original\)/);
|
||
assert.match(source, /state\.items\.splice\(currentIndex, 1, uploaded\)/);
|
||
assert.doesNotMatch(source, /o1key_uploads/);
|
||
assert.match(source, /fetchParallelBatchStatus/);
|
||
assert.match(source, /recoverParallelBatch/);
|
||
assert.match(source, /detachParallelBatchNode/);
|
||
assert.match(source, /\.o1key-slots-visible \.image-preview\{display:none!important;\}/);
|
||
assert.doesNotMatch(source, /resizeNativeSavePreview/);
|
||
assert.doesNotMatch(source, /\.o1key-image-save-node \.lg-node-content/);
|
||
assert.doesNotMatch(source, /\.o1key-image-save-node \.image-preview\s*\{/);
|
||
assert.doesNotMatch(source, /className = "o1igs-card"/);
|
||
const saveRendererSource = source.slice(
|
||
source.indexOf("function renderSaveResults"),
|
||
source.indexOf("function setSaveBusy"),
|
||
);
|
||
assert.doesNotMatch(saveRendererSource, /createElement\("img"\)/);
|
||
const savePanelSource = source.slice(
|
||
source.indexOf("function buildSavePanel"),
|
||
source.indexOf("function installNativeMinimumSize"),
|
||
);
|
||
assert.doesNotMatch(savePanelSource, /addDOMWidget/);
|
||
assert.doesNotMatch(savePanelSource, /prefixWidget\.hidden = true/);
|
||
assert.doesNotMatch(source, /installNativeMinimumSize\(nodeType, SAVE_NODE_LAYOUT_SIZE\)/);
|
||
assert.match(source, /lucide--download.*lucide--refresh-cw/);
|
||
assert.match(source, /font-size:12px;font-weight:500;line-height:1\.4;letter-spacing:\.035em/);
|
||
assert.match(source, /o1ig-select-caret svg\{display:block;width:12px;height:12px/);
|
||
assert.match(source, /const GENERATOR_DEFAULT_SIZE = \[560, 1035\]/);
|
||
assert.doesNotMatch(source, /o1key-save-custom-prefix/);
|
||
assert.match(source, /const GENERATOR_MIN_SIZE = \[500, 1025\]/);
|
||
assert.match(source, /const GENERATOR_DENSE_MIN_HEIGHT = 1110/);
|
||
assert.match(source, /const GENERATOR_BATCH_MIN_HEIGHT = 1215/);
|
||
assert.match(source, /const GENERATOR_DENSE_BATCH_MIN_HEIGHT = 1300/);
|
||
assert.match(source, /\.o1ig-prompt-wrap\{[^\n]*height:auto;min-height:142px;flex:1 1 142px/);
|
||
assert.match(source, /\.o1ig-prompt\{[\s\S]*?min-height:142px;max-height:none;resize:none/);
|
||
assert.doesNotMatch(source, /isExternalPromptConnected|useExternalPrompt|o1ig-prompt-input-slot/);
|
||
assert.match(source, /delete nodeData\.input\.optional\.external_prompt/);
|
||
assert.doesNotMatch(source, /app\.queuePrompt\(0, 1, \[saveNode\.id\]\)/);
|
||
assert.match(source, /\.o1ig-refs\{[\s\S]*?flex:0 0 109px[\s\S]*?min-height:109px/);
|
||
assert.match(source, /\.o1ig-thumb\{[\s\S]*?flex:0 0 102px;height:102px/);
|
||
assert.match(source, /\.o1ig-thumb img\{[\s\S]*?object-fit:contain;background:#111/);
|
||
assert.match(source, /referenceActions\.append\(add, canvasPick\)/);
|
||
assert.match(source, /modelActions\.append\(modelAdd, modelCanvasPick\)/);
|
||
assert.match(source, /window\.o1keyCanvasImagePicker = Object\.freeze/);
|
||
assert.equal(typeof context.window.o1keyCanvasImagePicker.open, "function");
|
||
assert.equal(context.window.o1keyCanvasImagePicker.readFile, readCanvasImageFile);
|
||
assert.match(source, /state\.container\.replaceChildren\(\);/);
|
||
assert.doesNotMatch(source, /className = "o1ig-order-handle"/);
|
||
assert.match(source, /tile\.draggable = !sortingLocked/);
|
||
assert.match(source, /tile\.addEventListener\("dragstart", \(event\) => beginReferenceDrag/);
|
||
assert.match(source, /node\._o1igSuppressReferenceClickUntil = Date\.now\(\) \+ 350/);
|
||
assert.match(source, /\.o1ig-thumb\.o1ig-dragging::before\{[\s\S]*?content:"移动中"/);
|
||
assert.match(source, /\.o1ig-refs\.o1ig-reordering\{/);
|
||
assert.match(source, /\.o1ig-thumb\.o1ig-drop-before\{transform:translateX\(7px\)/);
|
||
assert.match(source, /\.o1ig-empty-reference:hover,\.o1ig-empty-reference\.drag\{/);
|
||
assert.match(source, /\.o1ig-toolbar\{[^\n]*grid-template-columns:repeat\(2,minmax\(0,1fr\)\)/);
|
||
assert.match(source, /\.o1ig-field\{display:flex;flex-direction:column/);
|
||
assert.match(source, /makePanelSectionTitle\("画面描述"\)/);
|
||
assert.match(source, /makePanelSectionTitle\("生成参数"\)/);
|
||
assert.match(source, /makePanelSectionTitle\("保存设置"\)/);
|
||
assert.match(source, /filenamePrefixField\.classList\.add\("o1ig-field-wide"\)/);
|
||
assert.match(source, /saveLocationField\.classList\.add\("o1ig-field-wide"\)/);
|
||
assert.match(source, /o1ig-resize-warning\{display:none;color:#d5aa62/);
|
||
assert.match(source, /o1ig-resize-warning\.visible\{display:block/);
|
||
assert.match(source, /o1ig-seed\{[\s\S]*grid-template-columns:minmax\(0,1fr\) 34px;gap:0/);
|
||
assert.match(source, /o1ig-seed button\{[\s\S]*border-left:1px solid/);
|
||
assert.match(source, /className = "o1ig-prompt-optimize"/);
|
||
assert.match(source, /className = "o1ig-prompt-optimize-status"/);
|
||
assert.match(source, /promptOptimizeIcon\.textContent = "✨";[\s\S]*?promptOptimizeLabel\.textContent = "AI帮写";[\s\S]*?promptOptimize\.append\(promptOptimizeIcon, promptOptimizeLabel\)/);
|
||
assert.match(source, /o1ig-prompt-optimize\{[\s\S]*?min-width:96px[\s\S]*?display:flex[\s\S]*?gap:5px/);
|
||
assert.match(source, /o1ig-prompt-optimize-icon\{[\s\S]*?font-size:15px/);
|
||
assert.match(source, /o1ig-prompt-optimize-status\{[\s\S]*?right:112px[\s\S]*?max-width:calc\(100% - 128px\)/);
|
||
assert.doesNotMatch(source, /o1ig-prompt-guide|promptGuide|updateBatchPromptGuide|描述示例/);
|
||
assert.doesNotMatch(source, /先上传素材图和目标图|批量任务会在提交前显示总数/);
|
||
assert.match(source, /if \(singleReferences \? !outfits : \(!outfits \|\| !models\)\) \{/);
|
||
assert.match(source, /modelHint\.textContent = "每张目标图单独参与组合"/);
|
||
assert.match(source, /_o1igModelAssets\?\.classList\.toggle\("visible", enabled && !singleReferences\)/);
|
||
assert.match(source, /单图批量至少需要上传1张素材图/);
|
||
assert.match(source, /summary\.textContent = `\$\{pairingText\} × 每组 \$\{perPair\} 张\$\{promptText\}，共 \$\{total\} 张`/);
|
||
assert.doesNotMatch(source, /整组参与 \/ 全匹配时每张独立/);
|
||
assert.match(source, /index\.className = "o1ig-reference-index";[\s\S]*?index\.textContent = badges\.label/);
|
||
assert.doesNotMatch(source, /o1ig-request-index/);
|
||
assert.match(source, /const REFERENCE_LIGHTBOX_ID = "o1key-image-reference-lightbox"/);
|
||
assert.match(source, /function showReferenceLightbox\(node, role, listIndex\)/);
|
||
assert.match(source, /image\.setAttribute\("aria-label", sortingLocked \? "查看大图" : "查看大图；按住拖动可排序"\)[\s\S]*?showReferenceLightbox\(node, role, entry\.index\)/);
|
||
assert.match(source, /\.o1ig-lightbox\{[\s\S]*?position:fixed;inset:0;z-index:9999/);
|
||
assert.doesNotMatch(source, /o1ig-thumb\.previewable::after|content:"查看"|openImageInNewTab|window\.open/);
|
||
assert.match(source, /batchMode\.addEventListener\("change", \(\) => \{[\s\S]*?syncBatchLayout\(node\);/);
|
||
assert.match(source, /promptOptimize\.title = "AI帮写"/);
|
||
assert.match(source, /多个提示词用独占一行的 --- 分隔/);
|
||
assert.match(source, /setPromptOptimizeStatus\(node, "AI帮写中…", "busy"\)/);
|
||
assert.match(source, /await api\.fetchApi\("\/o1key\/image\/prompt-optimize"/);
|
||
assert.match(source, /o1ig-select-option-description/);
|
||
assert.match(source, /const THINKING_LEVEL_OPTIONS = \[/);
|
||
assert.match(source, /value: "低", label: "低", description: "耗时低，智力低"/);
|
||
assert.match(source, /value: "高", label: "高", description: "耗时高，智力高"/);
|
||
assert.match(source, /makeSelect\(THINKING_LEVEL_OPTIONS, findWidget\(node, "思考等级"\)\?\.value \|\| "低"\)/);
|
||
assert.match(source, /node\._o1igThinking\.value = findWidget\(node, "思考等级"\)\?\.value \|\| "低"/);
|
||
assert.match(source, /value: "不缩放", label: "不缩放", description: "无大图"/);
|
||
assert.match(source, /value: "智能缩放", label: "智能缩放", description: "有大图"/);
|
||
assert.doesNotMatch(source, /色彩纠正|不改AI图|改AI图/);
|
||
assert.match(source, /className = "o1ig-select-selected-description"/);
|
||
assert.match(source, /trigger\.append\(valueLabel, valueDescription, caret\)/);
|
||
assert.equal(maxReferences, 50);
|
||
assert.equal(maxRequestReferences, 10);
|
||
assert.equal(referenceLimit({ _o1igBatchEnabled: false }), 10);
|
||
assert.equal(referenceLimit({
|
||
_o1igLayerDecomposition: { value: "开启" },
|
||
_o1igBatchEnabled: false,
|
||
}), 1);
|
||
assert.equal(referenceLimit({
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "一组搭配+多模特" },
|
||
}, "references"), 9);
|
||
assert.equal(referenceLimit({
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "全部搭配×全部模特" },
|
||
}, "references"), 50);
|
||
assert.equal(referenceLimit({
|
||
_o1igBatchEnabled: true,
|
||
_o1igBatchMode: { value: "单图素材批量" },
|
||
}, "references"), 50);
|
||
assert.equal(referenceLimit({ _o1igBatchEnabled: true }, "models"), 50);
|
||
{
|
||
const saveNode = {
|
||
properties: {},
|
||
graph,
|
||
widgets: [],
|
||
_o1igsSlots: Array.from({ length: 4 }, (_, index) => ({
|
||
index: index + 1,
|
||
state: "running",
|
||
prompt: "",
|
||
references: [],
|
||
image: null,
|
||
})),
|
||
setDirtyCanvas() {},
|
||
};
|
||
const images = [
|
||
{ filename: "first.png", type: "output", request_index: 1, result_index: 1 },
|
||
{ filename: "second.png", type: "output", request_index: 2, result_index: 1 },
|
||
{ filename: "third-a.png", type: "output", request_index: 3, result_index: 1 },
|
||
{ filename: "third-b.png", type: "output", request_index: 3, result_index: 2 },
|
||
{ filename: "fourth.png", type: "output", request_index: 4, result_index: 1 },
|
||
];
|
||
const completed = applyCompletedSaveSlots(saveNode, {
|
||
total_count: 4,
|
||
request_count: 4,
|
||
result_count: 5,
|
||
}, images);
|
||
assert.equal(completed.length, 5);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(saveNode._o1igsSlots.map((slot) => slot.state))),
|
||
["success", "success", "success", "success"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(saveNode._o1igsSlots.map((slot) => slot.image.filename))),
|
||
["first.png", "second.png", "third-a.png", "fourth.png"],
|
||
);
|
||
const restoredSlots = reconcileSaveSlotsWithResults(
|
||
saveNode._o1igsSlots.map((slot, index) => ({
|
||
...slot,
|
||
state: index ? "running" : "success",
|
||
image: index ? null : slot.image,
|
||
})),
|
||
images,
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(restoredSlots.map((slot) => slot.state))),
|
||
["success", "success", "success", "success"],
|
||
);
|
||
assert.deepEqual(
|
||
JSON.parse(JSON.stringify(restoredSlots.map((slot) => slot.image.filename))),
|
||
["first.png", "second.png", "third-a.png", "fourth.png"],
|
||
);
|
||
}
|
||
{
|
||
const saveNode = {
|
||
properties: {},
|
||
graph,
|
||
widgets: [],
|
||
_o1igsSlots: [{ index: 1, state: "running", prompt: "", references: [], image: null }],
|
||
setDirtyCanvas() {},
|
||
};
|
||
const images = [
|
||
{
|
||
filename: "base.png", subfolder: "", type: "output",
|
||
request_index: 1, result_index: 1,
|
||
layer: { z_index: 0, name: "底图", url: "https://signed.invalid/secret" },
|
||
},
|
||
{
|
||
filename: "subject.png", subfolder: "", type: "output",
|
||
request_index: 1, result_index: 2,
|
||
layer: { z_index: 1, name: "主体" },
|
||
},
|
||
];
|
||
const completed = applyCompletedSaveSlots(saveNode, {
|
||
total_count: 2,
|
||
request_count: 1,
|
||
result_count: 2,
|
||
}, images, 0, true);
|
||
assert.equal(completed.length, 2);
|
||
assert.equal(completed[1].layer.name, "主体");
|
||
assert.equal(Object.hasOwn(completed[0].layer, "url"), false);
|
||
}
|
||
assert.match(source, /mask: isGptImageModel\(node\._o1igModel\.value\)/);
|
||
assert.match(source, /resizeWarning\.textContent = "可能发生像素偏移"/);
|
||
assert.match(source, /resize_mode: node\._o1igResize\.value/);
|
||
assert.doesNotMatch(source, /color_correction/);
|
||
assert.match(source, /if \(isGptImageModel\(node\._o1igModel\.value\)\)/);
|
||
assert.match(source, /jobPayload\.output_format = node\._o1igOutputFormat\.value/);
|
||
assert.match(source, /node\._o1igModel\.value === "Seedream 5\.0 Pro"/);
|
||
assert.match(source, /save_format: saveSettings\.format/);
|
||
assert.match(source, /jobPayload\.background = node\._o1igBackground\.value/);
|
||
assert.doesNotMatch(source, /jobPayload\.moderation/);
|
||
assert.match(source, /jobPayload\.google_search = true/);
|
||
assert.match(source, /jobPayload\.layer_decomposition = true/);
|
||
assert.match(source, /if \(layerDecomposition\) \{\s*layerSaveNode = acquireLayerSaveNodeForBatch\(node, saveNode\);/);
|
||
assert.match(source, /layerDecomposition,\s*retrySlotIndex,/);
|
||
assert.match(source, /node\._o1igModel\.value === "Nano Banana 2"/);
|
||
assert.match(source, /node\._o1igOnlineSearch\.value === "打开"/);
|
||
assert.match(source, /batch_enabled: retryTask \? false : Boolean\(node\._o1igBatchEnabled\)/);
|
||
assert.match(source, /model_references: retryTask \|\| node\._o1igBatchMode\.value === BATCH_MODE_SINGLE_REFERENCES/);
|
||
assert.match(source, /整组素材 → 多个目标/);
|
||
assert.match(source, /全匹配（素材 × 目标）/);
|
||
assert.match(source, /单图批量（每张素材独立）/);
|
||
assert.match(source, /api\.fetchApi\("\/o1key\/image\/save"/);
|
||
assert.match(source, /const saveSettings = generatorSaveSettings\(findConnectedGenerator\(saveNode\)\)/);
|
||
assert.match(source, /format: saveSettings\.format/);
|
||
assert.match(source, /save_location: saveSettings\.save_location/);
|
||
assert.match(source, /naming_rule: saveSettings\.naming_rule/);
|
||
assert.match(source, /api\.getQueue = async/);
|
||
assert.match(source, /api\.cancelJob = async/);
|
||
assert.match(source, /document\.createElement\("button"\)/);
|
||
assert.match(source, /"bg-secondary-background"/);
|
||
assert.doesNotMatch(source, /\.o1key-queue-count\s*\{/);
|
||
assert.match(source, /total_count: taskPrompts\.length/);
|
||
assert.match(source, /function retryFailedSaveSlot/);
|
||
assert.match(source, /failed_items/);
|
||
assert.match(source, /encodeURIComponent\(job\.batch_id\)\}\/cancel/);
|
||
assert.match(source, /generate\.addEventListener\("click", \(\) => queueGeneration\(node\)\)/);
|
||
assert.doesNotMatch(source, /取消当前任务/);
|
||
assert.doesNotMatch(source, /makeAdvancedField\("色彩纠正"/);
|
||
assert.match(source, /makeAdvancedField\("背景", background\)/);
|
||
assert.doesNotMatch(source, /makeAdvancedField\("内容审查强度"/);
|
||
assert.match(source, /makeAdvancedField\("在线搜索", onlineSearch\)/);
|
||
assert.match(source, /makeAdvancedField\("图层拆分", layerDecomposition\)/);
|
||
assert.match(source, /makeAdvancedField\("输出格式", outputFormat\)/);
|
||
assert.match(source, /makeAdvancedField\("命名规则", namingRule\)/);
|
||
assert.match(source, /makeAdvancedField\("文件名前缀", filenamePrefix\)/);
|
||
assert.match(source, /makeAdvancedField\("格式", saveFormat\)/);
|
||
assert.match(source, /makeAdvancedField\("保存位置", saveLocation\)/);
|
||
assert.match(source, /留空为 output；或填写 D:\/图片/);
|
||
assert.doesNotMatch(source, /色彩纠正/);
|
||
assert.match(source, /const MODEL_CAPABILITIES = Object\.freeze/);
|
||
assert.match(source, /setFieldVisible\(node\._o1igOnlineSearchField, capabilities\.search\)/);
|
||
assert.match(source, /_o1igResizeField: resizeField/);
|
||
assert.doesNotMatch(source, /参考图输入/);
|
||
assert.doesNotMatch(source, /hasConnectedReferenceInput/);
|
||
assert.doesNotMatch(source, /className = "o1ig-more"/);
|
||
assert.doesNotMatch(source, /className = "o1ig-advanced"/);
|
||
assert.match(source, /const GPT_OUTPUT_FORMATS = \[/);
|
||
assert.match(source, /value: "jpeg", label: "JPEG"/);
|
||
assert.match(source, /findWidget\(node, "输出格式"\)\?\.value \|\| "jpeg"/);
|
||
assert.match(source, /setFieldVisible\(node\._o1igSaveFormatField, capabilities\.saveFormat\)/);
|
||
assert.match(source, /const GPT_BACKGROUNDS = \[/);
|
||
assert.doesNotMatch(source, /const GPT_MODERATION_OPTIONS = \[/);
|
||
assert.match(source, /option\.value !== "jpeg"/);
|
||
assert.match(migrationSource, /type: "O1keyImageGenerator"/);
|
||
assert.match(migrationSource, /"不缩放"/);
|
||
assert.match(migrationSource, /"不纠正"/);
|
||
assert.match(migrationSource, /"auto"/);
|
||
assert.match(migrationSource, /移除统一图片生成节点已停用的色彩纠正参数/);
|
||
assert.match(migrationSource, /wv\.length < 15/);
|
||
assert.match(migrationSource, /wv\.length < 18/);
|
||
assert.match(migrationSource, /migrateUnifiedSaveSettings/);
|
||
assert.match(migrationSource, /migrateUnifiedOnlineSearch/);
|
||
assert.match(migrationSource, /migrateUnifiedExternalPromptInput/);
|
||
assert.match(migrationSource, /type: "MiniMaxH3Video"/);
|
||
assert.match(migrationSource, /wv\.push\("MiniMax-H3"\)/);
|
||
assert.match(migrationSource, /原生 seed 参数/);
|
||
|
||
{
|
||
let migrationExtension;
|
||
const migrationContext = {
|
||
app: { registerExtension(extension) { migrationExtension = extension; } },
|
||
console: { log() {}, warn() {} },
|
||
};
|
||
vm.runInNewContext(
|
||
migrationSource.replace(/^import .*;\s*$/gm, ""),
|
||
migrationContext,
|
||
);
|
||
const legacyRedCastValues = [1.0, 8.0, 0.1, "", 62.0, 15.0];
|
||
const legacyRedCastGraph = {
|
||
nodes: [{ type: "O1keyAutoRedCast", widgets_values: legacyRedCastValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyRedCastGraph);
|
||
assert.deepEqual(legacyRedCastValues, [1.0, 8.0, 0.1, "", 62.0, 15.0, 0]);
|
||
migrationExtension.beforeConfigureGraph(legacyRedCastGraph);
|
||
assert.equal(legacyRedCastValues.length, 7);
|
||
|
||
const interimRedCastValues = [1.0, 8.0, 0.1, "", 1234, 62.0, 15.0];
|
||
const interimRedCastGraph = {
|
||
nodes: [{ type: "O1keyAutoRedCast", widgets_values: interimRedCastValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(interimRedCastGraph);
|
||
assert.deepEqual(interimRedCastValues, [1.0, 8.0, 0.1, "", 62.0, 15.0, 1234]);
|
||
migrationExtension.beforeConfigureGraph(interimRedCastGraph);
|
||
assert.deepEqual(interimRedCastValues, [1.0, 8.0, 0.1, "", 62.0, 15.0, 1234]);
|
||
|
||
const currentRedCastValues = [1.0, 8.0, 0.1, "", 62.0, 15.0, 77];
|
||
migrationExtension.beforeConfigureGraph({
|
||
nodes: [{ type: "O1keyAutoRedCast", widgets_values: currentRedCastValues }],
|
||
});
|
||
assert.deepEqual(currentRedCastValues, [1.0, 8.0, 0.1, "", 62.0, 15.0, 77]);
|
||
|
||
const legacyPromptGraph = {
|
||
nodes: [
|
||
{ id: 1, type: "TextSource", outputs: [{ links: [41, 42] }] },
|
||
{
|
||
id: 2,
|
||
type: "O1keyImageGenerator",
|
||
inputs: [{ name: "prompt", link: null }, { name: "external_prompt", link: 41 }],
|
||
widgets_values: ["保留面板提示词"],
|
||
},
|
||
{ id: 3, type: "OtherNode", inputs: [{ link: 42 }] },
|
||
],
|
||
links: [[41, 1, 0, 2, 1, "STRING"], [42, 1, 0, 3, 0, "STRING"]],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyPromptGraph);
|
||
assert.deepEqual(legacyPromptGraph.nodes[1].inputs.map((input) => input.name), ["prompt"]);
|
||
assert.deepEqual(legacyPromptGraph.nodes[0].outputs[0].links, [42]);
|
||
assert.deepEqual(legacyPromptGraph.links.map((link) => link[0]), [42]);
|
||
assert.equal(legacyPromptGraph.nodes[1].widgets_values[0], "保留面板提示词");
|
||
migrationExtension.beforeConfigureGraph(legacyPromptGraph);
|
||
assert.deepEqual(legacyPromptGraph.links.map((link) => link[0]), [42]);
|
||
|
||
const nestedPromptGraph = {
|
||
definitions: { subgraphs: [{
|
||
nodes: [
|
||
{ id: 4, type: "TextSource", outputs: [{ links: [43] }] },
|
||
{ id: 5, type: "O1keyImageGenerator", inputs: [{ name: "external_prompt", link: 43 }] },
|
||
],
|
||
links: [{ id: 43, origin_id: 4, target_id: 5 }],
|
||
}] },
|
||
};
|
||
migrationExtension.beforeConfigureGraph(nestedPromptGraph);
|
||
assert.deepEqual(nestedPromptGraph.definitions.subgraphs[0].nodes[0].outputs[0].links, []);
|
||
assert.deepEqual(nestedPromptGraph.definitions.subgraphs[0].nodes[1].inputs, []);
|
||
assert.deepEqual(nestedPromptGraph.definitions.subgraphs[0].links, []);
|
||
|
||
const legacyValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1", "1", 0,
|
||
"[]", "自动", "png", "{}", "不缩放",
|
||
];
|
||
const graphData = {
|
||
nodes: [{ type: "O1keyImageGenerator", widgets_values: legacyValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(graphData);
|
||
assert.equal(legacyValues.length, 23);
|
||
|
||
const legacyVideoValues = Array.from({ length: 16 }, (_, index) => `value-${index}`);
|
||
const legacyVideoGraph = {
|
||
nodes: [{ type: "O1keyVideoGenerator", widgets_values: legacyVideoValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyVideoGraph);
|
||
assert.equal(legacyVideoValues.length, 17);
|
||
assert.equal(legacyVideoValues[16], "auto");
|
||
migrationExtension.beforeConfigureGraph(legacyVideoGraph);
|
||
assert.equal(legacyVideoValues.length, 17);
|
||
assert.equal(legacyValues[22], false);
|
||
migrationExtension.beforeConfigureGraph(graphData);
|
||
assert.equal(legacyValues.length, 23);
|
||
|
||
const legacyMiniMaxValues = ["prompt", "文生视频", "16:9", "2K", 5];
|
||
const legacyMiniMaxGraph = {
|
||
nodes: [{ type: "MiniMaxH3Video", widgets_values: legacyMiniMaxValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyMiniMaxGraph);
|
||
assert.deepEqual(legacyMiniMaxValues.slice(-2), ["MiniMax-H3", 0]);
|
||
assert.equal(legacyMiniMaxValues.length, 7);
|
||
migrationExtension.beforeConfigureGraph(legacyMiniMaxGraph);
|
||
assert.equal(legacyMiniMaxValues.length, 7);
|
||
|
||
const modelOnlyMiniMaxValues = [
|
||
"prompt", "文生视频", "16:9", "2K", 5, "MiniMax-H3-MAX",
|
||
];
|
||
migrationExtension.beforeConfigureGraph({
|
||
nodes: [{ type: "MiniMaxH3Video", widgets_values: modelOnlyMiniMaxValues }],
|
||
});
|
||
assert.deepEqual(modelOnlyMiniMaxValues.slice(-2), ["MiniMax-H3-MAX", 0]);
|
||
assert.equal(legacyValues[13], "auto");
|
||
assert.equal(legacyValues[14], false);
|
||
assert.equal(legacyValues[15], "一组搭配+多模特");
|
||
assert.equal(legacyValues[16], "[]");
|
||
assert.deepEqual(legacyValues.slice(17, 21), ["自定义前缀", "o1key", "原始", ""]);
|
||
assert.equal(legacyValues[21], "关闭");
|
||
migrationExtension.beforeConfigureGraph(graphData);
|
||
assert.equal(legacyValues.length, 23);
|
||
assert.equal(legacyValues[22], false);
|
||
|
||
const currentValues = [
|
||
"prompt", "gpt-image-2", "畅速", "高", "2K", "16:9", "1", 42,
|
||
"[]", "自动", "webp", "{}", "不缩放", "不纠正", "transparent",
|
||
];
|
||
migrationExtension.beforeConfigureGraph({
|
||
nodes: [{ type: "O1keyImageGenerator", widgets_values: currentValues }],
|
||
});
|
||
assert.equal(currentValues.length, 23);
|
||
assert.equal(currentValues[22], false);
|
||
assert.equal(currentValues[10], "webp");
|
||
assert.equal(currentValues[13], "transparent");
|
||
assert.equal(currentValues[14], false);
|
||
assert.equal(currentValues[15], "一组搭配+多模特");
|
||
assert.equal(currentValues[16], "[]");
|
||
assert.deepEqual(currentValues.slice(17, 21), ["自定义前缀", "o1key", "原始", ""]);
|
||
assert.equal(currentValues[21], "关闭");
|
||
|
||
const retiredModerationValues = [
|
||
"prompt", "gpt-image-2.5-flare", "直连", "低", "智能", "智能", "9", 17,
|
||
"[]", "最高", "webp", "{}", "智能缩放", "opaque", "低",
|
||
true, "单图素材批量", "[]", "自然数字", "saved", "原始", "archive", "关闭", false,
|
||
];
|
||
const retiredModerationGraph = {
|
||
nodes: [{ type: "O1keyImageGenerator", widgets_values: retiredModerationValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(retiredModerationGraph);
|
||
assert.equal(retiredModerationValues.length, 23);
|
||
assert.deepEqual(retiredModerationValues.slice(13, 17), ["opaque", true, "单图素材批量", "[]"]);
|
||
assert.equal(retiredModerationValues[9], "最高");
|
||
assert.equal(retiredModerationValues[17], "自然数字");
|
||
migrationExtension.beforeConfigureGraph(retiredModerationGraph);
|
||
assert.equal(retiredModerationValues.length, 23);
|
||
|
||
const movedGeneratorValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "低", "2K", "1:1", "1", 0,
|
||
"[]", "自动", "png", "{}", "不缩放", "不纠正", "auto", "自动",
|
||
false, "一组搭配+多模特", "[]",
|
||
];
|
||
const legacySaveValues = ["legacy-prefix", "jpg", "archive/session", "自然数字"];
|
||
const movedGraph = {
|
||
nodes: [
|
||
{ id: 10, type: "O1keyImageGenerator", widgets_values: movedGeneratorValues },
|
||
{
|
||
id: 11,
|
||
type: "O1keyImageSave",
|
||
widgets_values: legacySaveValues,
|
||
inputs: [{ link: 99 }],
|
||
properties: {},
|
||
},
|
||
],
|
||
links: [[99, 10, 0, 11, 0, "IMAGE"]],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(movedGraph);
|
||
assert.deepEqual(
|
||
movedGeneratorValues.slice(17, 21),
|
||
["自然数字", "legacy-prefix", "jpg", "archive/session"],
|
||
);
|
||
assert.deepEqual(legacySaveValues, []);
|
||
migrationExtension.beforeConfigureGraph(movedGraph);
|
||
assert.equal(movedGeneratorValues.length, 23);
|
||
assert.equal(movedGeneratorValues[22], false);
|
||
assert.equal(movedGeneratorValues[21], "关闭");
|
||
assert.deepEqual(legacySaveValues, []);
|
||
|
||
const legacyNanoValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1", "1", 0,
|
||
];
|
||
const legacyNanoGraph = {
|
||
nodes: [{ type: "NanoBanana", widgets_values: legacyNanoValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyNanoGraph);
|
||
assert.deepEqual(legacyNanoValues.slice(-1), ["不缩放"]);
|
||
assert.equal(legacyNanoValues.length, 9);
|
||
migrationExtension.beforeConfigureGraph(legacyNanoGraph);
|
||
assert.equal(legacyNanoValues.length, 9);
|
||
|
||
const legacyNanoWithColorCorrection = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1", "1", 0,
|
||
"不缩放", "智能纠正",
|
||
];
|
||
migrationExtension.beforeConfigureGraph({
|
||
nodes: [{ type: "NanoBanana", widgets_values: legacyNanoWithColorCorrection }],
|
||
});
|
||
assert.deepEqual(legacyNanoWithColorCorrection.slice(-1), ["不缩放"]);
|
||
assert.equal(legacyNanoWithColorCorrection.length, 9);
|
||
|
||
const legacyBatchNanoValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1",
|
||
"1个路径", "D:\\images", "关闭", 0, "原始", 95,
|
||
"和原始图片名保持一致", "",
|
||
];
|
||
const legacyBatchNanoGraph = {
|
||
nodes: [{ type: "BatchNanoBananaPro", widgets_values: legacyBatchNanoValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyBatchNanoGraph);
|
||
assert.deepEqual(legacyBatchNanoValues.slice(-6), [
|
||
"不缩放", "原始", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
assert.equal(legacyBatchNanoValues[10], 95);
|
||
assert.equal(legacyBatchNanoValues.length, 14);
|
||
migrationExtension.beforeConfigureGraph(legacyBatchNanoGraph);
|
||
assert.deepEqual(legacyBatchNanoValues.slice(-6), [
|
||
"不缩放", "原始", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
|
||
const stringQualityValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1",
|
||
"1个路径", "D:\\images", "关闭", 0, "JPEG", "95",
|
||
"和原始图片名保持一致", "", "不缩放", "不纠正",
|
||
];
|
||
const stringQualityGraph = {
|
||
nodes: [{ type: "BatchNanoBananaPro", widgets_values: stringQualityValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(stringQualityGraph);
|
||
assert.equal(stringQualityValues[10], 95);
|
||
assert.equal(typeof stringQualityValues[10], "number");
|
||
assert.deepEqual(stringQualityValues.slice(-6), [
|
||
"不缩放", "JPEG", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
assert.equal(stringQualityValues.length, 14);
|
||
migrationExtension.beforeConfigureGraph(stringQualityGraph);
|
||
assert.equal(stringQualityValues[10], 95);
|
||
assert.deepEqual(stringQualityValues.slice(-6), [
|
||
"不缩放", "JPEG", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
|
||
const smartResizeValues = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "2K", "1:1",
|
||
"1个路径", "D:\\images", "关闭", 0, "PNG", 95,
|
||
"和原始图片名保持一致", "", "智能缩放", "智能纠正",
|
||
];
|
||
const smartResizeGraph = {
|
||
nodes: [{ type: "BatchNanoBananaPro", widgets_values: smartResizeValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(smartResizeGraph);
|
||
assert.deepEqual(smartResizeValues.slice(-6), [
|
||
"智能缩放", "PNG", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
migrationExtension.beforeConfigureGraph(smartResizeGraph);
|
||
assert.deepEqual(smartResizeValues.slice(-6), [
|
||
"智能缩放", "PNG", 95, "和原始图片名保持一致", "", 0,
|
||
]);
|
||
|
||
const multiPathValues = [
|
||
"prompt", "Nano Banana 2", "专线", "低", "4K", "16:9",
|
||
"3个路径", "D:\\one", "D:\\two", "D:\\three", "同序号", "2",
|
||
7788, "WebP", 73, "自然数字", "D:\\output", "智能缩放",
|
||
];
|
||
const multiPathGraph = {
|
||
nodes: [{ type: "BatchNanoBananaPro", widgets_values: multiPathValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(multiPathGraph);
|
||
assert.deepEqual(multiPathValues.slice(6, 11), [
|
||
"3个路径", "D:\\one", "D:\\two", "D:\\three", "同序号",
|
||
]);
|
||
assert.deepEqual(multiPathValues.slice(-6), [
|
||
"智能缩放", "WebP", 73, "自然数字", "D:\\output", 7788,
|
||
]);
|
||
migrationExtension.beforeConfigureGraph(multiPathGraph);
|
||
assert.deepEqual(multiPathValues.slice(-6), [
|
||
"智能缩放", "WebP", 73, "自然数字", "D:\\output", 7788,
|
||
]);
|
||
assert.equal(multiPathValues.length, 17);
|
||
|
||
const randomInputGraph = {
|
||
nodes: [
|
||
{ id: 1, type: "TextSource", outputs: [{ links: [91] }] },
|
||
{ id: 2, type: "ImageSource", outputs: [{ links: [92] }] },
|
||
{
|
||
id: 3,
|
||
type: "BatchNanoBananaPro",
|
||
inputs: [
|
||
{ name: "图片路径数量.参考图1（主图）", link: null },
|
||
{ name: "图片路径数量.图片随机抽取", link: 91 },
|
||
{ name: "参考图组.参考图1", link: 92 },
|
||
],
|
||
},
|
||
],
|
||
links: [[91, 1, 0, 3, 1, "STRING"], [92, 2, 0, 3, 2, "IMAGE"]],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(randomInputGraph);
|
||
assert.deepEqual(randomInputGraph.nodes[2].inputs.map(input => input.name), [
|
||
"图片路径数量.参考图1（主图）", "参考图组.参考图1",
|
||
]);
|
||
assert.deepEqual(randomInputGraph.nodes[0].outputs[0].links, []);
|
||
assert.deepEqual(randomInputGraph.nodes[1].outputs[0].links, [92]);
|
||
assert.deepEqual(randomInputGraph.links, [[92, 2, 0, 3, 1, "IMAGE"]]);
|
||
migrationExtension.beforeConfigureGraph(randomInputGraph);
|
||
assert.deepEqual(randomInputGraph.links, [[92, 2, 0, 3, 1, "IMAGE"]]);
|
||
|
||
const legacyGPTValues = [
|
||
"prompt", "gpt-image-2", "畅速", "智能", 1, "自动", "png", 0,
|
||
];
|
||
const legacyGPTGraph = {
|
||
nodes: [{ type: "O1keyGPTImage", widgets_values: legacyGPTValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyGPTGraph);
|
||
assert.deepEqual(
|
||
legacyGPTValues.slice(-3),
|
||
["auto", "智能缩放", 0],
|
||
);
|
||
assert.equal(legacyGPTValues.length, 10);
|
||
migrationExtension.beforeConfigureGraph(legacyGPTGraph);
|
||
assert.equal(legacyGPTValues.length, 10);
|
||
|
||
const legacyGPTWithColorCorrection = [
|
||
"prompt", "gpt-image-2", "畅速", "智能", 1, "自动", "png", 0,
|
||
"不缩放", "智能纠正", "auto", "自动",
|
||
];
|
||
migrationExtension.beforeConfigureGraph({
|
||
nodes: [{ type: "O1keyGPTImage", widgets_values: legacyGPTWithColorCorrection }],
|
||
});
|
||
assert.deepEqual(legacyGPTWithColorCorrection.slice(-3), ["auto", "不缩放", 0]);
|
||
assert.equal(legacyGPTWithColorCorrection.length, 10);
|
||
|
||
const currentGPT25Values = [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "超高", "png",
|
||
"opaque", "智能缩放", 0,
|
||
];
|
||
const currentGPT25Graph = {
|
||
nodes: [{ type: "O1keyGPTImage", widgets_values: currentGPT25Values }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(currentGPT25Graph);
|
||
assert.equal(currentGPT25Values.length, 10);
|
||
assert.deepEqual(currentGPT25Values.slice(-3), ["opaque", "智能缩放", 0]);
|
||
migrationExtension.beforeConfigureGraph(currentGPT25Graph);
|
||
assert.equal(currentGPT25Values.length, 10);
|
||
|
||
const legacyGPT25Values = [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "超高", "png", 0,
|
||
"智能缩放", "transparent", "低",
|
||
];
|
||
const legacyGPT25Graph = {
|
||
nodes: [{ type: "O1keyGPTImage", widgets_values: legacyGPT25Values }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyGPT25Graph);
|
||
assert.equal(legacyGPT25Values.length, 10);
|
||
assert.deepEqual(legacyGPT25Values.slice(-3), ["transparent", "智能缩放", 0]);
|
||
migrationExtension.beforeConfigureGraph(legacyGPT25Graph);
|
||
assert.equal(legacyGPT25Values.length, 10);
|
||
|
||
const legacyGPTBatchValues = [
|
||
"prompt", "gpt-image-2", "畅速", "智能", 1, "自动",
|
||
"1个路径", "D:\\images", "关闭", 3, 0, "原始",
|
||
"和原始图片名保持一致", "",
|
||
];
|
||
const legacyGPTBatchGraph = {
|
||
nodes: [{ type: "O1keyGPTImageBatch", widgets_values: legacyGPTBatchValues }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchGraph);
|
||
assert.deepEqual(
|
||
legacyGPTBatchValues.slice(-6),
|
||
["原始", "auto", "和原始图片名保持一致", "", "智能缩放", 0],
|
||
);
|
||
assert.equal(legacyGPTBatchValues.length, 14);
|
||
assert.equal(legacyGPTBatchValues[8], "原始");
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchGraph);
|
||
assert.equal(legacyGPTBatchValues.length, 14);
|
||
|
||
const legacyGPTBatchWithRemovedControls = [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "最高",
|
||
"1个路径", "D:\\images", "关闭", 3, 123, "PNG",
|
||
"自然数字", "D:\\output", "不缩放", "智能纠正", "transparent", "低",
|
||
];
|
||
const legacyGPTBatchWithRemovedControlsGraph = {
|
||
nodes: [{ type: "O1keyGPTImageBatch", widgets_values: legacyGPTBatchWithRemovedControls }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchWithRemovedControlsGraph);
|
||
assert.deepEqual(
|
||
legacyGPTBatchWithRemovedControls.slice(-6),
|
||
["PNG", "transparent", "自然数字", "D:\\output", "不缩放", 123],
|
||
);
|
||
assert.equal(legacyGPTBatchWithRemovedControls.length, 14);
|
||
assert.equal(legacyGPTBatchWithRemovedControls[8], "PNG");
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchWithRemovedControlsGraph);
|
||
assert.equal(legacyGPTBatchWithRemovedControls.length, 14);
|
||
|
||
const legacyGPTBatchTwoPaths = [
|
||
"prompt", "gpt-image-2.5-flare", "畅速", "智能", 1, "超高",
|
||
"2个路径", "D:\\first", "D:\\second", "相同文件名", "关闭", 4,
|
||
456, "WebP", "和原始图片名保持一致", "D:\\output",
|
||
"智能缩放", "不纠正", "opaque", "自动",
|
||
];
|
||
const legacyGPTBatchTwoPathsGraph = {
|
||
nodes: [{ type: "O1keyGPTImageBatch", widgets_values: legacyGPTBatchTwoPaths }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchTwoPathsGraph);
|
||
assert.deepEqual(
|
||
legacyGPTBatchTwoPaths.slice(-6),
|
||
["WebP", "opaque", "和原始图片名保持一致", "D:\\output", "智能缩放", 456],
|
||
);
|
||
assert.equal(legacyGPTBatchTwoPaths.length, 16);
|
||
assert.equal(legacyGPTBatchTwoPaths[10], "WebP");
|
||
migrationExtension.beforeConfigureGraph(legacyGPTBatchTwoPathsGraph);
|
||
assert.equal(legacyGPTBatchTwoPaths.length, 16);
|
||
|
||
const currentGPTBatchWithRandomSelection = [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "最高",
|
||
"1个路径", "D:\\images", "1", "WebP", "opaque",
|
||
"和原始图片名保持一致", "D:\\output", "智能缩放", 789,
|
||
];
|
||
const currentGPTBatchWithRandomSelectionGraph = {
|
||
nodes: [{
|
||
type: "O1keyGPTImageBatch",
|
||
widgets_values: currentGPTBatchWithRandomSelection,
|
||
}],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(currentGPTBatchWithRandomSelectionGraph);
|
||
assert.equal(currentGPTBatchWithRandomSelection.length, 14);
|
||
assert.equal(currentGPTBatchWithRandomSelection[8], "WebP");
|
||
assert.deepEqual(currentGPTBatchWithRandomSelection.slice(-6), [
|
||
"WebP", "opaque", "和原始图片名保持一致", "D:\\output", "智能缩放", 789,
|
||
]);
|
||
migrationExtension.beforeConfigureGraph(currentGPTBatchWithRandomSelectionGraph);
|
||
assert.equal(currentGPTBatchWithRandomSelection.length, 14);
|
||
|
||
const previousGPTBatchWithRemovedControls = [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "最高",
|
||
"1个路径", "D:\\images", "关闭", 4, "WebP", "opaque",
|
||
"和原始图片名保持一致", "D:\\output", "智能缩放", 789,
|
||
];
|
||
const previousGPTBatchWithRemovedControlsGraph = {
|
||
nodes: [{
|
||
type: "O1keyGPTImageBatch",
|
||
widgets_values: previousGPTBatchWithRemovedControls,
|
||
}],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(previousGPTBatchWithRemovedControlsGraph);
|
||
assert.equal(previousGPTBatchWithRemovedControls.length, 14);
|
||
assert.deepEqual(previousGPTBatchWithRemovedControls.slice(-6), [
|
||
"WebP", "opaque", "和原始图片名保持一致", "D:\\output", "智能缩放", 789,
|
||
]);
|
||
migrationExtension.beforeConfigureGraph(previousGPTBatchWithRemovedControlsGraph);
|
||
assert.equal(previousGPTBatchWithRemovedControls.length, 14);
|
||
|
||
const legacyGPTBatchInputsNode = {
|
||
type: "O1keyGPTImageBatch",
|
||
widgets_values: [
|
||
"prompt", "gpt-image-2.5-sunburst", "畅速", "智能", 1, "自动",
|
||
"2个路径", "D:\\first", "D:\\second", "相同文件名", "原始", "auto",
|
||
"和原始图片名保持一致", "D:\\output", "智能缩放", 789,
|
||
],
|
||
inputs: [
|
||
{ name: "图片随机抽取", link: null },
|
||
{ name: "文件夹1", link: null },
|
||
{ name: "文件夹2", link: null },
|
||
{ name: "图片配对模式", link: null },
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [legacyGPTBatchInputsNode] });
|
||
assert.deepEqual(legacyGPTBatchInputsNode.inputs.map(input => input.name), [
|
||
"图片路径数量.参考图1（主图）",
|
||
"图片路径数量.参考图2",
|
||
"图片路径数量.图片配对模式",
|
||
]);
|
||
|
||
const removedNanoResolution = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "512", "1:1", "1", 0,
|
||
"不缩放", "不纠正",
|
||
];
|
||
const removedBatchResolution = [
|
||
"prompt", "Nano Banana 2", "畅速", "高", "512px", "1:1",
|
||
"1个路径", "D:\\images", "关闭", 0, "原始", 95,
|
||
"和原始图片名保持一致", "", "不缩放", "不纠正",
|
||
];
|
||
const removedResolutionGraph = {
|
||
nodes: [
|
||
{ type: "NanoBanana", widgets_values: removedNanoResolution },
|
||
{ type: "BatchNanoBananaPro", widgets_values: removedBatchResolution },
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(removedResolutionGraph);
|
||
assert.equal(removedNanoResolution[4], "1K");
|
||
assert.equal(removedBatchResolution[4], "1K");
|
||
migrationExtension.beforeConfigureGraph(removedResolutionGraph);
|
||
assert.equal(removedNanoResolution[4], "1K");
|
||
assert.equal(removedBatchResolution[4], "1K");
|
||
|
||
const legacyGrokValues = [
|
||
"continue the camera move", "CF加速", "grok-imagine-1.0-video",
|
||
"16:9", 20, "720p",
|
||
];
|
||
const legacyGrokNode = {
|
||
type: "O1keyGrokVideo",
|
||
widgets_values: legacyGrokValues,
|
||
inputs: [{ name: "参考图1", link: 42 }, { name: "参考图2", link: null }],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [legacyGrokNode] });
|
||
assert.deepEqual(legacyGrokValues, [
|
||
"参考生视频", "continue the camera move", "grok-imagine-video",
|
||
15, "16:9", "720p", "",
|
||
]);
|
||
assert.deepEqual(
|
||
legacyGrokNode.inputs.map(input => input.name),
|
||
["图片1", "图片2"],
|
||
);
|
||
migrationExtension.beforeConfigureGraph({ nodes: [legacyGrokNode] });
|
||
assert.equal(legacyGrokValues.length, 7);
|
||
|
||
const interimGrokValues = [
|
||
"文生视频", "prompt", "grok-imagine-video-1.5", 8, "16:9", "480p",
|
||
];
|
||
const interimGrokEditValues = ["编辑视频", "make it golden", 6];
|
||
const interimGrokGraph = {
|
||
nodes: [
|
||
{ type: "O1keyGrokVideo", widgets_values: interimGrokValues },
|
||
{ type: "O1keyGrokVideoEdit", widgets_values: interimGrokEditValues },
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph(interimGrokGraph);
|
||
assert.equal(interimGrokValues[6], "");
|
||
assert.equal(interimGrokEditValues[3], "grok-imagine-video-1.5");
|
||
migrationExtension.beforeConfigureGraph(interimGrokGraph);
|
||
assert.equal(interimGrokValues.length, 7);
|
||
assert.equal(interimGrokEditValues.length, 4);
|
||
}
|
||
|
||
{
|
||
let qualityExtension;
|
||
const context = {
|
||
app: { registerExtension(extension) { qualityExtension = extension; } },
|
||
requestAnimationFrame(callback) { callback(); },
|
||
};
|
||
vm.runInNewContext(
|
||
batchNanoQualitySource.replace(/^import .*;\s*$/gm, ""),
|
||
context,
|
||
);
|
||
|
||
const formatWidget = { name: "图片输出格式", value: "JPEG", options: {} };
|
||
const qualityWidget = { name: "图片质量", value: "95", options: {} };
|
||
const node = {
|
||
comfyClass: "BatchNanoBananaPro",
|
||
widgets: [formatWidget, qualityWidget],
|
||
setDirtyCanvas() {},
|
||
};
|
||
qualityExtension.nodeCreated(node);
|
||
assert.equal(qualityWidget.value, 95);
|
||
assert.equal(typeof qualityWidget.value, "number");
|
||
assert.equal(qualityWidget.hidden, false);
|
||
}
|
||
|
||
{
|
||
let minimaxExtension;
|
||
const notices = [];
|
||
const context = {
|
||
app: {
|
||
registerExtension(extension) { minimaxExtension = extension; },
|
||
extensionManager: { toast: { add(notice) { notices.push(notice); } } },
|
||
},
|
||
};
|
||
vm.runInNewContext(
|
||
minimaxH3ParameterGuardSource.replace(/^import .*;\s*$/gm, ""),
|
||
context,
|
||
);
|
||
|
||
const callbacks = [];
|
||
const widget = (name, value) => ({
|
||
name,
|
||
value,
|
||
options: {},
|
||
callback(nextValue) { callbacks.push([name, nextValue]); },
|
||
});
|
||
const model = widget("模型", "MiniMax-H3");
|
||
const mode = widget("生成模式", "参考素材生视频");
|
||
const resolution = widget("分辨率", "2K");
|
||
const duration = widget("时长", 4);
|
||
const node = {
|
||
comfyClass: "MiniMaxH3Video",
|
||
widgets: [mode, resolution, duration, model],
|
||
setDirtyCanvas() {},
|
||
};
|
||
|
||
minimaxExtension.nodeCreated(node);
|
||
model.value = "MiniMax-H3-MAX";
|
||
model.callback(model.value);
|
||
assert.deepEqual(Array.from(resolution.options.values), ["768P", "480P"]);
|
||
assert.equal(resolution.value, "768P");
|
||
assert.equal(duration.options.min, 5);
|
||
assert.equal(duration.value, 5);
|
||
assert.equal(mode.value, "文生视频");
|
||
|
||
mode.value = "参考素材生视频";
|
||
mode.callback(mode.value);
|
||
assert.equal(mode.value, "文生视频");
|
||
assert.ok(notices.length >= 1);
|
||
assert.ok(callbacks.some(([name, value]) => name === "生成模式" && value === "文生视频"));
|
||
}
|
||
|
||
{
|
||
let routeLabelsExtension;
|
||
const routeLabelsContext = {
|
||
app: { registerExtension(extension) { routeLabelsExtension = extension; } },
|
||
};
|
||
vm.runInNewContext(
|
||
nanoRouteLabelsSource.replace(/^import .*;\s*$/gm, ""),
|
||
routeLabelsContext,
|
||
);
|
||
|
||
for (const comfyClass of [
|
||
"NanoBanana",
|
||
"BatchNanoBananaPro",
|
||
"O1keyGPTImage",
|
||
"O1keyGPTImageBatch",
|
||
]) {
|
||
const routeWidget = {
|
||
name: "模型线路",
|
||
value: "畅速",
|
||
options: { values: ["畅速", "直连", "专线"] },
|
||
};
|
||
const node = {
|
||
comfyClass,
|
||
widgets: [routeWidget],
|
||
setDirtyCanvas() {},
|
||
};
|
||
routeLabelsExtension.nodeCreated(node);
|
||
const getOptionLabel = routeWidget.options.getOptionLabel;
|
||
assert.equal(getOptionLabel("畅速"), "特价");
|
||
assert.equal(getOptionLabel("直连"), "优质");
|
||
assert.equal(getOptionLabel("专线"), "企业");
|
||
assert.equal(getOptionLabel("未知线路"), "未知线路");
|
||
assert.equal(routeWidget.value, "畅速");
|
||
assert.deepEqual(routeWidget.options.values, ["畅速", "直连", "专线"]);
|
||
routeLabelsExtension.loadedGraphNode(node);
|
||
assert.equal(routeWidget.options.getOptionLabel, getOptionLabel);
|
||
}
|
||
}
|
||
|
||
{
|
||
let dynamicExtension;
|
||
const dynamicContext = {
|
||
app: {
|
||
registerExtension(extension) { dynamicExtension = extension; },
|
||
extensionManager: { toast: { add() {} } },
|
||
},
|
||
console,
|
||
};
|
||
vm.runInNewContext(
|
||
seedanceAutoPassDynamicSource.replace(/^import .*;\s*$/gm, ""),
|
||
dynamicContext,
|
||
);
|
||
|
||
const modelWidget = { name: "主模型", value: "seedance 2.5", options: {} };
|
||
const routeWidget = { name: "模型线路", value: "海外HC", options: {} };
|
||
const resolutionWidget = { name: "分辨率", value: "4k", options: {} };
|
||
const durationWidget = { name: "时长", value: "30秒", options: {} };
|
||
const node = {
|
||
comfyClass: "SeedanceAutoPass",
|
||
widgets: [modelWidget, routeWidget, resolutionWidget, durationWidget],
|
||
setDirtyCanvas() {},
|
||
};
|
||
dynamicExtension.nodeCreated(node);
|
||
|
||
assert.deepEqual(Array.from(resolutionWidget.options.values), ["480p", "720p", "1080p", "4k"]);
|
||
assert.equal(routeWidget.value, "海外");
|
||
assert.equal(resolutionWidget.value, "4k");
|
||
assert.equal(durationWidget.options.values.at(-1), "30秒");
|
||
|
||
routeWidget.value = "国内";
|
||
modelWidget.callback(modelWidget.value);
|
||
assert.equal(routeWidget.value, "国内");
|
||
|
||
modelWidget.value = "seedance 2.0 fast";
|
||
modelWidget.callback(modelWidget.value);
|
||
assert.deepEqual(Array.from(resolutionWidget.options.values), ["480p", "720p"]);
|
||
assert.equal(resolutionWidget.value, "720p");
|
||
assert.equal(durationWidget.value, "15秒");
|
||
}
|
||
|
||
{
|
||
let guardExtension;
|
||
const guardContext = {
|
||
app: {
|
||
registerExtension(extension) { guardExtension = extension; },
|
||
extensionManager: { toast: { add() {} } },
|
||
},
|
||
console,
|
||
};
|
||
vm.runInNewContext(
|
||
seedanceResolutionGuardSource.replace(/^import .*;\s*$/gm, ""),
|
||
guardContext,
|
||
);
|
||
|
||
const modelWidget = { name: "主模型", value: "seedance 2.5", options: {} };
|
||
const resolutionWidget = { name: "分辨率", value: "4k", options: {} };
|
||
const durationWidget = { name: "时长", value: "30秒", options: {} };
|
||
const node = {
|
||
comfyClass: "SeedanceMultiModal",
|
||
widgets: [modelWidget, resolutionWidget, durationWidget],
|
||
setDirtyCanvas() {},
|
||
};
|
||
guardExtension.nodeCreated(node);
|
||
|
||
assert.deepEqual(Array.from(resolutionWidget.options.values), ["720p", "1080p", "4k", "480p"]);
|
||
assert.equal(resolutionWidget.value, "4k");
|
||
assert.equal(durationWidget.options.values.at(-1), "30秒");
|
||
|
||
modelWidget.value = "seedance 2.0 fast";
|
||
modelWidget.callback(modelWidget.value);
|
||
assert.deepEqual(Array.from(resolutionWidget.options.values), ["720p", "480p"]);
|
||
assert.equal(resolutionWidget.value, "720p");
|
||
assert.equal(durationWidget.value, "15秒");
|
||
|
||
guardExtension.loadedGraphNode(node);
|
||
assert.equal(node.__o1keySeedanceParameterGuard, true);
|
||
}
|
||
|
||
{
|
||
let dynamicExtension;
|
||
const dynamicContext = {
|
||
app: { registerExtension(extension) { dynamicExtension = extension; } },
|
||
console,
|
||
};
|
||
vm.runInNewContext(
|
||
seedanceMultiModalDynamicSource.replace(/^import .*;\s*$/gm, ""),
|
||
dynamicContext,
|
||
);
|
||
|
||
let originalCallbackCount = 0;
|
||
let dirtyCount = 0;
|
||
let resizeCount = 0;
|
||
const widgets = [];
|
||
for (const [prefix, maximum] of [["图片素材ID", 30], ["视频素材ID", 10], ["音频素材ID", 10]]) {
|
||
for (let index = 1; index <= maximum; index++) {
|
||
widgets.push({
|
||
name: `${prefix}${index}`,
|
||
value: "",
|
||
options: {},
|
||
callback() { originalCallbackCount++; },
|
||
});
|
||
}
|
||
}
|
||
const node = {
|
||
comfyClass: "SeedanceMultiModal",
|
||
widgets,
|
||
size: [320, 1400],
|
||
computeSize() {
|
||
const visibleWidgetCount = this.widgets.filter(widget => !widget.hidden).length;
|
||
return [480, 100 + visibleWidgetCount * 24];
|
||
},
|
||
setSize(size) {
|
||
resizeCount++;
|
||
this.size = size;
|
||
},
|
||
setDirtyCanvas() { dirtyCount++; },
|
||
};
|
||
dynamicExtension.nodeCreated(node);
|
||
|
||
assert.deepEqual(Array.from(node.size), [320, 172]);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID1").hidden, false);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID2").hidden, true);
|
||
assert.equal(widgets.find(widget => widget.name === "视频素材ID1").hidden, false);
|
||
assert.equal(widgets.find(widget => widget.name === "视频素材ID2").hidden, true);
|
||
|
||
const firstImage = widgets.find(widget => widget.name === "图片素材ID1");
|
||
firstImage.value = "image-1";
|
||
firstImage.callback(firstImage.value);
|
||
assert.equal(originalCallbackCount, 1);
|
||
assert.deepEqual(Array.from(node.size), [320, 196]);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID2").hidden, false);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID3").hidden, true);
|
||
|
||
const fourthImage = widgets.find(widget => widget.name === "图片素材ID4");
|
||
fourthImage.value = "legacy-image-4";
|
||
dynamicExtension.loadedGraphNode(node);
|
||
assert.deepEqual(Array.from(node.size), [320, 268]);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID5").hidden, false);
|
||
assert.equal(widgets.find(widget => widget.name === "图片素材ID6").hidden, true);
|
||
|
||
dynamicExtension.nodeCreated(node);
|
||
firstImage.callback(firstImage.value);
|
||
assert.equal(originalCallbackCount, 2);
|
||
assert.equal(resizeCount, 4);
|
||
assert.ok(dirtyCount >= 3);
|
||
}
|
||
|
||
{
|
||
let migrationExtension;
|
||
vm.runInNewContext(
|
||
migrationSource.replace(/^import .*;\s*$/gm, ""),
|
||
{
|
||
app: { registerExtension(extension) { migrationExtension = extension; } },
|
||
console: { log() {}, warn() {} },
|
||
},
|
||
);
|
||
const node = {
|
||
type: "SeedanceMultiModal",
|
||
inputs: [
|
||
{ name: "参考图片1" },
|
||
{ name: "参考视频2" },
|
||
{ name: "参考音频.参考音频1" },
|
||
{ name: "真人素材ID1" },
|
||
],
|
||
widgets_values: [],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [node] });
|
||
assert.equal(node.inputs[0].name, "参考图片.参考图片1");
|
||
assert.equal(node.inputs[1].name, "参考视频.参考视频2");
|
||
assert.equal(node.inputs[2].name, "参考音频.参考音频1");
|
||
assert.equal(node.inputs[3].name, "图片素材ID1");
|
||
migrationExtension.beforeConfigureGraph({ nodes: [node] });
|
||
assert.equal(node.inputs[0].name, "参考图片.参考图片1");
|
||
assert.equal(node.inputs[1].name, "参考视频.参考视频2");
|
||
assert.equal(node.inputs[3].name, "图片素材ID1");
|
||
|
||
const elementNode = {
|
||
type: "SeedanceElementCreate",
|
||
inputs: [
|
||
{ name: "真人照片" },
|
||
{ name: "真人视频" },
|
||
{ name: "真人音频" },
|
||
{ name: "素材描述" },
|
||
],
|
||
widgets_values: [],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [elementNode] });
|
||
assert.deepEqual(
|
||
Array.from(elementNode.inputs, input => input.name),
|
||
["照片", "视频", "音频", "素材描述"],
|
||
);
|
||
migrationExtension.beforeConfigureGraph({ nodes: [elementNode] });
|
||
assert.deepEqual(
|
||
Array.from(elementNode.inputs, input => input.name),
|
||
["照片", "视频", "音频", "素材描述"],
|
||
);
|
||
|
||
const autoPassNode = {
|
||
type: "SeedanceAutoPass",
|
||
inputs: [],
|
||
widgets_values: [
|
||
"提示词", "多模态参考生视频", "关闭", "seedance 2.5", "国内",
|
||
"720p", "智能", "5秒", "关闭", 0,
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [autoPassNode] });
|
||
assert.deepEqual(
|
||
Array.from(autoPassNode.widgets_values),
|
||
[
|
||
"提示词", "多模态", "seedance 2.5", "国内",
|
||
"720p", "智能", "5秒", "关闭", "关闭", ...Array(50).fill(""), "关闭", 0, "关闭",
|
||
],
|
||
);
|
||
migrationExtension.beforeConfigureGraph({ nodes: [autoPassNode] });
|
||
assert.equal(autoPassNode.widgets_values.length, 62);
|
||
|
||
const legacyFrameNode = {
|
||
type: "SeedanceAutoPass",
|
||
inputs: [
|
||
{ name: "生成模式.联网搜索" },
|
||
{ name: "生成模式.首帧图片" },
|
||
],
|
||
widgets_values: [
|
||
"提示词", "图生视频-首帧", "打开", "seedance 2.0", "海外HC",
|
||
"720p", "16:9", "5秒", "关闭", 9, "打开",
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({ nodes: [legacyFrameNode] });
|
||
assert.deepEqual(
|
||
Array.from(legacyFrameNode.widgets_values),
|
||
[
|
||
"提示词", "首尾帧", "seedance 2.0", "海外",
|
||
"720p", "16:9", "5秒", "关闭", "关闭", ...Array(50).fill(""), "打开", 9, "打开",
|
||
],
|
||
);
|
||
assert.deepEqual(
|
||
Array.from(legacyFrameNode.inputs, input => input.name),
|
||
["联网搜索", "首帧图片"],
|
||
);
|
||
migrationExtension.beforeConfigureGraph({ nodes: [legacyFrameNode] });
|
||
assert.equal(legacyFrameNode.widgets_values.length, 62);
|
||
|
||
const legacyIdNode = {
|
||
type: "SeedanceAutoPass",
|
||
inputs: [{name: "图片素材ID"}, {name: "素材创建.视频素材ID"}, {name: "素材创建"}],
|
||
widgets_values: [
|
||
"提示词", "多模态", "seedance 2.5", "国内", "720p", "智能", "5秒", "关闭",
|
||
"手动", "image-1，image-2\nasset://image-3", "video-1;video-2", "audio-1", "打开", 42, "打开",
|
||
],
|
||
};
|
||
migrationExtension.beforeConfigureGraph({nodes: [legacyIdNode]});
|
||
assert.equal(legacyIdNode.widgets_values.length, 62);
|
||
assert.equal(legacyIdNode.widgets_values[8], "打开");
|
||
assert.deepEqual(legacyIdNode.widgets_values.slice(9, 12), ["image-1", "image-2", "asset://image-3"]);
|
||
assert.deepEqual(legacyIdNode.widgets_values.slice(39, 41), ["video-1", "video-2"]);
|
||
assert.equal(legacyIdNode.widgets_values[49], "audio-1");
|
||
assert.deepEqual(legacyIdNode.widgets_values.slice(59), ["打开", 42, "打开"]);
|
||
assert.deepEqual(legacyIdNode.inputs.map(input => input.name), ["图片素材ID1", "视频素材ID1", "素材创建模式"]);
|
||
const migratedIds = [...legacyIdNode.widgets_values];
|
||
migrationExtension.beforeConfigureGraph({nodes: [legacyIdNode]});
|
||
assert.deepEqual(legacyIdNode.widgets_values, migratedIds);
|
||
}
|
||
|
||
{
|
||
let extension;
|
||
vm.runInNewContext(seedanceAutoPassDynamicSource.replace(/^import .*;\s*$/gm, ""), {
|
||
app: {registerExtension(value) {extension = value;}}, console,
|
||
});
|
||
let callbacks = 0;
|
||
const assetMode = {name: "素材创建模式", value: "关闭", options: {}, callback() {callbacks++;}};
|
||
const ids = [];
|
||
for (const [prefix, maximum] of [["图片素材ID", 30], ["视频素材ID", 10], ["音频素材ID", 10]]) {
|
||
for (let index = 1; index <= maximum; index++) ids.push({
|
||
name: `${prefix}${index}`, value: "", options: {}, callback() {callbacks++;},
|
||
});
|
||
}
|
||
const node = {
|
||
comfyClass: "SeedanceAutoPass", widgets: [assetMode, ...ids], size: [360, 1500],
|
||
computeSize() {return [480, 100 + this.widgets.filter(widget => !widget.hidden).length * 24];},
|
||
setSize(size) {this.size = size;}, setDirtyCanvas() {},
|
||
};
|
||
extension.nodeCreated(node);
|
||
assert.ok(ids.every(widget => widget.hidden && widget.options.hidden));
|
||
assert.equal(assetMode.hidden, false);
|
||
assert.equal(assetMode.options.hidden, false);
|
||
assert.deepEqual(Array.from(node.size), [360, 124]);
|
||
assetMode.value = "打开";
|
||
assetMode.callback(assetMode.value);
|
||
assert.deepEqual(ids.filter(widget => !widget.hidden).map(widget => widget.name), [
|
||
"图片素材ID1", "视频素材ID1", "音频素材ID1",
|
||
]);
|
||
ids[0].value = "image-1";
|
||
ids[0].callback(ids[0].value);
|
||
assert.equal(ids[1].hidden, false);
|
||
assert.equal(ids[2].hidden, true);
|
||
assetMode.value = "关闭";
|
||
assetMode.callback(assetMode.value);
|
||
assert.ok(ids.every(widget => widget.hidden));
|
||
assert.equal(ids[0].value, "image-1");
|
||
assetMode.value = "打开";
|
||
ids[3].value = "saved-image-4";
|
||
extension.loadedGraphNode(node);
|
||
assert.equal(ids[4].hidden, false);
|
||
assert.equal(ids[5].hidden, true);
|
||
extension.nodeCreated(node);
|
||
ids[0].callback(ids[0].value);
|
||
assert.equal(callbacks, 4);
|
||
assert.deepEqual(node.widgets.map(widget => widget.name), [assetMode, ...ids].map(widget => widget.name));
|
||
}
|
||
|
||
{
|
||
let extension;
|
||
vm.runInNewContext(seedanceAutoPassDynamicSource.replace(/^import .*;\s*$/gm, ""), {
|
||
app: {registerExtension(value) {extension = value;}}, console,
|
||
});
|
||
const groups = ["参考图片", "参考视频", "参考音频"];
|
||
const configs = Object.fromEntries(groups.map(group => [group, {names: [`${group}1`, `${group}2`], min: 0}]));
|
||
let modeCallbacks = 0;
|
||
let connectionCallbacks = 0;
|
||
const removedLinks = [];
|
||
const mode = {name: "生成模式", value: "多模态", callback() {modeCallbacks++;}};
|
||
const node = {
|
||
comfyClass: "SeedanceAutoPass", widgets: [mode],
|
||
comfyDynamic: {autogrow: {...configs}},
|
||
inputs: [
|
||
...groups.map((group, index) => ({name: `${group}.${group}1`, type: ["IMAGE", "VIDEO", "AUDIO"][index], label: `${group}1`, shape: 7, link: null})),
|
||
{name: "首帧图片", type: "IMAGE", shape: 7, link: null},
|
||
{name: "尾帧图片", type: "IMAGE", shape: 7, link: null},
|
||
{name: "提示词", type: "STRING", link: 99},
|
||
],
|
||
addInput(name, type, options) {this.inputs.push({name, type, ...options, link: null});},
|
||
removeInput(index) {
|
||
const input = this.inputs[index];
|
||
if (input.link != null) {
|
||
removedLinks.push(input.link);
|
||
this.onConnectionsChange(1, index, false);
|
||
}
|
||
this.inputs.splice(index, 1);
|
||
},
|
||
onConnectionsChange(type, index, connected) {
|
||
connectionCallbacks++;
|
||
const group = this.inputs[index]?.name.split(".")[0];
|
||
if (connected && this.comfyDynamic.autogrow[group]) {
|
||
this.addInput(`${group}.${group}2`, this.inputs[index].type, {label: `${group}2`, shape: 7});
|
||
}
|
||
},
|
||
setDirtyCanvas() {},
|
||
};
|
||
const names = () => node.inputs.map(input => input.name);
|
||
extension.nodeCreated(node);
|
||
assert.deepEqual(names(), [...groups.map(group => `${group}.${group}1`), "提示词"]);
|
||
node.inputs[0].link = 10;
|
||
node.onConnectionsChange(1, 0, true);
|
||
assert.ok(names().includes("参考图片.参考图片2"));
|
||
const callbacksBeforeSwitch = connectionCallbacks;
|
||
mode.value = "首尾帧";
|
||
mode.callback(mode.value);
|
||
assert.deepEqual(names(), ["提示词", "首帧图片", "尾帧图片"]);
|
||
assert.deepEqual(removedLinks, [10]);
|
||
assert.equal(connectionCallbacks, callbacksBeforeSwitch, "mode removals must not schedule native Autogrow callbacks");
|
||
assert.deepEqual(Object.keys(node.comfyDynamic.autogrow), []);
|
||
assert.equal(node.inputs[0].link, 99, "unrelated converted widget inputs retain links");
|
||
node.inputs.find(input => input.name === "首帧图片").link = 20;
|
||
// Loading an older frame workflow may restore every schema socket.
|
||
node.addInput("参考视频.参考视频1", "VIDEO", {label: "参考视频1"});
|
||
extension.loadedGraphNode(node);
|
||
assert.deepEqual(names(), ["提示词", "首帧图片", "尾帧图片"]);
|
||
assert.equal(node.inputs.find(input => input.name === "首帧图片").link, 20);
|
||
extension.nodeCreated(node);
|
||
extension.loadedGraphNode(node);
|
||
mode.value = "多模态";
|
||
mode.callback(mode.value);
|
||
assert.deepEqual(names(), ["提示词", ...groups.map(group => `${group}.${group}1`)]);
|
||
assert.deepEqual(removedLinks, [10, 20]);
|
||
assert.equal(modeCallbacks, 2, "repeated hooks do not duplicate mode callbacks");
|
||
for (const group of groups) assert.equal(node.comfyDynamic.autogrow[group], configs[group]);
|
||
const imageIndex = node.inputs.findIndex(input => input.name === "参考图片.参考图片1");
|
||
assert.equal(node.inputs[imageIndex].shape, 7);
|
||
node.onConnectionsChange(1, imageIndex, true);
|
||
assert.ok(names().includes("参考图片.参考图片2"), "native progressive references resume after switching back");
|
||
mode.value = "首尾帧";
|
||
mode.callback(mode.value);
|
||
assert.deepEqual(names(), ["提示词", "首帧图片", "尾帧图片"]);
|
||
}
|
||
|
||
{
|
||
let extension;
|
||
vm.runInNewContext(seedanceAutoPassDynamicSource.replace(/^import .*;\s*$/gm, ""), {
|
||
app: {registerExtension(value) {extension = value;}}, console,
|
||
});
|
||
const assetMode = {name: "素材创建模式", value: "关闭", options: {}};
|
||
const search = {name: "联网搜索", value: "打开", options: {}, computeSize() {return [100, 24];}};
|
||
const seed = {name: "seed", value: 42, options: {}};
|
||
const lastFrame = {name: "返回末帧图片", value: "打开", options: {}};
|
||
const widgets = [assetMode, search, seed, lastFrame];
|
||
const node = {
|
||
comfyClass: "SeedanceAutoPass", widgets, size: [360, 500],
|
||
computeSize() {return [480, 100 + this.widgets.filter(widget => !widget.hidden).length * 24];},
|
||
setSize(value) {this.size = value;}, setDirtyCanvas() {},
|
||
};
|
||
extension.nodeCreated(node);
|
||
for (const widget of [search, lastFrame]) {
|
||
assert.equal(widget.hidden, true);
|
||
assert.equal(widget.options.hidden, true);
|
||
assert.deepEqual(Array.from(widget.computeSize()), [0, -4]);
|
||
assert.equal(widget.value, "打开", "hiding must preserve saved workflow values");
|
||
}
|
||
assert.deepEqual(Array.from(node.size), [360, 148]);
|
||
assert.equal(assetMode.hidden, false);
|
||
assert.notEqual(seed.hidden, true);
|
||
assert.equal(seed.value, 42);
|
||
// Graph configuration may reset visibility flags; loading reapplies them.
|
||
search.hidden = false;
|
||
search.options.hidden = false;
|
||
lastFrame.hidden = false;
|
||
lastFrame.options.hidden = false;
|
||
extension.loadedGraphNode(node);
|
||
assetMode.value = "打开";
|
||
assetMode.callback(assetMode.value);
|
||
assert.ok(search.hidden && lastFrame.hidden);
|
||
assert.deepEqual(node.widgets, widgets);
|
||
assert.deepEqual(node.widgets.map(widget => widget.value), ["打开", "打开", 42, "打开"]);
|
||
const otherWidgets = [{name: "联网搜索", value: "关闭", options: {}}, {name: "返回末帧图片", value: "关闭", options: {}}];
|
||
extension.nodeCreated({comfyClass: "SeedanceAutoPassBatch", widgets: otherWidgets});
|
||
assert.ok(otherWidgets.every(widget => !widget.hidden), "hide only the single all-in-one node");
|
||
}
|
||
|
||
console.log("o1key image generator frontend tests passed");
|