393 lines
11 KiB
JavaScript
393 lines
11 KiB
JavaScript
const WEIGHT_EXTENSION = /\.(?:safetensors|ckpt|pt|pth|bin)$/i;
|
|
const LORA_SYNTAX = /<lora:([^:>]+)(?::[^>]*)?>/gi;
|
|
const DISABLED_VALUES = new Set([
|
|
"",
|
|
"none",
|
|
"null",
|
|
"disabled",
|
|
"select a lora",
|
|
"select lora",
|
|
]);
|
|
|
|
export function cleanLoraName(value) {
|
|
if (typeof value !== "string") return "";
|
|
|
|
const trimmed = value.trim().replace(/^["']|["']$/g, "");
|
|
const exactSyntax = /^<lora:([^:>]+)(?::[^>]*)?>$/i.exec(trimmed);
|
|
const name = (exactSyntax?.[1] || trimmed)
|
|
.replace(/\\/g, "/")
|
|
.replace(/\/{2,}/g, "/")
|
|
.replace(/^\.\//, "")
|
|
.trim();
|
|
|
|
if (DISABLED_VALUES.has(name.toLowerCase())) return "";
|
|
return name;
|
|
}
|
|
|
|
export function normalizeLoraIdentifier(value) {
|
|
return cleanLoraName(value)
|
|
.replace(WEIGHT_EXTENSION, "")
|
|
.replace(/^\/+|\/+$/g, "")
|
|
.toLowerCase();
|
|
}
|
|
|
|
export function loraSearchTerm(value) {
|
|
const clean = cleanLoraName(value);
|
|
const basename = clean.replace(/\\/g, "/").split("/").pop() || clean;
|
|
return basename.replace(WEIGHT_EXTENSION, "").trim();
|
|
}
|
|
|
|
function formatUsageTipLabel(value) {
|
|
return String(value)
|
|
.replace(/([a-z0-9])([A-Z])/g, "$1 $2")
|
|
.replace(/[_-]+/g, " ")
|
|
.replace(/^./, (letter) => letter.toUpperCase());
|
|
}
|
|
|
|
function formatUsageTipValue(value) {
|
|
if (value == null) return "";
|
|
if (typeof value === "object") {
|
|
try {
|
|
return JSON.stringify(value);
|
|
} catch {
|
|
return String(value);
|
|
}
|
|
}
|
|
return String(value);
|
|
}
|
|
|
|
export function normalizeUsageTips(value) {
|
|
let parsed = value;
|
|
if (typeof value === "string") {
|
|
const text = value.trim();
|
|
if (!text || text === "{}" || text === "[]" || text === "null") return [];
|
|
try {
|
|
parsed = JSON.parse(text);
|
|
} catch {
|
|
return [{ label: "Note", value: text }];
|
|
}
|
|
}
|
|
|
|
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
|
|
return Object.entries(parsed)
|
|
.map(([key, entry]) => ({
|
|
label: formatUsageTipLabel(key),
|
|
value: formatUsageTipValue(entry),
|
|
}))
|
|
.filter((entry) => entry.value !== "");
|
|
}
|
|
|
|
export function extractLoraSyntax(value) {
|
|
if (typeof value !== "string") return [];
|
|
const names = [];
|
|
LORA_SYNTAX.lastIndex = 0;
|
|
for (const match of value.matchAll(LORA_SYNTAX)) {
|
|
const name = cleanLoraName(match[1]);
|
|
if (name) names.push(name);
|
|
}
|
|
return names;
|
|
}
|
|
|
|
function isEnabledEntry(entry) {
|
|
if (!entry || typeof entry !== "object") return true;
|
|
return entry.active !== false && entry.enabled !== false && entry.on !== false;
|
|
}
|
|
|
|
function collectStructuredNames(value, output, allowObjectKeys = false) {
|
|
if (typeof value === "string") {
|
|
const syntaxNames = extractLoraSyntax(value);
|
|
if (syntaxNames.length) {
|
|
output.push(...syntaxNames);
|
|
} else {
|
|
const name = cleanLoraName(value);
|
|
if (name) output.push(name);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (Array.isArray(value)) {
|
|
value.forEach((entry) => collectStructuredNames(entry, output, true));
|
|
return;
|
|
}
|
|
|
|
if (!value || typeof value !== "object" || !isEnabledEntry(value)) return;
|
|
|
|
const namedValue =
|
|
value.name ??
|
|
value.lora_name ??
|
|
value.loraName ??
|
|
value.lora ??
|
|
value.path ??
|
|
value.file;
|
|
if (typeof namedValue === "string") {
|
|
collectStructuredNames(namedValue, output);
|
|
return;
|
|
}
|
|
|
|
const nested = value.loras ?? value.items ?? value.values;
|
|
if (Array.isArray(nested) || (nested && typeof nested === "object")) {
|
|
collectStructuredNames(nested, output, true);
|
|
}
|
|
|
|
if (!allowObjectKeys) return;
|
|
for (const [key, entry] of Object.entries(value)) {
|
|
if (WEIGHT_EXTENSION.test(key) && entry !== false && entry !== 0) {
|
|
collectStructuredNames(key, output);
|
|
}
|
|
if (!entry || typeof entry !== "object" || !isEnabledEntry(entry)) continue;
|
|
const entryName =
|
|
entry.name ??
|
|
entry.lora_name ??
|
|
entry.loraName ??
|
|
entry.lora ??
|
|
entry.path ??
|
|
entry.file;
|
|
if (typeof entryName === "string") {
|
|
collectStructuredNames(entryName, output);
|
|
} else if (WEIGHT_EXTENSION.test(key)) {
|
|
collectStructuredNames(key, output);
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalizeWidgetName(name) {
|
|
return String(name || "")
|
|
.trim()
|
|
.toLowerCase()
|
|
.replace(/[\s-]+/g, "_");
|
|
}
|
|
|
|
function loraSlotIndex(name) {
|
|
const normalized = normalizeWidgetName(name);
|
|
const patterns = [
|
|
/^lora_?(\d+)(?:_(?:name|path|file|text))?$/,
|
|
/^lora_(?:name|path|file)(?:_text)?_?(\d+)$/,
|
|
];
|
|
for (const pattern of patterns) {
|
|
const match = pattern.exec(normalized);
|
|
if (match) return String(Number(match[1]));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function isLoraSelectorName(name) {
|
|
const normalized = normalizeWidgetName(name);
|
|
return (
|
|
/^(?:lora|loras|lora_name|lora_path|lora_file)$/.test(normalized) ||
|
|
loraSlotIndex(normalized) !== null ||
|
|
/^lora.*_(?:name|path|file)$/.test(normalized)
|
|
);
|
|
}
|
|
|
|
function isFalseLike(value) {
|
|
return (
|
|
value === false ||
|
|
value === 0 ||
|
|
["0", "false", "off", "disabled", "no"].includes(
|
|
String(value || "").trim().toLowerCase()
|
|
)
|
|
);
|
|
}
|
|
|
|
function isLoraSlotEnabled(widgetName, widgetsByName) {
|
|
const slot = loraSlotIndex(widgetName);
|
|
if (slot === null) return true;
|
|
const companionNames = [
|
|
`enabled_${slot}`,
|
|
`enable_${slot}`,
|
|
`lora_enabled_${slot}`,
|
|
`lora_${slot}_enabled`,
|
|
];
|
|
for (const name of companionNames) {
|
|
if (widgetsByName.has(name)) {
|
|
return !isFalseLike(widgetsByName.get(name)?.value);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function shouldReadLoraSlot(widgetName, widgetsByName) {
|
|
const slot = loraSlotIndex(widgetName);
|
|
if (slot === null) return true;
|
|
|
|
const count = Number(widgetsByName.get("lora_count")?.value);
|
|
if (Number.isFinite(count) && Number(slot) > count) return false;
|
|
|
|
const normalized = normalizeWidgetName(widgetName);
|
|
const inputMode = String(widgetsByName.get("input_mode")?.value || "")
|
|
.trim()
|
|
.toLowerCase();
|
|
const isTextSelector = normalized === `lora_name_text_${slot}`;
|
|
const isDropdownSelector = normalized === `lora_name_${slot}`;
|
|
|
|
if (inputMode === "text" && isDropdownSelector) {
|
|
return !widgetsByName.has(`lora_name_text_${slot}`);
|
|
}
|
|
if (inputMode && inputMode !== "text" && isTextSelector) {
|
|
return !widgetsByName.has(`lora_name_${slot}`);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
export function extractLoraNames(node) {
|
|
if (!node || typeof node !== "object") return [];
|
|
|
|
const output = [];
|
|
const descriptor = [
|
|
node.comfyClass,
|
|
node.type,
|
|
node.title,
|
|
node.constructor?.comfyClass,
|
|
]
|
|
.filter(Boolean)
|
|
.join(" ");
|
|
const isLoraNode = /lora/i.test(descriptor);
|
|
|
|
const hasManagerWidget = node.lorasWidget?.value != null;
|
|
if (hasManagerWidget) {
|
|
collectStructuredNames(node.lorasWidget.value, output, true);
|
|
}
|
|
|
|
const widgets = node.widgets || [];
|
|
const widgetsByName = new Map(
|
|
widgets.map((widget) => [normalizeWidgetName(widget?.name), widget])
|
|
);
|
|
|
|
for (const widget of hasManagerWidget ? [] : widgets) {
|
|
const widgetName = String(widget?.name || "");
|
|
const value = widget?.value;
|
|
const slotEnabled =
|
|
shouldReadLoraSlot(widgetName, widgetsByName) &&
|
|
isLoraSlotEnabled(widgetName, widgetsByName);
|
|
const syntaxNames = slotEnabled ? extractLoraSyntax(value) : [];
|
|
if (syntaxNames.length) output.push(...syntaxNames);
|
|
|
|
if (isLoraSelectorName(widgetName)) {
|
|
if (slotEnabled) collectStructuredNames(value, output, true);
|
|
} else if (
|
|
isLoraNode &&
|
|
/^(?:text|lora_syntax|lora_code)$/i.test(widgetName)
|
|
) {
|
|
output.push(...syntaxNames);
|
|
} else if (
|
|
isLoraNode &&
|
|
typeof value === "string" &&
|
|
WEIGHT_EXTENSION.test(cleanLoraName(value))
|
|
) {
|
|
collectStructuredNames(value, output);
|
|
}
|
|
}
|
|
|
|
const seen = new Set();
|
|
return output.filter((value) => {
|
|
const key = normalizeLoraIdentifier(value);
|
|
if (!key || seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
export function getSelectedGraphNodes(canvas) {
|
|
if (!canvas) return [];
|
|
|
|
const selectedItems = canvas.selectedItems;
|
|
if (selectedItems && typeof selectedItems.values === "function") {
|
|
return Array.from(selectedItems.values()).filter(
|
|
(item) => item && (item.widgets || item.comfyClass || item.type)
|
|
);
|
|
}
|
|
|
|
return Object.values(canvas.selected_nodes || {}).filter(Boolean);
|
|
}
|
|
|
|
function aliasesForModel(model) {
|
|
const fileName = cleanLoraName(model?.file_name || "");
|
|
const modelName = cleanLoraName(model?.model_name || "");
|
|
const folder = String(model?.folder || "")
|
|
.replace(/\\/g, "/")
|
|
.replace(/^\/+|\/+$/g, "");
|
|
const relativePath = folder && fileName ? `${folder}/${fileName}` : fileName;
|
|
const filePath = cleanLoraName(model?.file_path || "");
|
|
|
|
return {
|
|
fileName: normalizeLoraIdentifier(fileName),
|
|
modelName: normalizeLoraIdentifier(modelName),
|
|
relativePath: normalizeLoraIdentifier(relativePath),
|
|
filePath: normalizeLoraIdentifier(filePath),
|
|
};
|
|
}
|
|
|
|
function matchScore(query, model) {
|
|
const normalized = normalizeLoraIdentifier(query);
|
|
if (!normalized) return 0;
|
|
|
|
const basename = normalized.split("/").pop();
|
|
const hasPath = normalized.includes("/");
|
|
const aliases = aliasesForModel(model);
|
|
|
|
if (hasPath) {
|
|
if (aliases.relativePath === normalized) return 100;
|
|
if (
|
|
aliases.filePath === normalized ||
|
|
aliases.filePath.endsWith(`/${normalized}`)
|
|
) {
|
|
return 95;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (aliases.fileName.split("/").pop() === basename) return 90;
|
|
if (aliases.modelName === normalized) return 85;
|
|
return 0;
|
|
}
|
|
|
|
export function matchModelItems(query, items) {
|
|
let bestScore = 0;
|
|
let candidates = [];
|
|
|
|
for (const item of Array.isArray(items) ? items : []) {
|
|
const score = matchScore(query, item);
|
|
if (!score) continue;
|
|
if (score > bestScore) {
|
|
bestScore = score;
|
|
candidates = [item];
|
|
} else if (score === bestScore) {
|
|
candidates.push(item);
|
|
}
|
|
}
|
|
|
|
return {
|
|
found: candidates.length === 1,
|
|
ambiguous: candidates.length > 1,
|
|
model: candidates.length === 1 ? candidates[0] : null,
|
|
candidates,
|
|
};
|
|
}
|
|
|
|
function exactCivitaiUrl(host, model) {
|
|
const modelId = model?.civitai?.modelId;
|
|
const versionId = model?.civitai?.id;
|
|
if (!modelId) return null;
|
|
const version = versionId
|
|
? `?modelVersionId=${encodeURIComponent(String(versionId))}`
|
|
: "";
|
|
return `https://${host}/models/${encodeURIComponent(String(modelId))}${version}`;
|
|
}
|
|
|
|
export function buildExternalLinks(query, model = null) {
|
|
const term =
|
|
loraSearchTerm(model?.model_name || query) || loraSearchTerm(query);
|
|
const encodedTerm = encodeURIComponent(term);
|
|
const archiveTerm = String(model?.sha256 || term);
|
|
|
|
return {
|
|
civitai:
|
|
exactCivitaiUrl("civitai.com", model) ||
|
|
`https://civitai.com/search/models?query=${encodedTerm}`,
|
|
civitaiRed:
|
|
exactCivitaiUrl("civitai.red", model) ||
|
|
`https://civitai.red/search/models?query=${encodedTerm}`,
|
|
civArchive: `https://civarchive.com/search?q=${encodeURIComponent(archiveTerm)}`,
|
|
};
|
|
}
|