@musnows/scriverse 0.7.3 → 0.7.4

package/dist/public/outline-board.js

@@ -0,0 +1,137 @@
+const outlineStatuses = new Set(["all", "empty", "draft", "ready", "completed"]);
+const foreshadowStatuses = new Set(["all", "none", "unresolved", "resolved", "abandoned"]);
+const sortModes = new Set(["tree", "status", "foreshadows", "title"]);
+
+function text(value) {
+  return String(value ?? "");
+}
+
+function normalizedSearchText(value) {
+  return text(value).normalize("NFKC").trim().toLocaleLowerCase("zh-CN");
+}
+
+function numericOrder(value) {
+  const candidate = Number(value);
+  return Number.isFinite(candidate) ? candidate : 0;
+}
+
+function stableIdCompare(left, right) {
+  return text(left?.id).localeCompare(text(right?.id), "zh-CN");
+}
+
+function treeCompare(left, right) {
+  const delta = numericOrder(left?.sortOrder) - numericOrder(right?.sortOrder);
+  return delta || stableIdCompare(left, right);
+}
+
+function outlineStatusRank(chapter) {
+  if (!chapter?.outline) return 0;
+  return { draft: 1, ready: 2, completed: 3 }[chapter.outline.status] ?? 1;
+}
+
+function unresolvedForeshadowCount(chapter) {
+  return (Array.isArray(chapter?.foreshadows) ? chapter.foreshadows : [])
+    .filter((foreshadow) => foreshadow?.status === "planned" || foreshadow?.status === "planted")
+    .length;
+}
+
+function compareChapters(left, right, sort) {
+  if (sort === "status") {
+    const delta = outlineStatusRank(left) - outlineStatusRank(right);
+    if (delta) return delta;
+  }
+  if (sort === "foreshadows") {
+    const unresolvedDelta = unresolvedForeshadowCount(right) - unresolvedForeshadowCount(left);
+    if (unresolvedDelta) return unresolvedDelta;
+    const totalDelta = (right?.foreshadows?.length ?? 0) - (left?.foreshadows?.length ?? 0);
+    if (totalDelta) return totalDelta;
+  }
+  if (sort === "title") {
+    const delta = text(left?.title).localeCompare(text(right?.title), "zh-CN");
+    if (delta) return delta;
+  }
+  return treeCompare(left, right);
+}
+
+function matchesQuery(chapter, query) {
+  if (!query) return true;
+  const outline = chapter?.outline ?? {};
+  const values = [
+    chapter?.title,
+    chapter?.chapterType,
+    outline.goal,
+    outline.conflict,
+    outline.turningPoint,
+    outline.notes,
+    ...(Array.isArray(chapter?.foreshadows) ? chapter.foreshadows.map((item) => item?.title) : [])
+  ];
+  return values.some((value) => normalizedSearchText(value).includes(query));
+}
+
+function matchesOutlineStatus(chapter, status) {
+  if (status === "all") return true;
+  if (status === "empty") return !chapter?.outline;
+  return chapter?.outline?.status === status;
+}
+
+function matchesForeshadowStatus(chapter, status) {
+  if (status === "all") return true;
+  const foreshadows = Array.isArray(chapter?.foreshadows) ? chapter.foreshadows : [];
+  if (status === "none") return foreshadows.length === 0;
+  if (status === "unresolved") {
+    return foreshadows.some((item) => item?.status === "planned" || item?.status === "planted");
+  }
+  return foreshadows.some((item) => item?.status === status);
+}
+
+export function normalizeOutlineBoardState(value = {}) {
+  const outlineStatus = text(value?.outlineStatus);
+  const foreshadowStatus = text(value?.foreshadowStatus);
+  const sort = text(value?.sort);
+  return {
+    query: text(value?.query),
+    volumeId: text(value?.volumeId),
+    outlineStatus: outlineStatuses.has(outlineStatus) ? outlineStatus : "all",
+    foreshadowStatus: foreshadowStatuses.has(foreshadowStatus) ? foreshadowStatus : "all",
+    sort: sortModes.has(sort) ? sort : "tree"
+  };
+}
+
+/**
+ * 保持分卷层级与默认章节树顺序，对章节执行筛选和卷内排序。
+ * 未筛选时保留空分卷；指定空分卷时也保留该分组，便于确认数据状态。
+ */
+export function prepareOutlineBoard(board, value = {}) {
+  const state = normalizeOutlineBoardState(value);
+  const query = normalizedSearchText(state.query);
+  const chapterFilterActive = Boolean(query || state.outlineStatus !== "all" || state.foreshadowStatus !== "all");
+  const volumeFilterActive = Boolean(state.volumeId);
+  const sourceVolumes = Array.isArray(board?.volumes) ? board.volumes : [];
+  const totalChapterCount = sourceVolumes.reduce(
+    (total, volume) => total + (Array.isArray(volume?.chapters) ? volume.chapters.length : 0),
+    0
+  );
+  const volumes = [...sourceVolumes].sort(treeCompare).flatMap((volume) => {
+    if (volumeFilterActive && text(volume?.id) !== state.volumeId) return [];
+    const sourceChapters = Array.isArray(volume?.chapters) ? volume.chapters : [];
+    const chapters = sourceChapters
+      .filter((chapter) => matchesQuery(chapter, query)
+        && matchesOutlineStatus(chapter, state.outlineStatus)
+        && matchesForeshadowStatus(chapter, state.foreshadowStatus))
+      .sort((left, right) => compareChapters(left, right, state.sort));
+    const keepEmptyVolume = sourceChapters.length === 0 && (!chapterFilterActive || state.volumeId === text(volume?.id));
+    if (chapters.length === 0 && !keepEmptyVolume) return [];
+    return [{ ...volume, chapters }];
+  });
+  return {
+    state,
+    volumes,
+    totalChapterCount,
+    visibleChapterCount: volumes.reduce((total, volume) => total + volume.chapters.length, 0),
+    filtersActive: chapterFilterActive || volumeFilterActive
+  };
+}
+
+export function outlineBoardUnresolvedCount(chapter) {
+  return unresolvedForeshadowCount(chapter);
+}

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

