feat: add selected-loader LoRA info sidebar

2026-08-24 20:32:25 +02:00
parent 1ba04c6d88
commit 5365d9a06b
8 changed files with 1661 additions and 3 deletions
@@ -0,0 +1,392 @@
+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)}`,
+  };
+}