@rohal12/twee-ts 1.5.0 → 1.7.0

package/dist/bin/twee-ts.js

@@ -151,6 +151,9 @@ function hasInfoTags(p) {
 function hasInfoName(p) {
   return INFO_PASSAGE_NAMES.has(p.name);
 }
+function isInfoPassage(p) {
+  return hasInfoName(p) || hasInfoTags(p);
+}
 function isStoryPassage(p) {
   return !hasInfoName(p) && !hasInfoTags(p);
 }
@@ -262,8 +265,21 @@ function quote(s) {
 }
 
 // src/story.ts
+var passageIndex = /* @__PURE__ */ new WeakMap();
+function getIndex(story) {
+  let index = passageIndex.get(story);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (let i = 0; i < story.passages.length; i++) {
+      const passage = story.passages[i];
+      if (passage) index.set(passage.name, i);
+    }
+    passageIndex.set(story, index);
+  }
+  return index;
+}
 function createStory() {
-  return {
+  const story = {
     name: "",
     ifid: "",
     passages: [],
@@ -279,16 +295,17 @@ function createStory() {
       zoom: 1
     }
   };
+  passageIndex.set(story, /* @__PURE__ */ new Map());
+  return story;
 }
 function storyHas(story, name) {
-  return story.passages.some((p) => p.name === name);
-}
-function storyIndex(story, name) {
-  return story.passages.findIndex((p) => p.name === name);
+  return getIndex(story).has(name);
 }
 function storyAppend(story, p, diagnostics) {
-  const i = storyIndex(story, p.name);
+  const index = getIndex(story);
+  const i = index.get(p.name) ?? -1;
   if (i === -1) {
+    index.set(p.name, story.passages.length);
     story.passages.push(p);
   } else {
     diagnostics.push({
@@ -299,9 +316,15 @@ function storyAppend(story, p, diagnostics) {
   }
 }
 function storyPrepend(story, p, diagnostics) {
-  const i = storyIndex(story, p.name);
+  const index = getIndex(story);
+  const i = index.get(p.name) ?? -1;
   if (i === -1) {
     story.passages.unshift(p);
+    index.clear();
+    for (let j = 0; j < story.passages.length; j++) {
+      const passage = story.passages[j];
+      if (passage) index.set(passage.name, j);
+    }
   } else {
     diagnostics.push({
       level: "warning",
@@ -591,11 +614,15 @@ function watchFilesystem(pathnames, outFilename, callback) {
   const watchers = [];
   let buildTimer = null;
   const BUILD_DEBOUNCE = 500;
-  function scheduleBuild() {
+  const pendingFiles = /* @__PURE__ */ new Set();
+  function scheduleBuild(changedFile) {
+    if (changedFile) pendingFiles.add(changedFile);
     if (buildTimer) clearTimeout(buildTimer);
     buildTimer = setTimeout(() => {
       buildTimer = null;
-      callback();
+      const files = pendingFiles.size > 0 ? new Set(pendingFiles) : void 0;
+      pendingFiles.clear();
+      callback(files);
     }, BUILD_DEBOUNCE);
   }
   for (const pathname of pathnames) {
@@ -605,7 +632,8 @@ function watchFilesystem(pathnames, outFilename, callback) {
         const abs = resolve(pathname, filename);
         if (abs === absOutFile) return;
         if (isKnownFileType(filename)) {
-          scheduleBuild();
+          const rel = relative(process.cwd(), abs);
+          scheduleBuild(rel || abs);
         }
       });
       watchers.push(watcher);
@@ -864,6 +892,7 @@ function readFormatSource(format) {
 
 // src/loader.ts
 import { basename } from "path";
+import { statSync as statSync3 } from "fs";
 
 // src/lexer.ts
 var EOF = -1;
@@ -1371,54 +1400,182 @@ function loadInlineSources(story, sources, opts, diagnostics) {
     }
   }
 }
-function loadTwee(story, filename, opts, diagnostics) {
+function parseTweeFile(filename, opts) {
   const source = readUTF8(filename);
   const result = parseTwee(source, {
     filename,
     trim: opts.trim ?? true,
     twee2Compat: opts.twee2Compat ?? false
   });
-  diagnostics.push(...result.diagnostics);
-  for (const p of result.passages) {
-    storyAdd(story, p, diagnostics);
-  }
+  return { passages: result.passages, diagnostics: [...result.diagnostics] };
 }
-function loadTagged(story, tag, filename, diagnostics) {
+function parseTaggedFile(tag, filename) {
   const source = readUTF8(filename);
-  storyAdd(story, { name: basename(filename), tags: [tag], text: source }, diagnostics);
+  return { passages: [{ name: basename(filename), tags: [tag], text: source }], diagnostics: [] };
 }
-function loadMedia(story, tag, filename, diagnostics) {
+function parseMediaFile(tag, filename) {
   const source = readBase64(filename);
   const name = baseNameWithoutExt(filename);
-  storyAdd(
-    story,
-    {
-      name,
-      tags: [tag],
-      text: `data:${mediaTypeFromFilename(filename)};base64,${source}`
-    },
-    diagnostics
-  );
+  return {
+    passages: [{ name, tags: [tag], text: `data:${mediaTypeFromFilename(filename)};base64,${source}` }],
+    diagnostics: []
+  };
 }
-function loadFont(story, filename, diagnostics) {
+function parseFontFile(filename) {
   const source = readBase64(filename);
   const name = basename(filename);
   const family = baseNameWithoutExt(filename);
   const ext = normalizedFileExt(filename);
   const mediaType = mediaTypeFromExt(ext);
   const hint = fontFormatHint(ext);
-  storyAdd(
-    story,
-    {
-      name,
-      tags: ["stylesheet"],
-      text: `@font-face {
+  return {
+    passages: [
+      {
+        name,
+        tags: ["stylesheet"],
+        text: `@font-face {
 	font-family: "${family}";
 	src: url("data:${mediaType};base64,${source}") format("${hint}");
 }`
-    },
-    diagnostics
-  );
+      }
+    ],
+    diagnostics: []
+  };
+}
+function parseFile(filename, opts) {
+  const ext = normalizedFileExt(filename);
+  switch (ext) {
+    case "tw":
+    case "twee":
+      return parseTweeFile(filename, opts);
+    case "tw2":
+    case "twee2":
+      return parseTweeFile(filename, { ...opts, twee2Compat: true });
+    case "css":
+      return parseTaggedFile("stylesheet", filename);
+    case "js":
+      return parseTaggedFile("script", filename);
+    case "otf":
+    case "ttf":
+    case "woff":
+    case "woff2":
+      return parseFontFile(filename);
+    case "gif":
+    case "jpeg":
+    case "jpg":
+    case "png":
+    case "svg":
+    case "tif":
+    case "tiff":
+    case "webp":
+      return parseMediaFile("Twine.image", filename);
+    case "aac":
+    case "flac":
+    case "m4a":
+    case "mp3":
+    case "oga":
+    case "ogg":
+    case "opus":
+    case "wav":
+    case "wave":
+    case "weba":
+      return parseMediaFile("Twine.audio", filename);
+    case "mp4":
+    case "ogv":
+    case "webm":
+      return parseMediaFile("Twine.video", filename);
+    case "vtt":
+      return parseMediaFile("Twine.vtt", filename);
+    default:
+      return void 0;
+  }
+}
+function loadTwee(story, filename, opts, diagnostics) {
+  const result = parseTweeFile(filename, opts);
+  diagnostics.push(...result.diagnostics);
+  for (const p of result.passages) {
+    storyAdd(story, p, diagnostics);
+  }
+}
+function loadTagged(story, tag, filename, diagnostics) {
+  const result = parseTaggedFile(tag, filename);
+  for (const p of result.passages) {
+    storyAdd(story, p, diagnostics);
+  }
+}
+function loadMedia(story, tag, filename, diagnostics) {
+  const result = parseMediaFile(tag, filename);
+  for (const p of result.passages) {
+    storyAdd(story, p, diagnostics);
+  }
+}
+function loadFont(story, filename, diagnostics) {
+  const result = parseFontFile(filename);
+  for (const p of result.passages) {
+    storyAdd(story, p, diagnostics);
+  }
+}
+function loadSourcesCached(story, filenames, opts, diagnostics, processedFiles, cache, changedFiles) {
+  const currentFiles = /* @__PURE__ */ new Set();
+  for (const filename of filenames) {
+    if (processedFiles.has(filename)) {
+      diagnostics.push({ level: "warning", message: `load ${filename}: Skipping duplicate.` });
+      continue;
+    }
+    currentFiles.add(filename);
+    const cached = cache.get(filename);
+    if (changedFiles && cached && !changedFiles.has(filename)) {
+      diagnostics.push(...cached.diagnostics);
+      for (const p of cached.passages) {
+        storyAdd(story, p, diagnostics);
+      }
+      processedFiles.add(filename);
+      continue;
+    }
+    let mtimeMs;
+    try {
+      mtimeMs = statSync3(filename).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (cached && cached.mtimeMs === mtimeMs) {
+      diagnostics.push(...cached.diagnostics);
+      for (const p of cached.passages) {
+        storyAdd(story, p, diagnostics);
+      }
+      processedFiles.add(filename);
+      continue;
+    }
+    try {
+      const result = parseFile(filename, opts);
+      if (!result) continue;
+      cache.set(filename, {
+        mtimeMs,
+        passages: result.passages,
+        diagnostics: result.diagnostics
+      });
+      diagnostics.push(...result.diagnostics);
+      for (const p of result.passages) {
+        storyAdd(story, p, diagnostics);
+      }
+    } catch (e) {
+      diagnostics.push({
+        level: "error",
+        message: `load ${filename}: ${e instanceof Error ? e.message : String(e)}`,
+        file: filename
+      });
+      continue;
+    }
+    processedFiles.add(filename);
+  }
+  for (const key of cache.keys()) {
+    if (!currentFiles.has(key)) {
+      cache.delete(key);
+    }
+  }
+  if (story.name !== "" && !story.passages.some((p) => p.name === "StoryTitle")) {
+    storyPrepend(story, { name: "StoryTitle", tags: [], text: story.name }, diagnostics);
+  }
 }
 
 // src/version.ts
@@ -1687,7 +1844,7 @@ function modifyHead(html, modulePaths, headFile, diagnostics) {
 }
 
 // src/remote-formats.ts
-import { mkdirSync, readFileSync as readFileSync3, writeFileSync, existsSync, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync, existsSync, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 var DEFAULT_SFA_INDICES = [
@@ -1899,7 +2056,7 @@ function discoverCachedFormats() {
   for (const name of names) {
     const nameDir = join4(cacheDir, name);
     try {
-      if (!statSync3(nameDir).isDirectory()) continue;
+      if (!statSync4(nameDir).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -1940,11 +2097,12 @@ async function compileToFile(options) {
 }
 async function watch(options) {
   const controller = new AbortController();
+  const cache = /* @__PURE__ */ new Map();
   const filePaths = options.sources.filter((s) => typeof s === "string");
   const modulePaths = options.modules ?? [];
   const allPaths = [...filePaths, ...modulePaths];
-  const handle = watchFilesystem(allPaths, options.outFile, () => {
-    buildOutput(options).then((result) => {
+  const handle = watchFilesystem(allPaths, options.outFile, (changedFiles) => {
+    buildOutput(options, cache, changedFiles).then((result) => {
       writeFileSync2(options.outFile, result.output, "utf-8");
       options.onBuild?.(result);
     }).catch((e) => {
@@ -1954,7 +2112,7 @@ async function watch(options) {
   controller.signal.addEventListener("abort", () => handle.close());
   return controller;
 }
-async function buildOutput(options) {
+async function buildOutput(options, cache, changedFiles) {
   const diagnostics = [];
   const outputMode = options.outputMode ?? "html";
   const trim = options.trim ?? true;
@@ -1975,7 +2133,11 @@ async function buildOutput(options) {
   const sourceFilenames = getFilenames(filePaths);
   const story = createStory();
   const processedFiles = /* @__PURE__ */ new Set();
-  loadSources(story, sourceFilenames, { trim, twee2Compat }, diagnostics, processedFiles);
+  if (cache) {
+    loadSourcesCached(story, sourceFilenames, { trim, twee2Compat }, diagnostics, processedFiles, cache, changedFiles);
+  } else {
+    loadSources(story, sourceFilenames, { trim, twee2Compat }, diagnostics, processedFiles);
+  }
   loadInlineSources(story, inlineSources, { trim, twee2Compat }, diagnostics);
   if (options.tagAliases) {
     story.passages = applyTagAliases(story.passages, options.tagAliases);
@@ -2113,6 +2275,171 @@ function storyToJSON(story) {
   return JSON.stringify(obj, null, 2);
 }
 
+// src/inspect.ts
+function extractLinksFromText(text) {
+  const targets = /* @__PURE__ */ new Set();
+  const wikiLinkRe = /\[\[([^\]]+)\]\]/g;
+  let m;
+  while ((m = wikiLinkRe.exec(text)) !== null) {
+    const content = m[1];
+    const arrowIdx = content.indexOf("->");
+    if (arrowIdx !== -1) {
+      targets.add(content.slice(arrowIdx + 2).trim());
+      continue;
+    }
+    const pipeIdx = content.indexOf("|");
+    if (pipeIdx !== -1) {
+      targets.add(content.slice(pipeIdx + 1).trim());
+      continue;
+    }
+    targets.add(content.trim());
+  }
+  const gotoRe = /<<goto\s+["']([^"']+)["']\s*>>/g;
+  while ((m = gotoRe.exec(text)) !== null) {
+    targets.add(m[1]);
+  }
+  const linkMacroRe = /<<link\s+["'][^"']*["']\s+["']([^"']+)["']\s*>>/g;
+  while ((m = linkMacroRe.exec(text)) !== null) {
+    targets.add(m[1]);
+  }
+  return [...targets];
+}
+function storyInspect(story) {
+  const allNames = new Set(story.passages.map((p) => p.name));
+  const passages = [];
+  const storyPassages = [];
+  const infoPassages = [];
+  const tagSet = /* @__PURE__ */ new Set();
+  const passagesByTag = /* @__PURE__ */ new Map();
+  const tagsByPassage = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  for (const p of story.passages) {
+    passages.push(p.name);
+    if (isStoryPassage(p)) {
+      storyPassages.push(p.name);
+    }
+    if (isInfoPassage(p)) {
+      infoPassages.push(p.name);
+    }
+    tagsByPassage.set(p.name, [...p.tags]);
+    for (const tag of p.tags) {
+      tagSet.add(tag);
+      let list = passagesByTag.get(tag);
+      if (!list) {
+        list = [];
+        passagesByTag.set(tag, list);
+      }
+      list.push(p.name);
+    }
+    const targets = extractLinksFromText(p.text);
+    links.set(p.name, targets);
+  }
+  const brokenLinks = [];
+  for (const [from, targets] of links) {
+    for (const to of targets) {
+      if (!allNames.has(to)) {
+        brokenLinks.push({ from, to });
+      }
+    }
+  }
+  const deadEnds = [];
+  for (const name of storyPassages) {
+    const targets = links.get(name);
+    if (!targets || targets.length === 0) {
+      deadEnds.push(name);
+    }
+  }
+  const start = story.twine2.start || "Start";
+  const linkedTo = /* @__PURE__ */ new Set();
+  for (const targets of links.values()) {
+    for (const t of targets) {
+      linkedTo.add(t);
+    }
+  }
+  const orphans = [];
+  for (const name of storyPassages) {
+    if (name !== start && !linkedTo.has(name)) {
+      orphans.push(name);
+    }
+  }
+  return {
+    passages,
+    storyPassages,
+    infoPassages,
+    tags: [...tagSet].sort(),
+    passagesByTag,
+    tagsByPassage,
+    links,
+    brokenLinks,
+    deadEnds,
+    orphans,
+    start
+  };
+}
+
+// src/lint.ts
+async function lint(options) {
+  const result = await compile({ ...options, outputMode: "json" });
+  const map = storyInspect(result.story);
+  return {
+    diagnostics: result.diagnostics,
+    stats: result.stats,
+    formatName: result.story.twine2.format,
+    formatVersion: result.story.twine2.formatVersion,
+    start: map.start,
+    passages: map.passages.length,
+    storyPassages: map.storyPassages.length,
+    infoPassages: map.infoPassages.length,
+    brokenLinks: map.brokenLinks,
+    deadEnds: map.deadEnds,
+    orphans: map.orphans
+  };
+}
+function formatLintReport(result) {
+  const lines = [];
+  const formatStr = result.formatName ? `${result.formatName}${result.formatVersion ? " " + result.formatVersion : ""}` : "unknown";
+  lines.push(`Format: ${formatStr}`);
+  lines.push(
+    `Passages: ${result.passages} total (${result.storyPassages} story, ${result.infoPassages} info), ${result.stats.words.toLocaleString()} words, ${result.stats.files.length} files`
+  );
+  lines.push(`Start: ${result.start}`);
+  if (result.brokenLinks.length > 0) {
+    lines.push("");
+    lines.push(`Broken links (${result.brokenLinks.length}):`);
+    for (const link of result.brokenLinks) {
+      lines.push(`  ${link.from} -> ${link.to} (passage "${link.to}" does not exist)`);
+    }
+  }
+  if (result.deadEnds.length > 0) {
+    lines.push("");
+    lines.push(`Dead ends (${result.deadEnds.length}): ${result.deadEnds.join(", ")}`);
+  }
+  if (result.orphans.length > 0) {
+    lines.push("");
+    lines.push(`Orphans (${result.orphans.length}): ${result.orphans.join(", ")}`);
+  }
+  const errors = result.diagnostics.filter((d) => d.level === "error");
+  const warnings = result.diagnostics.filter((d) => d.level === "warning");
+  if (errors.length > 0 || warnings.length > 0) {
+    lines.push("");
+    lines.push(`Diagnostics: ${errors.length} error(s), ${warnings.length} warning(s)`);
+    for (const d of errors) {
+      lines.push(`  error: ${d.message}`);
+    }
+    for (const d of warnings) {
+      lines.push(`  warning: ${d.message}`);
+    }
+  }
+  lines.push("");
+  const hasErrors = errors.length > 0 || result.brokenLinks.length > 0;
+  if (hasErrors) {
+    lines.push("Lint failed.");
+  } else {
+    lines.push("Lint passed.");
+  }
+  return lines.join("\n");
+}
+
 // src/config.ts
 import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
 import { join as join5 } from "path";
@@ -2229,6 +2556,7 @@ var { values, positionals } = parseArgs({
     "archive-twine1": { type: "boolean" },
     "twee2-compat": { type: "boolean" },
     "no-trim": { type: "boolean" },
+    lint: { type: "boolean" },
     test: { type: "boolean", short: "t" },
     watch: { type: "boolean", short: "w" },
     "log-stats": { type: "boolean", short: "l" },
@@ -2297,6 +2625,27 @@ async function main() {
       tagAliases[pair.slice(0, eq)] = pair.slice(eq + 1);
     }
   }
+  if (values.lint) {
+    const lintResult = await lint({
+      sources,
+      formatId: values.format ?? config?.formatId,
+      startPassage: values.start ?? config?.startPassage,
+      formatPaths: config?.formatPaths,
+      modules: values.module ?? config?.modules,
+      headFile: values.head ?? config?.headFile,
+      trim: values["no-trim"] ? false : config?.trim ?? true,
+      twee2Compat: values["twee2-compat"] ?? config?.twee2Compat ?? false,
+      testMode: values.test ?? config?.testMode ?? false,
+      formatIndices: values["format-index"] ?? config?.formatIndices,
+      formatUrls: values["format-url"] ?? config?.formatUrls,
+      noRemote: values["no-remote"] ?? config?.noRemote ?? false,
+      tagAliases,
+      sourceInfo: values["source-info"] ?? config?.sourceInfo ?? false
+    });
+    console.log(formatLintReport(lintResult));
+    const hasErrors = lintResult.brokenLinks.length > 0 || lintResult.diagnostics.some((d) => d.level === "error");
+    process.exit(hasErrors ? 1 : 0);
+  }
   const compileOptions = {
     sources,
     outputMode,
@@ -2429,6 +2778,7 @@ Options:
   --archive-twine1          Output as Twine 1 archive
   --json                    Output as JSON
   --twee2-compat            Enable Twee2 syntax compatibility
+  --lint                    Lint story structure (broken links, dead ends, orphans)
   --no-trim                 Don't trim passage whitespace
   -t, --test                Enable test/debug mode
   -w, --watch               Watch for changes and rebuild