@@ -2,6 +2,7 @@ export type RestorableModule = "drafts" | "settings" | "characters" | "races" |
 export type PageRoute =
   | { view: "shelf" }
   | { view: "editor"; workId: string; chapterId: string | null }
+  | { view: "reader"; 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 };

package/dist/public/page-route.js

@@ -40,6 +40,10 @@ export function serializePageRoute(route = {}) {
     params.set("view", "editor");
     params.set("work", workId);
     if (route.chapterId) params.set("chapter", String(route.chapterId));
+  } else if (view === "reader" && workId) {
+    params.set("view", "reader");
+    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);
@@ -75,6 +79,10 @@ export function parsePageRoute(hash = "") {
     const chapterId = value(params, "chapter");
     return { view, workId, chapterId: chapterId || null };
   }
+  if (view === "reader" && 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" };

package/dist/public/reading-preview.d.ts

@@ -0,0 +1,32 @@
+export type ReadingMode = "scroll" | "paged";
+export type ReadingTheme = "paper" | "light" | "dark";
+export type ReadingPreferences = { mode: ReadingMode; fontSize: number; lineHeight: number; theme: ReadingTheme };
+export type ReadingChapter = {
+  id: string;
+  workId: string;
+  volumeId: string;
+  volumeTitle: string;
+  title: string;
+  chapterType: string;
+  volumeIndex: number;
+  chapterIndex: number;
+  sequenceIndex: number;
+};
+export type ReadingPosition = { chapterId: string; scrollRatio: number; pageIndex: number };
+
+export const READING_PREFERENCES_STORAGE_KEY: string;
+export const READING_POSITION_STORAGE_PREFIX: string;
+export const DEFAULT_READING_PREFERENCES: Readonly<ReadingPreferences>;
+export function normalizeReadingPreferences(value: unknown): ReadingPreferences;
+export function readingPositionStorageKey(workId: unknown): string;
+export function buildReadingChapterSequence(work: unknown): ReadingChapter[];
+export function normalizeReadingPosition(value: unknown, sequence: ReadingChapter[]): ReadingPosition | null;
+export function resolveReadingStart(sequence: ReadingChapter[], options?: { chapterId?: unknown; volumeId?: unknown; storedPosition?: unknown }): ReadingChapter | null;
+export function adjacentReadingChapter(sequence: ReadingChapter[], chapterId: string, direction: number): ReadingChapter | null;
+export function resolvePagedReadingStep(input: { sequence: ReadingChapter[]; chapterId: string; pageIndex: number; pageCount: number }, direction: number): { chapterId: string; pageIndex: number; chapterChanged: boolean } | null;
+export function createReadingRequestGate(): {
+  begin(chapterId: string): { chapterId: string; generation: number; signal: AbortSignal };
+  isCurrent(request: { chapterId: string; generation: number; signal: AbortSignal }): boolean;
+  finish(request: { chapterId: string; generation: number }): void;
+  cancel(): void;
+};

package/dist/public/reading-preview.js

@@ -0,0 +1,136 @@
+export const READING_PREFERENCES_STORAGE_KEY = "scriverse-reading-preferences-v1";
+export const READING_POSITION_STORAGE_PREFIX = "scriverse-reading-position-v1:";
+
+export const DEFAULT_READING_PREFERENCES = Object.freeze({
+  mode: "scroll",
+  fontSize: 20,
+  lineHeight: 1.9,
+  theme: "paper"
+});
+
+const readingModes = new Set(["scroll", "paged"]);
+const readingFontSizes = new Set([16, 18, 20, 22, 24]);
+const readingLineHeights = new Set([1.6, 1.8, 1.9, 2, 2.2]);
+const readingThemes = new Set(["paper", "light", "dark"]);
+
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+export function normalizeReadingPreferences(value) {
+  const candidate = record(value);
+  const fontSize = Number(candidate.fontSize);
+  const lineHeight = Number(candidate.lineHeight);
+  return {
+    mode: readingModes.has(candidate.mode) ? candidate.mode : DEFAULT_READING_PREFERENCES.mode,
+    fontSize: readingFontSizes.has(fontSize) ? fontSize : DEFAULT_READING_PREFERENCES.fontSize,
+    lineHeight: readingLineHeights.has(lineHeight) ? lineHeight : DEFAULT_READING_PREFERENCES.lineHeight,
+    theme: readingThemes.has(candidate.theme) ? candidate.theme : DEFAULT_READING_PREFERENCES.theme
+  };
+}
+
+export function readingPositionStorageKey(workId) {
+  return `${READING_POSITION_STORAGE_PREFIX}${encodeURIComponent(String(workId ?? ""))}`;
+}
+
+export function buildReadingChapterSequence(work) {
+  const workId = String(work?.id ?? "");
+  const volumes = Array.isArray(work?.volumes) ? work.volumes : [];
+  const seen = new Set();
+  const sequence = [];
+  for (const [volumeIndex, volume] of volumes.entries()) {
+    const volumeId = String(volume?.id ?? "");
+    const chapters = Array.isArray(volume?.chapters) ? volume.chapters : [];
+    for (const [chapterIndex, chapter] of chapters.entries()) {
+      const id = String(chapter?.id ?? "");
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      sequence.push({
+        id,
+        workId: String(chapter?.workId ?? workId),
+        volumeId: String(chapter?.volumeId ?? volumeId),
+        volumeTitle: String(volume?.title ?? "正文"),
+        title: String(chapter?.title ?? "未命名章节"),
+        chapterType: String(chapter?.chapterType ?? "正文"),
+        volumeIndex,
+        chapterIndex,
+        sequenceIndex: sequence.length
+      });
+    }
+  }
+  return sequence;
+}
+
+export function normalizeReadingPosition(value, sequence) {
+  const candidate = record(value);
+  const chapterId = String(candidate.chapterId ?? "");
+  if (!sequence.some((chapter) => chapter.id === chapterId)) return null;
+  const scrollRatio = Number(candidate.scrollRatio);
+  const pageIndex = Number(candidate.pageIndex);
+  return {
+    chapterId,
+    scrollRatio: Number.isFinite(scrollRatio) ? Math.min(1, Math.max(0, scrollRatio)) : 0,
+    pageIndex: Number.isInteger(pageIndex) && pageIndex >= 0 ? pageIndex : 0
+  };
+}
+
+export function resolveReadingStart(sequence, options = {}) {
+  if (!sequence.length) return null;
+  const requestedChapterId = String(options.chapterId ?? "");
+  const requested = sequence.find((chapter) => chapter.id === requestedChapterId);
+  if (requested) return requested;
+  const stored = normalizeReadingPosition(options.storedPosition, sequence);
+  if (stored) return sequence.find((chapter) => chapter.id === stored.chapterId) ?? sequence[0];
+  const volumeId = String(options.volumeId ?? "");
+  return sequence.find((chapter) => chapter.volumeId === volumeId) ?? sequence[0];
+}
+
+export function adjacentReadingChapter(sequence, chapterId, direction) {
+  const index = sequence.findIndex((chapter) => chapter.id === chapterId);
+  if (index < 0) return null;
+  return sequence[index + (direction < 0 ? -1 : 1)] ?? null;
+}
+
+export function resolvePagedReadingStep({ sequence, chapterId, pageIndex, pageCount }, direction) {
+  const safePageCount = Math.max(1, Math.floor(Number(pageCount) || 1));
+  const safePageIndex = Math.min(safePageCount - 1, Math.max(0, Math.floor(Number(pageIndex) || 0)));
+  if (direction >= 0) {
+    if (safePageIndex < safePageCount - 1) return { chapterId, pageIndex: safePageIndex + 1, chapterChanged: false };
+    const next = adjacentReadingChapter(sequence, chapterId, 1);
+    return next ? { chapterId: next.id, pageIndex: 0, chapterChanged: true } : null;
+  }
+  if (safePageIndex > 0) return { chapterId, pageIndex: safePageIndex - 1, chapterChanged: false };
+  const previous = adjacentReadingChapter(sequence, chapterId, -1);
+  return previous ? { chapterId: previous.id, pageIndex: -1, chapterChanged: true } : null;
+}
+
+export function createReadingRequestGate() {
+  let generation = 0;
+  let active = null;
+  return {
+    begin(chapterId) {
+      active?.controller.abort();
+      const request = {
+        chapterId: String(chapterId),
+        generation: ++generation,
+        controller: new AbortController()
+      };
+      active = request;
+      return { chapterId: request.chapterId, generation: request.generation, signal: request.controller.signal };
+    },
+    isCurrent(request) {
+      return Boolean(active)
+        && active.chapterId === request?.chapterId
+        && active.generation === request?.generation
+        && !request?.signal?.aborted;
+    },
+    finish(request) {
+      if (active?.generation === request?.generation) active = null;
+    },
+    cancel() {
+      active?.controller.abort();
+      active = null;
+      generation += 1;
+    }
+  };
+}