@mnaoumov/typescript-dev-toolkit 3.6.4 → 3.7.0

package/dist/lib/cjs/docs-site/docs-snippets.cjs

@@ -0,0 +1,310 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var docs_snippets_exports = {};
+__export(docs_snippets_exports, {
+  assertDocsSnippetsCompile: () => assertDocsSnippetsCompile,
+  extractDocsSnippets: () => extractDocsSnippets,
+  findDocsSnippetProblems: () => findDocsSnippetProblems,
+  formatDocsSnippetProblems: () => formatDocsSnippetProblems
+});
+module.exports = __toCommonJS(docs_snippets_exports);
+var import_promises = require('node:fs/promises');
+var import_node_path = require('node:path');
+var import_typescript = require('typescript');
+const CHECKED_LANGUAGES = /* @__PURE__ */ new Map([
+  ["javascript", true],
+  ["js", true],
+  ["ts", false],
+  ["typescript", false]
+]);
+const LINE_AFTER_FENCE_OFFSET = 2;
+const MARKER_REG_EXP = /^<!--\s*snippet-check:\s*(?<kind>[a-z]+)\b(?<text>.*?)-->$/su;
+const DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ = 6133;
+const DIAGNOSTIC_ALL_IMPORTS_UNUSED = 6192;
+const DIAGNOSTIC_DECLARED_BUT_NEVER_USED = 6196;
+const DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED = 6198;
+const IGNORED_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED,
+  DIAGNOSTIC_ALL_IMPORTS_UNUSED,
+  DIAGNOSTIC_DECLARED_BUT_NEVER_USED,
+  DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ
+]);
+const DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY = 7005;
+const DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY = 7006;
+const DIAGNOSTIC_MEMBER_IMPLICITLY_ANY = 7008;
+const DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY = 7031;
+const DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS = 7034;
+const DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS = 7041;
+const DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY = 7053;
+const JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS,
+  DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY,
+  DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY,
+  DIAGNOSTIC_MEMBER_IMPLICITLY_ANY,
+  DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY,
+  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY,
+  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS
+]);
+async function assertDocsSnippetsCompile(params) {
+  const problems = await findDocsSnippetProblems(params);
+  if (problems.length > 0) {
+    throw new Error(`${String(problems.length)} problem(s) in the documentation snippets:
+${formatDocsSnippetProblems(problems)}`);
+  }
+}
+function extractDocsSnippets(markdown) {
+  const lines = markdown.split(/\r?\n/u);
+  const snippets = [];
+  let openFence = null;
+  let codeLines = [];
+  let pendingSkipReason = null;
+  let pendingContext = [];
+  for (const [index, line] of lines.entries()) {
+    if (openFence) {
+      const content = stripPrefix(line, openFence.prefix);
+      if (content.trimEnd() === openFence.fence) {
+        const isJavaScript = CHECKED_LANGUAGES.get(openFence.language);
+        if (isJavaScript !== void 0) {
+          snippets.push({
+            code: codeLines.join("\n"),
+            codeStartLine: openFence.startLine,
+            context: openFence.context.join("\n"),
+            isJavaScript,
+            language: openFence.language,
+            skipReason: openFence.skipReason
+          });
+        }
+        openFence = null;
+        codeLines = [];
+      } else {
+        codeLines.push(content);
+      }
+      continue;
+    }
+    const fenceMatch = /^(?<prefix>(?:\s*>)*\s*)(?<fence>`{3,}|~{3,})(?<language>[\w-]*)/u.exec(line);
+    if (fenceMatch?.groups) {
+      openFence = {
+        context: pendingContext,
+        fence: fenceMatch.groups["fence"] ?? "",
+        language: (fenceMatch.groups["language"] ?? "").toLowerCase(),
+        prefix: fenceMatch.groups["prefix"] ?? "",
+        skipReason: pendingSkipReason,
+        startLine: index + LINE_AFTER_FENCE_OFFSET
+      };
+      pendingSkipReason = null;
+      pendingContext = [];
+      continue;
+    }
+    const text = line.replace(/^(?:\s*>)*\s*/u, "").trim();
+    const markerMatch = MARKER_REG_EXP.exec(text);
+    const kind = markerMatch?.groups?.["kind"];
+    const markerText = (markerMatch?.groups?.["text"] ?? "").trim();
+    if (kind === "skip") {
+      pendingSkipReason = markerText.replace(/^[-—:]\s*/u, "");
+    } else if (kind === "context") {
+      pendingContext.push(markerText);
+    } else if (text !== "") {
+      pendingSkipReason = null;
+      pendingContext = [];
+    }
+  }
+  return snippets;
+}
+async function findDocsSnippetProblems(params) {
+  const rootDirectory = (0, import_node_path.resolve)(params.rootDirectory);
+  const docsDirectory = (0, import_node_path.join)(rootDirectory, params.docsDirectory ?? "docs/src/content/docs");
+  const problems = [];
+  const virtualFiles = /* @__PURE__ */ new Map();
+  const rootNames = [];
+  const snippetsDirectory = (0, import_node_path.join)(rootDirectory, "docs", "__snippets__");
+  function addVirtualFile(path, file) {
+    virtualFiles.set(normalizePath(path), file);
+    rootNames.push(path);
+  }
+  const prelude = params.prelude ?? "";
+  if (prelude !== "") {
+    addVirtualFile((0, import_node_path.join)(snippetsDirectory, "prelude.ts"), { code: prelude, codeStartLine: 1, contextLineCount: 0, filePath: "<prelude>" });
+  }
+  for (const guidePath of await listGuides(docsDirectory)) {
+    const filePath = toPosix((0, import_node_path.relative)(rootDirectory, guidePath));
+    const markdown = await (0, import_promises.readFile)(guidePath, "utf-8");
+    for (const snippet of extractDocsSnippets(markdown)) {
+      if (snippet.skipReason === "") {
+        problems.push({
+          filePath,
+          line: snippet.codeStartLine - 1,
+          message: "A `snippet-check: skip` marker must give its reason."
+        });
+        continue;
+      }
+      if (snippet.skipReason !== null) {
+        continue;
+      }
+      const extension = snippet.isJavaScript ? "js" : "ts";
+      const baseName = `${toPosix((0, import_node_path.relative)(docsDirectory, guidePath)).replaceAll("/", "__")}.L${String(snippet.codeStartLine)}.${extension}`;
+      const context = snippet.context === "" ? "" : `${snippet.context}
+`;
+      addVirtualFile((0, import_node_path.join)(snippetsDirectory, baseName), {
+        code: `${context}${snippet.code}
+export {};
+`,
+        codeStartLine: snippet.codeStartLine,
+        contextLineCount: context === "" ? 0 : context.split("\n").length - 1,
+        filePath
+      });
+    }
+  }
+  problems.push(...compileSnippets({ compilerOptions: params.compilerOptions ?? {}, rootDirectory, rootNames, virtualFiles }));
+  return problems;
+}
+function formatDocsSnippetProblems(problems) {
+  return problems.map((problem) => `${problem.filePath}:${String(problem.line)} - ${problem.message}`).join("\n");
+}
+function compileSnippets(params) {
+  const { rootDirectory, rootNames, virtualFiles } = params;
+  const configPath = (0, import_node_path.join)(rootDirectory, "tsconfig.json");
+  const parsed = (0, import_typescript.getParsedCommandLineOfConfigFile)(configPath, {}, {
+    ...import_typescript.sys,
+    onUnRecoverableConfigFileDiagnostic(diagnostic) {
+      throw new Error((0, import_typescript.flattenDiagnosticMessageText)(diagnostic.messageText, "\n"));
+    }
+  });
+  if (!parsed) {
+    throw new Error(`Cannot read ${configPath}`);
+  }
+  const compilerOptions = {
+    ...parsed.options,
+    ...params.compilerOptions,
+    allowJs: true,
+    checkJs: true,
+    composite: false,
+    incremental: false,
+    noEmit: true,
+    noUnusedLocals: false,
+    noUnusedParameters: false
+  };
+  delete compilerOptions.tsBuildInfoFile;
+  const host = (0, import_typescript.createCompilerHost)(compilerOptions, true);
+  const originalGetSourceFile = host.getSourceFile.bind(host);
+  const originalFileExists = host.fileExists.bind(host);
+  const originalReadFile = host.readFile.bind(host);
+  host.fileExists = (fileName) => virtualFiles.has(normalizePath(fileName)) || originalFileExists(fileName);
+  host.readFile = (fileName) => virtualFiles.get(normalizePath(fileName))?.code ?? originalReadFile(fileName);
+  host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+    const virtualFile = virtualFiles.get(normalizePath(fileName));
+    if (virtualFile) {
+      const scriptKind = fileName.endsWith(".js") ? import_typescript.ScriptKind.JS : import_typescript.ScriptKind.TS;
+      return (0, import_typescript.createSourceFile)(fileName, virtualFile.code, languageVersionOrOptions, true, scriptKind);
+    }
+    return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+  };
+  const program = (0, import_typescript.createProgram)({ host, options: compilerOptions, rootNames });
+  const problems = [];
+  for (const rootName of rootNames) {
+    const sourceFile = program.getSourceFile(rootName);
+    const virtualFile = virtualFiles.get(normalizePath(rootName));
+    if (!sourceFile || !virtualFile) {
+      continue;
+    }
+    const isJavaScript = rootName.endsWith(".js");
+    const diagnostics = [...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile)];
+    for (const diagnostic of diagnostics) {
+      if (IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code) || isJavaScript && JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code)) {
+        continue;
+      }
+      const fileLine = diagnostic.start === void 0 ? 0 : sourceFile.getLineAndCharacterOfPosition(diagnostic.start).line;
+      const snippetLine = Math.max(0, fileLine - virtualFile.contextLineCount);
+      problems.push({
+        filePath: virtualFile.filePath,
+        line: virtualFile.codeStartLine + snippetLine,
+        message: `TS${String(diagnostic.code)}: ${(0, import_typescript.flattenDiagnosticMessageText)(diagnostic.messageText, " ")}`
+      });
+    }
+  }
+  return problems;
+}
+async function listGuides(directory) {
+  const guides = [];
+  for (const entry of await (0, import_promises.readdir)(directory, { withFileTypes: true })) {
+    const entryPath = (0, import_node_path.join)(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== "api") {
+        guides.push(...await listGuides(entryPath));
+      }
+    } else if (/\.mdx?$/u.test(entry.name)) {
+      guides.push(entryPath);
+    }
+  }
+  return guides.sort();
+}
+function normalizePath(path) {
+  return toPosix((0, import_node_path.resolve)(path)).toLowerCase();
+}
+function stripPrefix(line, prefix) {
+  return line.startsWith(prefix) ? line.slice(prefix.length) : line.replace(/^(?:\s*>)*\s?/u, "");
+}
+function toPosix(path) {
+  return path.replaceAll("\\", "/");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertDocsSnippetsCompile,
+  extractDocsSnippets,
+  findDocsSnippetProblems,
+  formatDocsSnippetProblems
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/docs-snippets.ts"],"sourcesContent":["/**\n * @file\n *\n * Extracts the code snippets of a package's documentation guides and type-checks them against its sources.\n *\n * A guide's snippet is code a reader copies, so a renamed member or a stale import path in it is a bug that ships\n * to the site with every check green. Every fenced `ts`, `typescript`, `js` or `javascript` block in\n * `docs/src/content/docs` is compiled as its own module, with the project's `tsconfig.json`, so an import of the\n * package's own name resolves wherever that configuration sends it (its `paths`, or the `compilerOptions` passed\n * here) and a wrong name fails. A `ts` / `typescript` block is compiled as TypeScript; a `js` / `javascript` block,\n * often a devtools-console recipe, is compiled as JavaScript with `checkJs`, so a wrong member of a typed object\n * still fails while an untyped lookup does not. The generated API reference (`docs/src/content/docs/api`) is\n * skipped: it is rendered from the TSDoc.\n *\n * Three things shape what a snippet is compiled with, each but the first written in the guide as an HTML comment,\n * invisible on the site, on the lines right above the fence:\n *\n * - The names every guide may use without declaring them are the package's `prelude`, compiled as a module of its\n *   own (a `declare global` block, with the imports it needs).\n * - `<!-- snippet-check: context <TypeScript> -->` prepends declarations to that one snippet, for the names its\n *   prose has already introduced (`declare const linkEl: HTMLAnchorElement;`). Several such lines add up.\n * - `<!-- snippet-check: skip <reason> -->` exempts a snippet that is deliberately not compilable, such as\n *   pseudo-code. The reason is required, so a skip is a decision somebody wrote down, never a silent hole.\n */\n\nimport type {\n  CompilerOptions,\n  SourceFile\n} from 'typescript';\n\nimport {\n  readdir,\n  readFile\n} from 'node:fs/promises';\nimport {\n  join,\n  relative,\n  resolve\n} from 'node:path';\nimport {\n  createCompilerHost,\n  createProgram,\n  createSourceFile,\n  flattenDiagnosticMessageText,\n  getParsedCommandLineOfConfigFile,\n  ScriptKind,\n  sys\n} from 'typescript';\n\n/**\n * The languages of the fenced blocks that are type-checked, and whether each is JavaScript.\n */\nconst CHECKED_LANGUAGES: ReadonlyMap<string, boolean> = new Map([\n  ['javascript', true],\n  ['js', true],\n  ['ts', false],\n  ['typescript', false]\n]);\n\n/**\n * The offset from a fence line's 0-based index to the 1-based line of the code after it.\n */\nconst LINE_AFTER_FENCE_OFFSET = 2;\n\nconst MARKER_REG_EXP = /^<!--\\s*snippet-check:\\s*(?<kind>[a-z]+)\\b(?<text>.*?)-->$/su;\n\n/**\n * Diagnostics a snippet is not held to: an illustration declares names it never reads.\n */\nconst DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ = 6133;\nconst DIAGNOSTIC_ALL_IMPORTS_UNUSED = 6192;\nconst DIAGNOSTIC_DECLARED_BUT_NEVER_USED = 6196;\nconst DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED = 6198;\nconst IGNORED_DIAGNOSTIC_CODES = new Set([\n  DIAGNOSTIC_ALL_DESTRUCTURED_ELEMENTS_UNUSED,\n  DIAGNOSTIC_ALL_IMPORTS_UNUSED,\n  DIAGNOSTIC_DECLARED_BUT_NEVER_USED,\n  DIAGNOSTIC_DECLARED_BUT_VALUE_NEVER_READ\n]);\n\n/**\n * The implicit-`any` diagnostics, which a JavaScript snippet is not held to: a console recipe has no annotations to\n * give, and an untyped lookup such as a `Symbol.for` slot on `globalThis` is what plain JavaScript does.\n */\nconst DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY = 7005;\nconst DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY = 7006;\nconst DIAGNOSTIC_MEMBER_IMPLICITLY_ANY = 7008;\nconst DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY = 7031;\nconst DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS = 7034;\nconst DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS = 7041;\nconst DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY = 7053;\nconst JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES = new Set([\n  DIAGNOSTIC_ARROW_FUNCTION_CAPTURES_GLOBAL_THIS,\n  DIAGNOSTIC_BINDING_ELEMENT_IMPLICITLY_ANY,\n  DIAGNOSTIC_ELEMENT_IMPLICITLY_ANY,\n  DIAGNOSTIC_MEMBER_IMPLICITLY_ANY,\n  DIAGNOSTIC_PARAMETER_IMPLICITLY_ANY,\n  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY,\n  DIAGNOSTIC_VARIABLE_IMPLICITLY_ANY_IN_SOME_LOCATIONS\n]);\n\n/**\n * Parameters for {@link assertDocsSnippetsCompile}: the same as {@link findDocsSnippetProblems} takes.\n */\nexport type AssertDocsSnippetsCompileParams = FindDocsSnippetProblemsParams;\n\n/**\n * One fenced code block of a guide.\n */\nexport interface DocsSnippet {\n  /**\n   * The code, with any blockquote or indentation prefix of the fence stripped.\n   */\n  readonly code: string;\n\n  /**\n   * The 1-based line of the guide on which the code starts (the line after the opening fence).\n   */\n  readonly codeStartLine: number;\n\n  /**\n   * The declarations of the `snippet-check: context` markers above the fence, joined by newlines.\n   */\n  readonly context: string;\n\n  /**\n   * Whether the snippet is JavaScript rather than TypeScript.\n   */\n  readonly isJavaScript: boolean;\n\n  /**\n   * The language of the fence.\n   */\n  readonly language: string;\n\n  /**\n   * The reason given by a `snippet-check: skip` marker, or `null` when the snippet is checked.\n   */\n  readonly skipReason: null | string;\n}\n\n/**\n * A problem found in a guide's snippet.\n */\nexport interface DocsSnippetProblem {\n  /**\n   * The guide's path, relative to the package root.\n   */\n  readonly filePath: string;\n\n  /**\n   * The 1-based line of the guide.\n   */\n  readonly line: number;\n\n  /**\n   * What is wrong.\n   */\n  readonly message: string;\n}\n\n/**\n * Parameters for {@link findDocsSnippetProblems}.\n */\nexport interface FindDocsSnippetProblemsParams {\n  /**\n   * Compiler options laid over the ones `tsconfig.json` gives, for instance `paths` that resolve the package's own\n   * name onto its sources when its `tsconfig.json` has none. A relative path in them is not resolved, so pass\n   * absolute ones.\n   */\n  readonly compilerOptions?: CompilerOptions;\n\n  /**\n   * The guides directory, relative to {@link FindDocsSnippetProblemsParams.rootDirectory}.\n   *\n   * @default `'docs/src/content/docs'`\n   */\n  readonly docsDirectory?: string;\n\n  /**\n   * The ambient context every snippet is compiled with: the names a guide may use without declaring them, written as\n   * a module (`declare global { ... }`, with the imports it needs).\n   *\n   * @default `''`, no prelude.\n   */\n  readonly prelude?: string;\n\n  /**\n   * The package root, holding `tsconfig.json`.\n   */\n  readonly rootDirectory: string;\n}\n\ninterface CompileSnippetsParams {\n  readonly compilerOptions: CompilerOptions;\n  readonly rootDirectory: string;\n  readonly rootNames: readonly string[];\n  readonly virtualFiles: ReadonlyMap<string, VirtualSnippetFile>;\n}\n\ninterface OpenFence {\n  readonly context: string[];\n  readonly fence: string;\n  readonly language: string;\n  readonly prefix: string;\n  readonly skipReason: null | string;\n  readonly startLine: number;\n}\n\ninterface VirtualSnippetFile {\n  readonly code: string;\n  readonly codeStartLine: number;\n  readonly contextLineCount: number;\n  readonly filePath: string;\n}\n\n/**\n * Type-checks every snippet of the guides and throws when one fails, for a `docs:check-snippets` script.\n *\n * @param params - The {@link AssertDocsSnippetsCompileParams}.\n * @returns A promise that resolves when every snippet compiles.\n * @throws {Error} Listing every problem, one per line.\n */\nexport async function assertDocsSnippetsCompile(params: AssertDocsSnippetsCompileParams): Promise<void> {\n  const problems = await findDocsSnippetProblems(params);\n  if (problems.length > 0) {\n    throw new Error(`${String(problems.length)} problem(s) in the documentation snippets:\\n${formatDocsSnippetProblems(problems)}`);\n  }\n}\n\n/**\n * Extracts the fenced code blocks of the checked languages from a markdown document.\n *\n * A fence inside a blockquote or a list item is recognized too: its prefix (`> `, indentation) is stripped from\n * every line of its code.\n *\n * @param markdown - The markdown document.\n * @returns The snippets, in document order.\n */\nexport function extractDocsSnippets(markdown: string): DocsSnippet[] {\n  const lines = markdown.split(/\\r?\\n/u);\n  const snippets: DocsSnippet[] = [];\n  let openFence: null | OpenFence = null;\n  let codeLines: string[] = [];\n  let pendingSkipReason: null | string = null;\n  let pendingContext: string[] = [];\n\n  for (const [index, line] of lines.entries()) {\n    if (openFence) {\n      const content = stripPrefix(line, openFence.prefix);\n      if (content.trimEnd() === openFence.fence) {\n        const isJavaScript = CHECKED_LANGUAGES.get(openFence.language);\n        if (isJavaScript !== undefined) {\n          snippets.push({\n            code: codeLines.join('\\n'),\n            codeStartLine: openFence.startLine,\n            context: openFence.context.join('\\n'),\n            isJavaScript,\n            language: openFence.language,\n            skipReason: openFence.skipReason\n          });\n        }\n        openFence = null;\n        codeLines = [];\n      } else {\n        codeLines.push(content);\n      }\n      continue;\n    }\n\n    const fenceMatch = /^(?<prefix>(?:\\s*>)*\\s*)(?<fence>`{3,}|~{3,})(?<language>[\\w-]*)/u.exec(line);\n    if (fenceMatch?.groups) {\n      /* v8 ignore start -- Every group of the fence pattern takes part in a match, so the fallbacks never apply. */\n      openFence = {\n        context: pendingContext,\n        fence: fenceMatch.groups['fence'] ?? '',\n        language: (fenceMatch.groups['language'] ?? '').toLowerCase(),\n        prefix: fenceMatch.groups['prefix'] ?? '',\n        skipReason: pendingSkipReason,\n        startLine: index + LINE_AFTER_FENCE_OFFSET\n      };\n      /* v8 ignore stop */\n      pendingSkipReason = null;\n      pendingContext = [];\n      continue;\n    }\n\n    const text = line.replace(/^(?:\\s*>)*\\s*/u, '').trim();\n    const markerMatch = MARKER_REG_EXP.exec(text);\n    const kind = markerMatch?.groups?.['kind'];\n    const markerText = (markerMatch?.groups?.['text'] ?? '').trim();\n    if (kind === 'skip') {\n      pendingSkipReason = markerText.replace(/^[-—:]\\s*/u, '');\n    } else if (kind === 'context') {\n      pendingContext.push(markerText);\n    } else if (text !== '') {\n      pendingSkipReason = null;\n      pendingContext = [];\n    }\n  }\n\n  return snippets;\n}\n\n/**\n * Type-checks every snippet of the guides.\n *\n * @param params - The {@link FindDocsSnippetProblemsParams}.\n * @returns The problems found, empty when every snippet compiles.\n */\nexport async function findDocsSnippetProblems(params: FindDocsSnippetProblemsParams): Promise<DocsSnippetProblem[]> {\n  const rootDirectory = resolve(params.rootDirectory);\n  const docsDirectory = join(rootDirectory, params.docsDirectory ?? 'docs/src/content/docs');\n  const problems: DocsSnippetProblem[] = [];\n  const virtualFiles = new Map<string, VirtualSnippetFile>();\n  const rootNames: string[] = [];\n  const snippetsDirectory = join(rootDirectory, 'docs', '__snippets__');\n\n  function addVirtualFile(path: string, file: VirtualSnippetFile): void {\n    virtualFiles.set(normalizePath(path), file);\n    rootNames.push(path);\n  }\n\n  const prelude = params.prelude ?? '';\n  if (prelude !== '') {\n    addVirtualFile(join(snippetsDirectory, 'prelude.ts'), { code: prelude, codeStartLine: 1, contextLineCount: 0, filePath: '<prelude>' });\n  }\n\n  for (const guidePath of await listGuides(docsDirectory)) {\n    const filePath = toPosix(relative(rootDirectory, guidePath));\n    const markdown = await readFile(guidePath, 'utf-8');\n    for (const snippet of extractDocsSnippets(markdown)) {\n      if (snippet.skipReason === '') {\n        problems.push({\n          filePath,\n          line: snippet.codeStartLine - 1,\n          message: 'A `snippet-check: skip` marker must give its reason.'\n        });\n        continue;\n      }\n      if (snippet.skipReason !== null) {\n        continue;\n      }\n      const extension = snippet.isJavaScript ? 'js' : 'ts';\n      const baseName = `${toPosix(relative(docsDirectory, guidePath)).replaceAll('/', '__')}.L${String(snippet.codeStartLine)}.${extension}`;\n      const context = snippet.context === '' ? '' : `${snippet.context}\\n`;\n      addVirtualFile(join(snippetsDirectory, baseName), {\n        code: `${context}${snippet.code}\\nexport {};\\n`,\n        codeStartLine: snippet.codeStartLine,\n        contextLineCount: context === '' ? 0 : context.split('\\n').length - 1,\n        filePath\n      });\n    }\n  }\n\n  problems.push(...compileSnippets({ compilerOptions: params.compilerOptions ?? {}, rootDirectory, rootNames, virtualFiles }));\n  return problems;\n}\n\n/**\n * Formats problems one per line, as `path:line - message`.\n *\n * @param problems - The problems.\n * @returns The formatted text.\n */\nexport function formatDocsSnippetProblems(problems: readonly DocsSnippetProblem[]): string {\n  return problems.map((problem) => `${problem.filePath}:${String(problem.line)} - ${problem.message}`).join('\\n');\n}\n\nfunction compileSnippets(params: CompileSnippetsParams): DocsSnippetProblem[] {\n  const { rootDirectory, rootNames, virtualFiles } = params;\n  const configPath = join(rootDirectory, 'tsconfig.json');\n  const parsed = getParsedCommandLineOfConfigFile(configPath, {}, {\n    ...sys,\n    onUnRecoverableConfigFileDiagnostic(diagnostic) {\n      throw new Error(flattenDiagnosticMessageText(diagnostic.messageText, '\\n'));\n    }\n  });\n  /* v8 ignore start -- An unreadable configuration throws in the handler above before this can be reached. */\n  if (!parsed) {\n    throw new Error(`Cannot read ${configPath}`);\n  }\n  /* v8 ignore stop */\n\n  const compilerOptions: CompilerOptions = {\n    ...parsed.options,\n    ...params.compilerOptions,\n    allowJs: true,\n    checkJs: true,\n    composite: false,\n    incremental: false,\n    noEmit: true,\n    noUnusedLocals: false,\n    noUnusedParameters: false\n  };\n  delete compilerOptions.tsBuildInfoFile;\n\n  const host = createCompilerHost(compilerOptions, true);\n  const originalGetSourceFile = host.getSourceFile.bind(host);\n  const originalFileExists = host.fileExists.bind(host);\n  const originalReadFile = host.readFile.bind(host);\n  host.fileExists = (fileName): boolean => virtualFiles.has(normalizePath(fileName)) || originalFileExists(fileName);\n  host.readFile = (fileName): string | undefined => virtualFiles.get(normalizePath(fileName))?.code ?? originalReadFile(fileName);\n  host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile): SourceFile | undefined => {\n    const virtualFile = virtualFiles.get(normalizePath(fileName));\n    if (virtualFile) {\n      const scriptKind = fileName.endsWith('.js') ? ScriptKind.JS : ScriptKind.TS;\n      return createSourceFile(fileName, virtualFile.code, languageVersionOrOptions, true, scriptKind);\n    }\n    return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);\n  };\n\n  const program = createProgram({ host, options: compilerOptions, rootNames });\n  const problems: DocsSnippetProblem[] = [];\n  for (const rootName of rootNames) {\n    const sourceFile = program.getSourceFile(rootName);\n    const virtualFile = virtualFiles.get(normalizePath(rootName));\n    /* v8 ignore start -- Every root name is a virtual file the program was built from. */\n    if (!sourceFile || !virtualFile) {\n      continue;\n    }\n    /* v8 ignore stop */\n    const isJavaScript = rootName.endsWith('.js');\n    const diagnostics = [...program.getSyntacticDiagnostics(sourceFile), ...program.getSemanticDiagnostics(sourceFile)];\n    for (const diagnostic of diagnostics) {\n      if (IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code) || (isJavaScript && JAVASCRIPT_IGNORED_DIAGNOSTIC_CODES.has(diagnostic.code))) {\n        continue;\n      }\n      /* v8 ignore next -- A diagnostic of one source file always carries its position. */\n      const fileLine = diagnostic.start === undefined ? 0 : sourceFile.getLineAndCharacterOfPosition(diagnostic.start).line;\n      const snippetLine = Math.max(0, fileLine - virtualFile.contextLineCount);\n      problems.push({\n        filePath: virtualFile.filePath,\n        line: virtualFile.codeStartLine + snippetLine,\n        message: `TS${String(diagnostic.code)}: ${flattenDiagnosticMessageText(diagnostic.messageText, ' ')}`\n      });\n    }\n  }\n  return problems;\n}\n\nasync function listGuides(directory: string): Promise<string[]> {\n  const guides: string[] = [];\n  for (const entry of await readdir(directory, { withFileTypes: true })) {\n    const entryPath = join(directory, entry.name);\n    if (entry.isDirectory()) {\n      if (entry.name !== 'api') {\n        guides.push(...await listGuides(entryPath));\n      }\n    } else if (/\\.mdx?$/u.test(entry.name)) {\n      guides.push(entryPath);\n    }\n  }\n  return guides.sort();\n}\n\nfunction normalizePath(path: string): string {\n  return toPosix(resolve(path)).toLowerCase();\n}\n\nfunction stripPrefix(line: string, prefix: string): string {\n  return line.startsWith(prefix) ? line.slice(prefix.length) : line.replace(/^(?:\\s*>)*\\s?/u, '');\n}\n\nfunction toPosix(path: string): string {\n  return path.replaceAll('\\\\', '/');\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/docs-site/docs-snippets.d.cts

@@ -0,0 +1,136 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Extracts the code snippets of a package's documentation guides and type-checks them against its sources.
+ *
+ * A guide's snippet is code a reader copies, so a renamed member or a stale import path in it is a bug that ships
+ * to the site with every check green. Every fenced `ts`, `typescript`, `js` or `javascript` block in
+ * `docs/src/content/docs` is compiled as its own module, with the project's `tsconfig.json`, so an import of the
+ * package's own name resolves wherever that configuration sends it (its `paths`, or the `compilerOptions` passed
+ * here) and a wrong name fails. A `ts` / `typescript` block is compiled as TypeScript; a `js` / `javascript` block,
+ * often a devtools-console recipe, is compiled as JavaScript with `checkJs`, so a wrong member of a typed object
+ * still fails while an untyped lookup does not. The generated API reference (`docs/src/content/docs/api`) is
+ * skipped: it is rendered from the TSDoc.
+ *
+ * Three things shape what a snippet is compiled with, each but the first written in the guide as an HTML comment,
+ * invisible on the site, on the lines right above the fence:
+ *
+ * - The names every guide may use without declaring them are the package's `prelude`, compiled as a module of its
+ *   own (a `declare global` block, with the imports it needs).
+ * - `<!-- snippet-check: context <TypeScript> -->` prepends declarations to that one snippet, for the names its
+ *   prose has already introduced (`declare const linkEl: HTMLAnchorElement;`). Several such lines add up.
+ * - `<!-- snippet-check: skip <reason> -->` exempts a snippet that is deliberately not compilable, such as
+ *   pseudo-code. The reason is required, so a skip is a decision somebody wrote down, never a silent hole.
+ */
+import type { CompilerOptions } from 'typescript' with { 'resolution-mode': 'import' };
+/**
+ * Parameters for {@link assertDocsSnippetsCompile}: the same as {@link findDocsSnippetProblems} takes.
+ */
+export type AssertDocsSnippetsCompileParams = FindDocsSnippetProblemsParams;
+/**
+ * One fenced code block of a guide.
+ */
+export interface DocsSnippet {
+    /**
+     * The code, with any blockquote or indentation prefix of the fence stripped.
+     */
+    readonly code: string;
+    /**
+     * The 1-based line of the guide on which the code starts (the line after the opening fence).
+     */
+    readonly codeStartLine: number;
+    /**
+     * The declarations of the `snippet-check: context` markers above the fence, joined by newlines.
+     */
+    readonly context: string;
+    /**
+     * Whether the snippet is JavaScript rather than TypeScript.
+     */
+    readonly isJavaScript: boolean;
+    /**
+     * The language of the fence.
+     */
+    readonly language: string;
+    /**
+     * The reason given by a `snippet-check: skip` marker, or `null` when the snippet is checked.
+     */
+    readonly skipReason: null | string;
+}
+/**
+ * A problem found in a guide's snippet.
+ */
+export interface DocsSnippetProblem {
+    /**
+     * The guide's path, relative to the package root.
+     */
+    readonly filePath: string;
+    /**
+     * The 1-based line of the guide.
+     */
+    readonly line: number;
+    /**
+     * What is wrong.
+     */
+    readonly message: string;
+}
+/**
+ * Parameters for {@link findDocsSnippetProblems}.
+ */
+export interface FindDocsSnippetProblemsParams {
+    /**
+     * Compiler options laid over the ones `tsconfig.json` gives, for instance `paths` that resolve the package's own
+     * name onto its sources when its `tsconfig.json` has none. A relative path in them is not resolved, so pass
+     * absolute ones.
+     */
+    readonly compilerOptions?: CompilerOptions;
+    /**
+     * The guides directory, relative to {@link FindDocsSnippetProblemsParams.rootDirectory}.
+     *
+     * @default `'docs/src/content/docs'`
+     */
+    readonly docsDirectory?: string;
+    /**
+     * The ambient context every snippet is compiled with: the names a guide may use without declaring them, written as
+     * a module (`declare global { ... }`, with the imports it needs).
+     *
+     * @default `''`, no prelude.
+     */
+    readonly prelude?: string;
+    /**
+     * The package root, holding `tsconfig.json`.
+     */
+    readonly rootDirectory: string;
+}
+/**
+ * Type-checks every snippet of the guides and throws when one fails, for a `docs:check-snippets` script.
+ *
+ * @param params - The {@link AssertDocsSnippetsCompileParams}.
+ * @returns A promise that resolves when every snippet compiles.
+ * @throws {Error} Listing every problem, one per line.
+ */
+export declare function assertDocsSnippetsCompile(params: AssertDocsSnippetsCompileParams): Promise<void>;
+/**
+ * Extracts the fenced code blocks of the checked languages from a markdown document.
+ *
+ * A fence inside a blockquote or a list item is recognized too: its prefix (`> `, indentation) is stripped from
+ * every line of its code.
+ *
+ * @param markdown - The markdown document.
+ * @returns The snippets, in document order.
+ */
+export declare function extractDocsSnippets(markdown: string): DocsSnippet[];
+/**
+ * Type-checks every snippet of the guides.
+ *
+ * @param params - The {@link FindDocsSnippetProblemsParams}.
+ * @returns The problems found, empty when every snippet compiles.
+ */
+export declare function findDocsSnippetProblems(params: FindDocsSnippetProblemsParams): Promise<DocsSnippetProblem[]>;
+/**
+ * Formats problems one per line, as `path:line - message`.
+ *
+ * @param problems - The problems.
+ * @returns The formatted text.
+ */
+export declare function formatDocsSnippetProblems(problems: readonly DocsSnippetProblem[]): string;

