@musnows/scriverse 0.2.0 → 0.3.0

package/dist/public/markdown.js

@@ -0,0 +1,199 @@
+const escapeHtml = (value) => String(value ?? "").replace(/[&<>'"]/gu, (character) => ({
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  "'": "&#39;",
+  '"': "&quot;"
+})[character]);
+
+function safeLinkTarget(value) {
+  const target = String(value ?? "").trim();
+  if (/^(https?:|mailto:)/iu.test(target)) return target;
+  if (/^(\/|#)/u.test(target) && !target.startsWith("//")) return target;
+  return null;
+}
+
+function renderInlineMarkdown(value) {
+  const tokens = [];
+  const preserve = (html) => {
+    const marker = `\uE000${tokens.length}\uE001`;
+    tokens.push(html);
+    return marker;
+  };
+  let source = String(value ?? "");
+  source = source.replace(/`([^`\n]+)`/gu, (_match, code) => preserve(`<code>${escapeHtml(code)}</code>`));
+  source = source.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/gu, (_match, label, href) => {
+    const target = safeLinkTarget(href);
+    if (!target) return `${label}（${href}）`;
+    const external = /^https?:/iu.test(target) ? ' target="_blank" rel="noopener noreferrer"' : "";
+    return preserve(`<a href="${escapeHtml(target)}"${external}>${escapeHtml(label)}</a>`);
+  });
+  let html = escapeHtml(source);
+  html = html.replace(/\*\*([^*\n]+)\*\*/gu, "<strong>$1</strong>");
+  html = html.replace(/__([^_\n]+)__/gu, "<strong>$1</strong>");
+  html = html.replace(/(^|[^*])\*([^*\n]+)\*/gu, "$1<em>$2</em>");
+  html = html.replace(/~~([^~\n]+)~~/gu, "<del>$1</del>");
+  tokens.forEach((token, index) => {
+    html = html.replace(`\uE000${index}\uE001`, token);
+  });
+  return html;
+}
+
+function splitMarkdownTableRow(value) {
+  const source = String(value ?? "").trim();
+  if (!source.includes("|")) return null;
+  const cells = [];
+  let cell = "";
+  let inCode = false;
+  let separators = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    if (character === "\\" && source[index + 1] === "|") {
+      cell += "|";
+      index += 1;
+      continue;
+    }
+    if (character === "`") inCode = !inCode;
+    if (character === "|" && !inCode) {
+      cells.push(cell.trim());
+      cell = "";
+      separators += 1;
+      continue;
+    }
+    cell += character;
+  }
+  cells.push(cell.trim());
+  if (!separators) return null;
+  if (source.startsWith("|")) cells.shift();
+  if (source.endsWith("|") && cells.at(-1) === "") cells.pop();
+  return cells;
+}
+
+function tableAlignments(cells) {
+  if (!cells?.length || !cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) return null;
+  return cells.map((cell) => {
+    if (cell.startsWith(":") && cell.endsWith(":")) return "center";
+    if (cell.endsWith(":")) return "right";
+    return "left";
+  });
+}
+
+function renderMarkdownTable(headers, alignments, rows) {
+  const renderCell = (tag, value, alignment) => `<${tag} class="markdown-align-${alignment}">${renderInlineMarkdown(value)}</${tag}>`;
+  const header = headers.map((cell, index) => renderCell("th", cell, alignments[index])).join("");
+  const body = rows.map((row) => {
+    const cells = headers.map((_header, index) => renderCell("td", row[index] ?? "", alignments[index])).join("");
+    return `<tr>${cells}</tr>`;
+  }).join("");
+  return `<div class="markdown-table-scroll" role="region" aria-label="Markdown 表格" tabindex="0"><table><thead><tr>${header}</tr></thead>${body ? `<tbody>${body}</tbody>` : ""}</table></div>`;
+}
+
+export function renderMarkdown(value) {
+  const lines = String(value ?? "").replace(/\r\n?/gu, "\n").split("\n");
+  const output = [];
+  let paragraph = [];
+  let list = null;
+  let quote = null;
+  let codeFence = null;
+
+  const flushParagraph = () => {
+    if (!paragraph.length) return;
+    output.push(`<p>${paragraph.map(renderInlineMarkdown).join("<br>")}</p>`);
+    paragraph = [];
+  };
+  const flushList = () => {
+    if (!list) return;
+    output.push(`<${list.tag}>${list.items.map((item) => `<li class="markdown-depth-${item.depth}">${renderInlineMarkdown(item.text)}</li>`).join("")}</${list.tag}>`);
+    list = null;
+  };
+  const flushQuote = () => {
+    if (!quote) return;
+    const content = quote.join("\n").trim();
+    if (content) {
+      const html = content.split(/\n\s*\n/gu)
+        .map((part) => part.split("\n").map(renderInlineMarkdown).join("<br>"))
+        .join("<br><br>");
+      output.push(`<blockquote>${html}</blockquote>`);
+    }
+    quote = null;
+  };
+  const flushBlocks = () => {
+    flushParagraph();
+    flushList();
+    flushQuote();
+  };
+
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
+    if (codeFence) {
+      if (/^\s*```/u.test(line)) {
+        output.push(`<pre><code${codeFence.language ? ` class="language-${codeFence.language}"` : ""}>${escapeHtml(codeFence.lines.join("\n"))}</code></pre>`);
+        codeFence = null;
+      } else {
+        codeFence.lines.push(line);
+      }
+      continue;
+    }
+    const fence = line.match(/^\s*```([\w-]*)\s*$/u);
+    if (fence) {
+      flushBlocks();
+      codeFence = { language: fence[1].replace(/[^\w-]/gu, ""), lines: [] };
+      continue;
+    }
+    const quoteLine = line.match(/^>\s?(.*)$/u);
+    if (quoteLine) {
+      flushParagraph();
+      flushList();
+      if (!quote) quote = [];
+      quote.push(quoteLine[1]);
+      continue;
+    }
+    flushQuote();
+    if (!line.trim()) {
+      flushBlocks();
+      continue;
+    }
+    const heading = line.match(/^(#{1,4})\s+(.+)$/u);
+    if (heading) {
+      flushBlocks();
+      const level = heading[1].length;
+      output.push(`<h${level}>${renderInlineMarkdown(heading[2])}</h${level}>`);
+      continue;
+    }
+    if (/^\s*(---+|___+|\*\*\*+)\s*$/u.test(line)) {
+      flushBlocks();
+      output.push("<hr>");
+      continue;
+    }
+    const tableHeaders = splitMarkdownTableRow(line);
+    const alignments = tableAlignments(splitMarkdownTableRow(lines[lineIndex + 1]));
+    if (tableHeaders && alignments && tableHeaders.length === alignments.length) {
+      flushBlocks();
+      const rows = [];
+      lineIndex += 2;
+      while (lineIndex < lines.length && lines[lineIndex].trim()) {
+        const row = splitMarkdownTableRow(lines[lineIndex]);
+        if (!row) break;
+        rows.push(row);
+        lineIndex += 1;
+      }
+      lineIndex -= 1;
+      output.push(renderMarkdownTable(tableHeaders, alignments, rows));
+      continue;
+    }
+    const listItem = line.match(/^(\s*)([-+*]|\d+\.)\s+(.+)$/u);
+    if (listItem) {
+      flushParagraph();
+      const tag = /\d+\./u.test(listItem[2]) ? "ol" : "ul";
+      if (list && list.tag !== tag) flushList();
+      if (!list) list = { tag, items: [] };
+      list.items.push({ depth: Math.min(3, Math.floor(listItem[1].length / 2)), text: listItem[3] });
+      continue;
+    }
+    if (list) flushList();
+    paragraph.push(line);
+  }
+  if (codeFence) output.push(`<pre><code${codeFence.language ? ` class="language-${codeFence.language}"` : ""}>${escapeHtml(codeFence.lines.join("\n"))}</code></pre>`);
+  flushBlocks();
+  return output.join("");
+}

package/dist/public/model-config.d.ts

@@ -0,0 +1,17 @@
+export const MODEL_PURPOSE_OPTIONS: ReadonlyArray<readonly [string, string]>;
+
+export type ModelFormValues = {
+  displayName: string;
+  modelId: string;
+  purposes: string[];
+  contextWindow: number;
+  temperature: number;
+  maxTokens: number;
+  thinkingEnabled: boolean;
+  enabled: boolean;
+};
+
+export function normalizeModelPurposes(purposes: unknown): string[];
+export function modelFormValues(model?: Record<string, unknown> | null): ModelFormValues;
+export function modelPayload(values: ModelFormValues, existingPreset?: Record<string, unknown>): Record<string, unknown> & { thinkingEnabled: boolean };
+export function modelOptionLabel(model: Record<string, unknown> | null | undefined): string;

package/dist/public/model-config.js

@@ -0,0 +1,57 @@
+export const MODEL_PURPOSE_OPTIONS = Object.freeze([
+  ["chat", "通用对话"],
+  ["continue", "创作续写"],
+  ["polish", "文本润色"],
+  ["chapter-analysis", "章节理解"],
+  ["book-analysis", "全书分析"],
+  ["timeline-analysis", "时间轴抽取"],
+  ["relationship-analysis", "人物关系分析"],
+  ["consistency-check", "一致性校对"]
+]);
+
+const purposeAliases = new Map([
+  ...MODEL_PURPOSE_OPTIONS.flatMap(([key, label]) => [[key, key], [label, key]]),
+  ["章节分析", "chapter-analysis"],
+  ["时间轴分析", "timeline-analysis"],
+  ["关系分析", "relationship-analysis"]
+]);
+
+export function normalizeModelPurposes(purposes) {
+  const values = Array.isArray(purposes) ? purposes : String(purposes ?? "").split(/[,，]/u);
+  return [...new Set(values.map((value) => purposeAliases.get(String(value).trim())).filter(Boolean))];
+}
+
+export function modelFormValues(model = null) {
+  return {
+    displayName: model?.displayName ?? "",
+    modelId: model?.modelId ?? "",
+    purposes: model ? normalizeModelPurposes(model.purposes) : ["chat", "continue"],
+    contextWindow: model?.contextWindow ?? 128000,
+    temperature: model?.preset?.temperature ?? 0.7,
+    maxTokens: model?.preset?.max_tokens ?? 32000,
+    thinkingEnabled: model?.thinkingEnabled ?? true,
+    enabled: model?.enabled ?? true
+  };
+}
+
+export function modelPayload(values, existingPreset = {}) {
+  return {
+    displayName: String(values.displayName),
+    modelId: String(values.modelId),
+    purposes: normalizeModelPurposes(values.purposes),
+    contextWindow: Number(values.contextWindow),
+    preset: {
+      ...existingPreset,
+      temperature: Number(values.temperature),
+      max_tokens: Number(values.maxTokens)
+    },
+    thinkingEnabled: Boolean(values.thinkingEnabled),
+    enabled: Boolean(values.enabled)
+  };
+}
+
+export function modelOptionLabel(model) {
+  const providerName = String(model?.providerName ?? "").trim();
+  const modelName = String(model?.displayName ?? model?.modelId ?? "").trim();
+  return [providerName, modelName].filter(Boolean).join(" · ");
+}

package/dist/public/page-route.d.ts

@@ -0,0 +1,11 @@
+export type RestorableModule = "settings" | "characters" | "races" | "organizations" | "timeline" | "outlines" | "relationships" | "reviews" | "tasks" | "ai-settings";
+export type PageRoute =
+  | { view: "shelf" }
+  | { view: "editor"; workId: string; chapterId: string | null }
+  | { view: "module"; workId: string; module: RestorableModule }
+  | { view: "welcome"; workId: string }
+  | { view: "settings" | "platform-ai"; workId: string | null; returnView?: "shelf" | "editor" | "module" | "welcome"; returnModule?: RestorableModule; returnChapterId?: string };
+
+export const RESTORABLE_MODULES: readonly RestorableModule[];
+export function serializePageRoute(route?: Record<string, unknown>): string;
+export function parsePageRoute(hash?: string): PageRoute;

package/dist/public/page-route.js

@@ -0,0 +1,81 @@
+export const RESTORABLE_MODULES = Object.freeze([
+  "settings",
+  "characters",
+  "races",
+  "organizations",
+  "timeline",
+  "outlines",
+  "relationships",
+  "reviews",
+  "tasks",
+  "ai-settings"
+]);
+
+const moduleSet = new Set(RESTORABLE_MODULES);
+const returnViewSet = new Set(["shelf", "editor", "module", "welcome"]);
+
+function value(params, key) {
+  return String(params.get(key) ?? "").trim();
+}
+
+function appendReturnContext(params, route) {
+  const returnView = returnViewSet.has(route.returnView) ? route.returnView : "";
+  if (!returnView) return;
+  params.set("from", returnView);
+  if (returnView === "module" && moduleSet.has(route.returnModule)) params.set("fromModule", route.returnModule);
+  if (returnView === "editor" && route.returnChapterId) params.set("fromChapter", String(route.returnChapterId));
+}
+
+export function serializePageRoute(route = {}) {
+  const params = new URLSearchParams();
+  const view = String(route.view ?? "shelf");
+  const workId = String(route.workId ?? "").trim();
+
+  if (view === "editor" && workId) {
+    params.set("view", "editor");
+    params.set("work", workId);
+    if (route.chapterId) params.set("chapter", String(route.chapterId));
+  } else if (view === "module" && workId && moduleSet.has(route.module)) {
+    params.set("view", "module");
+    params.set("work", workId);
+    params.set("module", route.module);
+  } else if (view === "welcome" && workId) {
+    params.set("view", "welcome");
+    params.set("work", workId);
+  } else if (view === "settings" || view === "platform-ai") {
+    params.set("view", view);
+    if (workId) params.set("work", workId);
+    appendReturnContext(params, route);
+  } else {
+    params.set("view", "shelf");
+  }
+
+  return `#${params.toString()}`;
+}
+
+export function parsePageRoute(hash = "") {
+  const params = new URLSearchParams(String(hash).replace(/^#/, ""));
+  const view = value(params, "view");
+  const workId = value(params, "work");
+
+  if (view === "editor" && workId) {
+    const chapterId = value(params, "chapter");
+    return { view, workId, chapterId: chapterId || null };
+  }
+  if (view === "module" && workId) {
+    const module = value(params, "module");
+    return moduleSet.has(module) ? { view, workId, module } : { view: "shelf" };
+  }
+  if (view === "welcome" && workId) return { view, workId };
+  if (view === "settings" || view === "platform-ai") {
+    const route = { view, workId: workId || null };
+    const returnView = value(params, "from");
+    if (returnViewSet.has(returnView)) route.returnView = returnView;
+    const returnModule = value(params, "fromModule");
+    if (returnView === "module" && moduleSet.has(returnModule)) route.returnModule = returnModule;
+    const returnChapterId = value(params, "fromChapter");
+    if (returnView === "editor" && returnChapterId) route.returnChapterId = returnChapterId;
+    return route;
+  }
+  return { view: "shelf" };
+}