Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

10.5 KB
Raw Blame
import { normalizeGenerationInfo } from "./image-generation-info.js";
import { formatFacetNodePath, normalizeFacetCatalog } from "./facets.js";
import { entryPalette, visualDescriptions } from "./visuals.js";
import { matchesSearchQuery, parseSearchQuery } from "./search-query.js";

export function filterEntries(entries = [], filters = {}, catalogValue) {
  const catalog = normalizeFacetCatalog(catalogValue);
  const query = parseSearchQuery(filters.query);
  const preparedFacetSelections = prepareFacetSelections(catalog, filters.facetSelections);
  return entries.filter((entry) => {
    if (filters.contentId && !entryContentTypeIds(entry).includes(filters.contentId)) return false;
    if (filters.pendingOnly && !isEntryPending(entry)) return false;
    if ((query.terms.length || query.filters.length) && !matchesSearchQuery(entry, query, catalog, entrySearchText(entry, catalog))) return false;
    for (const { facetId, accepted } of preparedFacetSelections) {
      const matches = (entry.facetAssignments ?? []).some((item) =>
        item.status === "confirmed" && item.facetId === facetId && accepted.has(item.nodeId)
      );
      if (!matches) return false;
    }
    return true;
  });
}

function prepareFacetSelections(catalog, facetSelections) {
  const activeSelections = [...(facetSelections ?? [])].filter(([, selected]) => selected?.size);
  if (!activeSelections.length) return [];
  const childrenByParent = new Map();
  const nodesByFacet = new Map();
  for (const node of catalog.nodes) {
    const facetNodes = nodesByFacet.get(node.facetId) ?? [];
    facetNodes.push(node.id);
    nodesByFacet.set(node.facetId, facetNodes);
    if (!node.parentId) continue;
    const children = childrenByParent.get(node.parentId) ?? [];
    children.push(node.id);
    childrenByParent.set(node.parentId, children);
  }
  return activeSelections.map(([facetId, selected]) => {
    const accepted = new Set();
    for (const nodeId of selected) {
      if (nodeId === facetId) {
        for (const id of nodesByFacet.get(facetId) ?? []) accepted.add(id);
        continue;
      }
      const pending = [nodeId];
      while (pending.length) {
        const id = pending.pop();
        if (accepted.has(id)) continue;
        accepted.add(id);
        pending.push(...(childrenByParent.get(id) ?? []));
      }
    }
    return { facetId, accepted };
  });
}

// Rebuild this reader when the catalog changes; assignments are read fresh on every call.
export function createEntryAssignmentReader(catalogValue) {
  const catalog = normalizeFacetCatalog(catalogValue);
  const nodeById = new Map(catalog.nodes.map((item) => [item.id, item]));
  return (entry = {}, status = "confirmed") => {
    const grouped = new Map();
    for (const assignment of entry.facetAssignments ?? []) {
      if (assignment.status !== status) continue;
      const node = nodeById.get(assignment.nodeId);
      if (!node || node.status !== "active") continue;
      const values = grouped.get(node.facetId) ?? [];
      values.push({ ...assignment, name: node.name, path: formatFacetNodePath(catalog, node.id, nodeById) });
      grouped.set(node.facetId, values);
    }
    return grouped;
  };
}

export function groupEntryAssignments(entry = {}, catalogValue, status = "confirmed") {
  return createEntryAssignmentReader(catalogValue)(entry, status);
}

export function entryAttributeSummary(entry, catalogValue, limit = 4) {
  const catalog = normalizeFacetCatalog(catalogValue);
  const grouped = groupEntryAssignments(entry, catalog, "confirmed");
  const values = [];
  let stableOrder = 0;
  for (const facet of catalog.facets.filter((item) => item.status === "active").sort((a, b) => a.order - b.order)) {
    for (const item of (grouped.get(facet.id) ?? []).toSorted((left, right) => Number(right.importance ?? 0) - Number(left.importance ?? 0))) {
      values.push({ facetId: facet.id, label: item.name, path: item.path, source: item.source, priority: 0, importance: Number(item.importance ?? 0), stableOrder: stableOrder++ });
    }
  }
  for (const label of entry.customLabels ?? []) {
    values.push({ facetId: "custom", label, path: label, source: "manual", priority: 1, importance: 0, stableOrder: stableOrder++ });
  }
  return values
    .toSorted((left, right) => left.priority - right.priority || right.importance - left.importance || left.stableOrder - right.stableOrder)
    .slice(0, limit)
    .map(({ source: _source, priority: _priority, importance: _importance, stableOrder: _stableOrder, ...item }) => item);
}

