@rohal12/twee-ts 1.5.0 → 1.7.0

package/dist/index.cjs

@@ -30,9 +30,11 @@ __export(src_exports, {
   discoverFormats: () => discoverFormats,
   fetchAndCacheFormat: () => fetchAndCacheFormat,
   fetchDirectFormat: () => fetchDirectFormat,
+  formatLintReport: () => formatLintReport,
   generateIFID: () => generateIFID,
   getCacheDir: () => getCacheDir,
   getFormatSearchDirs: () => getFormatSearchDirs,
+  lint: () => lint,
   loadConfig: () => loadConfig,
   loadConfigFile: () => loadConfigFile,
   parseFormatJSON: () => parseFormatJSON,
@@ -50,7 +52,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/compiler.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 
 // src/ifid.ts
 var import_node_crypto = require("crypto");
@@ -309,8 +311,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: [],
@@ -326,16 +341,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({
@@ -346,9 +362,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",
@@ -638,11 +660,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) {
@@ -652,7 +678,8 @@ function watchFilesystem(pathnames, outFilename, callback) {
         const abs = (0, import_node_path2.resolve)(pathname, filename);
         if (abs === absOutFile) return;
         if (isKnownFileType(filename)) {
-          scheduleBuild();
+          const rel = (0, import_node_path2.relative)(process.cwd(), abs);
+          scheduleBuild(rel || abs);
         }
       });
       watchers.push(watcher);
@@ -911,6 +938,7 @@ function readFormatSource(format) {
 
 // src/loader.ts
 var import_node_path5 = require("path");
+var import_node_fs4 = require("fs");
 
 // src/lexer.ts
 var EOF = -1;
@@ -1434,54 +1462,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: (0, import_node_path5.basename)(filename), tags: [tag], text: source }, diagnostics);
+  return { passages: [{ name: (0, import_node_path5.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 = (0, import_node_path5.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 = (0, import_node_fs4.statSync)(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
@@ -1591,7 +1747,7 @@ function ensureIFID(story, diagnostics) {
 }
 
 // src/output-twine1.ts
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path6 = require("path");
 var CREATOR_NAME2 = "twee-ts";
 function toTwine1Archive(story, _startName) {
@@ -1624,7 +1780,7 @@ function toTwine1HTML(story, format, startName, _diagnostics) {
   } else {
     let footer;
     try {
-      footer = (0, import_node_fs4.readFileSync)((0, import_node_path6.join)(formatDir, "footer.html"), "utf-8");
+      footer = (0, import_node_fs5.readFileSync)((0, import_node_path6.join)(formatDir, "footer.html"), "utf-8");
     } catch {
       footer = "</div>\n</body>\n</html>\n";
     }
@@ -1654,7 +1810,7 @@ function getTwine1PassageChunk(story) {
 function tryReplaceComponent(template, placeholder, componentPath, required) {
   if (!template.includes(placeholder)) return template;
   try {
-    let content = (0, import_node_fs4.readFileSync)(componentPath, "utf-8");
+    let content = (0, import_node_fs5.readFileSync)(componentPath, "utf-8");
     if (content.charCodeAt(0) === 65279) content = content.slice(1);
     return template.replace(placeholder, content);
   } catch (e) {
@@ -1750,7 +1906,7 @@ function modifyHead(html, modulePaths, headFile, diagnostics) {
 }
 
 // src/remote-formats.ts
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_path7 = require("path");
 var import_node_os2 = require("os");
 var DEFAULT_SFA_INDICES = [
@@ -1851,9 +2007,9 @@ async function fetchAndCacheFormat(entry, downloadUrl) {
   }
   const cacheDir = getCacheDir();
   const formatDir = (0, import_node_path7.join)(cacheDir, entry.name, entry.version);
-  (0, import_node_fs5.mkdirSync)(formatDir, { recursive: true });
+  (0, import_node_fs6.mkdirSync)(formatDir, { recursive: true });
   const formatPath = (0, import_node_path7.join)(formatDir, "format.js");
-  (0, import_node_fs5.writeFileSync)(formatPath, text, "utf-8");
+  (0, import_node_fs6.writeFileSync)(formatPath, text, "utf-8");
   return {
     id,
     filename: formatPath,
@@ -1877,9 +2033,9 @@ async function fetchDirectFormat(url) {
   const id = makeFormatId(data.name, data.version);
   const cacheDir = getCacheDir();
   const formatDir = (0, import_node_path7.join)(cacheDir, data.name, data.version);
-  (0, import_node_fs5.mkdirSync)(formatDir, { recursive: true });
+  (0, import_node_fs6.mkdirSync)(formatDir, { recursive: true });
   const formatPath = (0, import_node_path7.join)(formatDir, "format.js");
-  (0, import_node_fs5.writeFileSync)(formatPath, text, "utf-8");
+  (0, import_node_fs6.writeFileSync)(formatPath, text, "utf-8");
   return {
     id,
     filename: formatPath,
@@ -1928,8 +2084,8 @@ async function resolveRemoteFormat(name, version, indices, urls) {
 function getCachedFormat(name, version) {
   const formatPath = (0, import_node_path7.join)(getCacheDir(), name, version, "format.js");
   try {
-    if (!(0, import_node_fs5.existsSync)(formatPath)) return void 0;
-    const source = (0, import_node_fs5.readFileSync)(formatPath, "utf-8");
+    if (!(0, import_node_fs6.existsSync)(formatPath)) return void 0;
+    const source = (0, import_node_fs6.readFileSync)(formatPath, "utf-8");
     const id = makeFormatId(name, version);
     const data = parseFormatJSON(source, id);
     if (!data) return void 0;
@@ -1949,26 +2105,26 @@ function discoverCachedFormats() {
   const formats = /* @__PURE__ */ new Map();
   const cacheDir = getCacheDir();
   try {
-    if (!(0, import_node_fs5.existsSync)(cacheDir)) return formats;
+    if (!(0, import_node_fs6.existsSync)(cacheDir)) return formats;
   } catch {
     return formats;
   }
   let names;
   try {
-    names = (0, import_node_fs5.readdirSync)(cacheDir);
+    names = (0, import_node_fs6.readdirSync)(cacheDir);
   } catch {
     return formats;
   }
   for (const name of names) {
     const nameDir = (0, import_node_path7.join)(cacheDir, name);
     try {
-      if (!(0, import_node_fs5.statSync)(nameDir).isDirectory()) continue;
+      if (!(0, import_node_fs6.statSync)(nameDir).isDirectory()) continue;
     } catch {
       continue;
     }
     let versions;
     try {
-      versions = (0, import_node_fs5.readdirSync)(nameDir);
+      versions = (0, import_node_fs6.readdirSync)(nameDir);
     } catch {
       continue;
     }
@@ -1998,17 +2154,18 @@ async function compile(options) {
 }
 async function compileToFile(options) {
   const result = await compile(options);
-  (0, import_node_fs6.writeFileSync)(options.outFile, result.output, "utf-8");
+  (0, import_node_fs7.writeFileSync)(options.outFile, result.output, "utf-8");
   return result;
 }
 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) => {
-      (0, import_node_fs6.writeFileSync)(options.outFile, result.output, "utf-8");
+  const handle = watchFilesystem(allPaths, options.outFile, (changedFiles) => {
+    buildOutput(options, cache, changedFiles).then((result) => {
+      (0, import_node_fs7.writeFileSync)(options.outFile, result.output, "utf-8");
       options.onBuild?.(result);
     }).catch((e) => {
       options.onError?.(e instanceof Error ? e : new Error(String(e)));
@@ -2017,7 +2174,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;
@@ -2038,7 +2195,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);
@@ -2278,18 +2439,81 @@ function storyInspect(story) {
   };
 }
 
+// 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
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path8 = require("path");
 var CONFIG_FILENAME = "twee-ts.config.json";
 var VALID_OUTPUT_MODES = ["html", "twee3", "twee1", "twine2-archive", "twine1-archive", "json"];
 function loadConfig(dir) {
   const base = dir ?? process.cwd();
   const configPath = (0, import_node_path8.join)(base, CONFIG_FILENAME);
-  if (!(0, import_node_fs7.existsSync)(configPath)) return null;
+  if (!(0, import_node_fs8.existsSync)(configPath)) return null;
   let raw;
   try {
-    raw = (0, import_node_fs7.readFileSync)(configPath, "utf-8");
+    raw = (0, import_node_fs8.readFileSync)(configPath, "utf-8");
   } catch {
     return null;
   }
@@ -2309,7 +2533,7 @@ function loadConfig(dir) {
 function loadConfigFile(filePath) {
   let raw;
   try {
-    raw = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+    raw = (0, import_node_fs8.readFileSync)(filePath, "utf-8");
   } catch (e) {
     throw new Error(`Cannot read config file ${filePath}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -2390,9 +2614,11 @@ function scaffoldConfig() {
   discoverFormats,
   fetchAndCacheFormat,
   fetchDirectFormat,
+  formatLintReport,
   generateIFID,
   getCacheDir,
   getFormatSearchDirs,
+  lint,
   loadConfig,
   loadConfigFile,
   parseFormatJSON,