package/dist/lib/cjs/docs-site/index.cjs

@@ -51,10 +51,12 @@ __export(docs_site_exports, {
   "docs-site-assets": () => docs_site_assets,
   "docs-site-commands": () => docs_site_commands,
   "docs-site-config": () => docs_site_config,
+  "docs-snippets": () => docs_snippets,
   "link-check": () => link_check,
   "og-image": () => og_image,
   "og-image-page": () => og_image_page,
   "og-images": () => og_images,
+  "outdated-references": () => outdated_references,
   "repo-homepage": () => repo_homepage,
   "route-data": () => route_data,
   "satteri-github-alerts": () => satteri_github_alerts,
@@ -80,10 +82,12 @@ var docs_links = __toESM(((module) => module && module.__esModule && 'default' i
 var docs_site_assets = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./docs-site-assets.cjs')), 1);
 var docs_site_commands = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./docs-site-commands.cjs')), 1);
 var docs_site_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./docs-site-config.cjs')), 1);
+var docs_snippets = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./docs-snippets.cjs')), 1);
 var link_check = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./link-check.cjs')), 1);
 var og_image_page = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./og-image-page.cjs')), 1);
 var og_image = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./og-image.cjs')), 1);
 var og_images = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./og-images.cjs')), 1);
+var outdated_references = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./outdated-references.cjs')), 1);
 var repo_homepage = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./repo-homepage.cjs')), 1);
 var route_data = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./route-data.cjs')), 1);
 var satteri_github_alerts = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./satteri-github-alerts.cjs')), 1);
@@ -109,14 +113,16 @@ var unrendered_alerts = __toESM(((module) => module && module.__esModule && 'def
   "docs-site-assets": null,
   "docs-site-commands": null,
   "docs-site-config": null,
+  "docs-snippets": null,
   "link-check": null,
   "og-image": null,
   "og-image-page": null,
   "og-images": null,
+  "outdated-references": null,
   "repo-homepage": null,
   "route-data": null,
   "satteri-github-alerts": null,
   "satteri-relative-links": null,
   "unrendered-alerts": null
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/docs-site/index.d.cts

@@ -17,10 +17,12 @@ export * as 'docs-links' from './docs-links.cjs';
 export * as 'docs-site-assets' from './docs-site-assets.cjs';
 export * as 'docs-site-commands' from './docs-site-commands.cjs';
 export * as 'docs-site-config' from './docs-site-config.cjs';
+export * as 'docs-snippets' from './docs-snippets.cjs';
 export * as 'link-check' from './link-check.cjs';
 export * as 'og-image-page' from './og-image-page.cjs';
 export * as 'og-image' from './og-image.cjs';
 export * as 'og-images' from './og-images.cjs';
+export * as 'outdated-references' from './outdated-references.cjs';
 export * as 'repo-homepage' from './repo-homepage.cjs';
 export * as 'route-data' from './route-data.cjs';
 export * as 'satteri-github-alerts' from './satteri-github-alerts.cjs';