export function entrySourceMetadataRows(entry = {}, sourceLabel = "来源") {
  const descriptors = [];
  const fields = [];
  const seen = new Set();
  const english = sourceLabel === "Source";
  const labels = english
    ? { provider: "Provider", itemId: "Work ID", author: "Author", handle: "Account", publishedAt: "Published", model: "Model", dimensions: "Dimensions", repins: "Saves", reactions: "Reactions", favorites: "Favorites", likes: "Likes", uses: "Uses", views: "Views", shares: "Shares", comments: "Comments", coins: "Coins", danmaku: "Danmaku" }
    : { provider: "来源", itemId: "作品 ID", author: "作者", handle: "账号", publishedAt: "发布时间", model: "模型", dimensions: "尺寸", repins: "收藏次数", reactions: "回应", favorites: "收藏", likes: "点赞", uses: "使用", views: "浏览", shares: "分享", comments: "评论", coins: "投币", danmaku: "弹幕" };
  const addField = (label, value) => {
    const text = String(value ?? "").trim();
    const key = `${label}\n${text}`;
    if (!label || !text || seen.has(key)) return;
    seen.add(key);
    fields.push({ label, value: text });
  };
  const sourceFacts = entry.sourceFacts && typeof entry.sourceFacts === "object" ? entry.sourceFacts : {};
  for (const name of ["provider", "itemId", "author", "handle", "publishedAt", "model", "dimensions"]) {
    addField(labels[name], sourceFacts[name]);
  }
  addField(english ? "Author URL" : "作者主页", sourceFacts.authorUrl);
  addField(english ? "Original source" : "作品原始来源", sourceFacts.originalSourceUrl);
  addField(english ? "Image description" : "图片描述", sourceFacts.imageDescription);
  addField(english ? "Metadata incomplete" : "元信息未补全", sourceFacts.metadataError);
  const description = String(sourceFacts.description || "").trim();
  if (description && !String(entry.text || "").includes(description)) addField(english ? "Description" : "作品说明", description);
  for (const [name, amount] of Object.entries(sourceFacts.engagement || {})) {
    if (Number.isFinite(Number(amount)) && Number(amount) >= 0) addField(labels[name] || name, String(amount));
  }
  for (const value of entry.metadataLabels ?? []) {
    const text = String(value ?? "").trim();
    if (!text) continue;
    const match = text.match(/^([^::]{1,24})[::]\s*(.+)$/);
    if (match) addField(match[1].trim(), match[2].trim());
    else if (!seen.has(text)) {
      seen.add(text);
      descriptors.push(text);
    }
  }
  const images = (entry.mediaAssets ?? []).filter(asset => asset.kind === "image" && asset.usage !== "poster");
  for (const [index, asset] of images.entries()) {
    const info = normalizeGenerationInfo(asset.generationInfo);
    if (!info) continue;
    for (const [branch, candidate] of info.candidates.entries()) {
      const prefix = [
        images.length > 1 ? `${english ? "Image" : "图片"} ${index + 1}` : "",
        info.candidates.length > 1 ? `${english ? "Branch" : "分支"} ${branch + 1}` : ""
      ].filter(Boolean).join(" · ");
      const label = name => prefix ? `${prefix} · ${name}` : name;
      addField(label(english ? "Generator" : "生成工具"), candidate.format === "a1111" ? "A1111" : "ComfyUI");
      addField(label(english ? "Negative prompt" : "负向提示词"), candidate.negativePrompt);
      for (const parameter of candidate.parameters) addField(label(parameter.name), parameter.value);
    }
  }
  return [
    ...(descriptors.length ? [{ label: sourceLabel, value: descriptors.join(" · ") }] : []),
    ...fields
  ];
}

export function isEntryPending(entry) {
  if (Array.isArray(entry?.memberEntries)) return entry.memberEntries.some(isEntryPending);
  return entry.classification?.status === "needs_review" ||
    Boolean((entry.analysisCandidates ?? []).some(isReusableAnalysis));
}

export function entrySearchText(entry, catalogValue, nodeByIdValue) {
  const nodeById = nodeByIdValue instanceof Map
    ? nodeByIdValue
    : new Map(normalizeFacetCatalog(catalogValue).nodes.map((item) => [item.id, item]));
  if (Array.isArray(entry?.memberEntries)) {
    return [entry.title, ...(entry.customLabels ?? []), ...(entry.metadataLabels ?? []), ...entry.memberEntries.map((item) => entrySearchText(item, catalogValue, nodeById))]
      .filter(Boolean).join("\n").toLocaleLowerCase("zh-CN");
  }
  const tags = (entry.facetAssignments ?? []).flatMap((item) => {
    const node = nodeById.get(item.nodeId);
    return node ? [node.name, ...node.aliases] : [];
  });
  const sourceFacts = entry.sourceFacts && typeof entry.sourceFacts === "object" ? entry.sourceFacts : {};
  const sourceFactValues = [
    sourceFacts.provider,
    sourceFacts.itemId,
    sourceFacts.author,
    sourceFacts.handle,
    sourceFacts.publishedAt,
    sourceFacts.model,
    sourceFacts.dimensions,
    ...Object.entries(sourceFacts.engagement || {}).flatMap(([key, value]) => [key, value])
  ];
  return [
    entry.title, entry.text, entry.url, ...Object.values(entry.creative || {}), ...tags, ...(entry.customLabels ?? []), ...(entry.metadataLabels ?? []),
    ...(entry.mediaPrompts ?? []).map(prompt => prompt.text),
    ...sourceFactValues,
    ...visualDescriptions(entry),
    ...(entry.negativeTerms ?? []), ...(entry.legacyFacetCandidates ?? []),
    ...(entry.timeNotes ?? []).map((note) => note.text),
    ...(entryPalette(entry)?.colors ?? []),
    ...(entry.analysisCandidates ?? []).filter(isReusableAnalysis).flatMap((item) => [item.dimensionName, item.groupName, item.tagName, item.evidence]),
    ...(entry.analysisBreakdown ?? []).filter(isReusableAnalysis).flatMap((item) => [item.dimensionName, item.groupName, item.tagName, item.evidence, item.reviewReason])
  ].filter(Boolean).join("\n").toLocaleLowerCase("zh-CN");
}

export function entryContentTypeIds(entry) {
  if (Array.isArray(entry?.contentTypeIds)) return entry.contentTypeIds.filter(Boolean);
  if (Array.isArray(entry?.memberEntries)) {
    return [...new Set(entry.memberEntries.map((item) => item.classification?.pathIds?.[0]).filter(Boolean))];
  }
  return [entry?.classification?.pathIds?.[0]].filter(Boolean);
}

function isReusableAnalysis(item) {
  return Boolean(item?.source && item.source !== "deepseek_text");
}