@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.0.0

package/dist/lib/esm/docs-site/api-doc-text-utils.d.mts

@@ -0,0 +1,178 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Text/markdown/escaping utilities and identifier helpers for the API documentation generator.
+ */
+import type { MarkdownSegment, MemberInfo, TypeInfo } from './api-doc-types.mjs';
+/**
+ * Compute an overload key for methods with distinguishing first param (e.g. on('changed',...))
+ *
+ * @param method - The method.
+ * @returns The overload key.
+ */
+export declare function computeOverloadKey(method: MemberInfo): string;
+/**
+ * Creates the folder a file is about to be written to.
+ *
+ * @param filePath - The path of the file about to be written.
+ */
+export declare function ensureDirectory(filePath: string): Promise<void>;
+/**
+ * Escape text for use inside a JS string within a JSX expression: {...{key: "..."}}
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeJsString(text: string): string;
+/**
+ * Escape text for use inside a JSX attribute: attr="..." (MDX uses HTML-style parsing)
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeJsxAttribute(text: string): string;
+/**
+ * Escape text for a markdown table cell.
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeMarkdown(text: string): string;
+/**
+ * Escape angle brackets so MDX does not read them as JSX.
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeMdxAngleBrackets(text: string): string;
+/**
+ * Escape curly braces in MDX markdown content to prevent JSX expression parsing
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeMdxBraces(text: string): string;
+/**
+ * Escape text for a double-quoted YAML value.
+ *
+ * @param text - The text to escape.
+ * @returns The escaped text.
+ */
+export declare function escapeYaml(text: string): string;
+/**
+ * Escape MDX-unsafe characters (`<`, `{`, `}`) in prose text, while leaving inline code spans
+ * (`` `code` ``) and markdown links (`[text](url)`) untouched. MDX parses bare `<`/`{` in prose as
+ * JSX/expressions, so they must be backslash-escaped to render as literal text.
+ *
+ * @param text - The prose to escape.
+ * @returns The escaped prose.
+ */
+export declare function escapeMdxProse(text: string): string;
+/**
+ * Collapse single newlines within paragraphs to spaces, preserve double newlines as paragraph breaks.
+ * Fenced code blocks (backtick or tilde fences) are preserved verbatim — their internal newlines are NOT folded,
+ * so embedded code survives to be re-emitted as a real code fence downstream.
+ *
+ * @param text - The text.
+ * @returns The folded text.
+ */
+export declare function foldTsDocParagraphs(text: string): string;
+/**
+ * The type's name with its type parameters, without their constraints.
+ *
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @returns The name with its bare type parameters.
+ */
+export declare function getDisplayName(name: string, info: TypeInfo): string;
+/**
+ * Emit the import statement for a documented export.
+ *
+ * The subpath equals the type's namespace (its source path relative to `src`), so `src/string.ts` of
+ * `@mnaoumov/typescript-lib` is `@mnaoumov/typescript-lib/string`.
+ *
+ * Interfaces / type aliases / enums are imported with `import type`; classes / functions /
+ * variables with a value `import`.
+ *
+ * @param info - The documented type.
+ * @returns The import statement.
+ */
+export declare function getImportStatement(info: TypeInfo): string;
+/**
+ * The folder a namespace's pages are written to.
+ *
+ * @param namespace - The type's namespace.
+ * @returns The folder.
+ */
+export declare function getNamespaceDirectory(namespace: string): string;
+/**
+ * Sanitize a member name for use in a case-PRESERVED URL/route segment (e.g. `showNotice`).
+ *
+ * @param name - The member's name.
+ * @returns The case-preserved segment.
+ */
+export declare function memberRouteSegment(name: string): string;
+/**
+ * Sanitize a member name for use as an on-disk FILENAME (lowercased, collision-safe).
+ *
+ * @param name - The member's name.
+ * @returns The lowercased file name segment.
+ */
+export declare function memberSlug(name: string): string;
+/**
+ * Slugify an overload key for a case-PRESERVED URL/route segment: on("changed") -> on-changed.
+ *
+ * @param overloadKey - The overload key, e.g. `on('changed')`.
+ * @returns The case-preserved segment.
+ */
+export declare function overloadRouteSegment(overloadKey: string): string;
+/**
+ * Slugify an overload key for an on-disk FILENAME: on("changed") -> on-changed (lowercased).
+ *
+ * @param overloadKey - The overload key, e.g. `on('changed')`.
+ * @returns The lowercased file name segment.
+ */
+export declare function overloadSlug(overloadKey: string): string;
+/**
+ * Replace every match of a global regular expression with what a replacer builds from the match. The typed
+ * counterpart of `String.prototype.replaceAll` with a callback, whose arguments are typed only positionally.
+ *
+ * @param text - The text.
+ * @param regExp - The regular expression; it must carry the `g` flag.
+ * @param replacer - Builds the replacement of one match.
+ * @returns The text with every match replaced.
+ */
+export declare function replaceRegExpMatches(text: string, regExp: RegExp, replacer: (match: RegExpMatchArray) => string): string;
+/**
+ * Split markdown text into an ordered list of prose and fenced-code segments.
+ * A fenced-code segment is delimited by a line of 3+ backticks or tildes; its content is captured
+ * raw (never escaped) so it can be re-emitted as a literal MDX code fence.
+ *
+ * @param text - The text.
+ * @returns The segments, in order.
+ */
+export declare function segmentMarkdown(text: string): MarkdownSegment[];
+/**
+ * Strip the `import("…")` qualifiers ts-morph prints before a type that is not in scope, recording each one's
+ * declaration file first, since it is the one place a printed type names where it was declared.
+ *
+ * @param typeText - The printed type.
+ * @returns The type without its import qualifiers.
+ */
+export declare function simplifyType(typeText: string): string;
+/**
+ * Normalize a code signature for the `signature:` frontmatter / OG card: collapse whitespace to
+ * single spaces and truncate to a card-friendly length with an ellipsis.
+ *
+ * @param signature - The signature.
+ * @returns The normalized signature.
+ */
+export declare function truncateSignature(signature: string): string;
+/**
+ * Strip markdown formatting to plain text for use in meta descriptions
+ *
+ * @param text - The text.
+ * @returns The plain text, at most 160 characters.
+ */
+export declare function stripMarkdown(text: string): string;

package/dist/lib/esm/docs-site/api-doc-text-utils.mjs

@@ -0,0 +1,239 @@
+/*
+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();
+})();
+
+import {
+  getMandatoryNamedGroup,
+  getOptionalNamedGroup
+} from "@mnaoumov/typescript-lib/reg-exp";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { EVENT_METHODS } from "./api-doc-constants.mjs";
+import { registerPackageDeclaration } from "./api-doc-package-sites.mjs";
+import { toRouteSegment } from "./api-doc-route-segments.mjs";
+import { getApiDocSettings } from "./api-doc-settings.mjs";
+function computeOverloadKey(method) {
+  if (EVENT_METHODS.has(method.name) && method.parameters.length > 0) {
+    const firstParameter = method.parameters[0];
+    if (firstParameter?.type.startsWith('"') || firstParameter?.type.startsWith("'")) {
+      const normalizedType = firstParameter.type.replaceAll('"', "'");
+      return `${method.name}(${normalizedType})`;
+    }
+  }
+  return method.name;
+}
+async function ensureDirectory(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+function escapeJsString(text) {
+  return text.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`).replaceAll("\n", " ");
+}
+function escapeJsxAttribute(text) {
+  return text.replaceAll("&", "&").replaceAll('"', """).replaceAll("\n", " ");
+}
+function escapeMarkdown(text) {
+  return text.replaceAll("|", String.raw`\|`).replaceAll("\n", " ").replaceAll("{", String.raw`\{`).replaceAll("}", String.raw`\}`);
+}
+function escapeMdxAngleBrackets(text) {
+  return text.replaceAll("<", String.raw`\<`).replaceAll(">", String.raw`\>`);
+}
+function escapeMdxBraces(text) {
+  return text.replaceAll("{", String.raw`\{`).replaceAll("}", String.raw`\}`);
+}
+function escapeYaml(text) {
+  return text.replaceAll('"', String.raw`\"`);
+}
+const SIGNATURE_MAX_LENGTH = 160;
+const IMPORT_QUALIFIER_REG_EXP = /import\((?<Quote>["'])[^"']+\k<Quote>\)\./g;
+const IMPORT_TYPE_REG_EXP = /import\((?<Quote>["'])(?<Path>[^"']+)\k<Quote>\)\.(?<Name>[A-Za-z_$][\w$]*)/g;
+function escapeMdxProse(text) {
+  const protectedPattern = /`[^`]*`|\[[^\]]*\]\([^)]*\)/g;
+  let result = "";
+  let lastIndex = 0;
+  for (const match of text.matchAll(protectedPattern)) {
+    const index = match.index;
+    result += escapeMdxProseChars(text.slice(lastIndex, index));
+    result += match[0];
+    lastIndex = index + match[0].length;
+  }
+  result += escapeMdxProseChars(text.slice(lastIndex));
+  return result;
+}
+function foldTsDocParagraphs(text) {
+  const segments = segmentMarkdown(text);
+  return segments.map((seg) => {
+    return seg.type === "code" ? `\`\`\`${seg.lang}
+${seg.text}
+\`\`\`` : seg.text.split(/\n{2,}/).map((paragraph) => paragraph.replaceAll("\n", " ")).join("\n\n");
+  }).map((segment) => segment.trim()).filter(Boolean).join("\n\n");
+}
+function getDisplayName(name, info) {
+  if (info.typeParameters.length === 0) {
+    return name;
+  }
+  const bareParams = info.typeParameters.map((tp) => tp.replace(/\s+extends\s+.*$/, ""));
+  return `${name}<${bareParams.join(", ")}>`;
+}
+function getImportStatement(info) {
+  const isTypeOnly = ["enum", "interface", "type"].includes(info.kind);
+  const importKeyword = isTypeOnly ? "import type" : "import";
+  return `${importKeyword} { ${info.name} } from '${getApiDocSettings().packageName}/${info.namespace}';`;
+}
+function getNamespaceDirectory(namespace) {
+  return namespace;
+}
+function memberRouteSegment(name) {
+  return slugifyMemberName(name);
+}
+function memberSlug(name) {
+  return toRouteSegment(slugifyMemberName(name));
+}
+function overloadRouteSegment(overloadKey) {
+  return slugifyOverloadKey(overloadKey);
+}
+function overloadSlug(overloadKey) {
+  return toRouteSegment(slugifyOverloadKey(overloadKey));
+}
+function replaceRegExpMatches(text, regExp, replacer) {
+  let result = "";
+  let lastIndex = 0;
+  for (const match of text.matchAll(regExp)) {
+    result += text.slice(lastIndex, match.index) + replacer(match);
+    lastIndex = match.index + match[0].length;
+  }
+  return result + text.slice(lastIndex);
+}
+function segmentMarkdown(text) {
+  const lines = text.split("\n");
+  const segments = [];
+  let proseBuffer = [];
+  let codeLines = [];
+  let openFence = null;
+  for (const line of lines) {
+    if (openFence) {
+      if (openFence.closeRe.test(line)) {
+        segments.push({ lang: openFence.lang, text: codeLines.join("\n"), type: "code" });
+        openFence = null;
+      } else {
+        codeLines.push(line);
+      }
+      continue;
+    }
+    const openMatch = /^\s*(?<fence>(?<fenceChar>[`~])\k<fenceChar>{2,})(?<lang>.*)$/.exec(line);
+    if (openMatch) {
+      const fenceChars = getMandatoryNamedGroup(openMatch, "fence");
+      const fenceChar = getMandatoryNamedGroup(openMatch, "fenceChar");
+      flushProse();
+      codeLines = [];
+      openFence = {
+        closeRe: new RegExp(`^\\s*\\${fenceChar}{${String(fenceChars.length)},}\\s*$`),
+        lang: getMandatoryNamedGroup(openMatch, "lang").trim()
+      };
+      continue;
+    }
+    proseBuffer.push(line);
+  }
+  if (openFence) {
+    segments.push({ lang: openFence.lang, text: codeLines.join("\n"), type: "code" });
+  }
+  flushProse();
+  return segments;
+  function flushProse() {
+    if (proseBuffer.length === 0) {
+      return;
+    }
+    segments.push({ text: proseBuffer.join("\n"), type: "prose" });
+    proseBuffer = [];
+  }
+}
+function simplifyType(typeText) {
+  for (const match of typeText.matchAll(IMPORT_TYPE_REG_EXP)) {
+    registerPackageDeclaration(getMandatoryNamedGroup(match, "Name"), getMandatoryNamedGroup(match, "Path"));
+  }
+  return typeText.replaceAll(IMPORT_QUALIFIER_REG_EXP, "");
+}
+function truncateSignature(signature) {
+  const collapsed = signature.replaceAll(/\s+/g, " ").trim();
+  return collapsed.length <= SIGNATURE_MAX_LENGTH ? collapsed : `${collapsed.slice(0, SIGNATURE_MAX_LENGTH - 1).trimEnd()}\u2026`;
+}
+function slugifyMemberName(name) {
+  const cleaned = name.replaceAll(/^["']|["']$/g, "").replaceAll(/[^a-zA-Z0-9]/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+  return cleaned === "index" ? "index-member" : cleaned || "unnamed";
+}
+function slugifyOverloadKey(overloadKey) {
+  const slug = overloadKey.replaceAll(/["'()]/g, " ").replaceAll(/[^a-zA-Z0-9\s]/g, "").trim().replaceAll(/\s+/g, "-");
+  return slug === "index" ? "index-member" : slug;
+}
+const OG_DESCRIPTION_MAX_LENGTH = 160;
+function stripMarkdown(text) {
+  const plain = replaceRegExpMatches(text, /\{@link\s+(?:[^|}]+?)(?:\s*\|\s*(?<display>[^}]+?))?\}/g, (match) => getOptionalNamedGroup(match, "display") ?? "").replaceAll(/\[(?<text>[^\]]+)\]\([^)]+\)/g, "$<text>").replaceAll(/[`*_~]/g, "").replaceAll(/\s+/g, " ").trim();
+  if (plain.length <= OG_DESCRIPTION_MAX_LENGTH) {
+    return plain;
+  }
+  const clipped = plain.slice(0, OG_DESCRIPTION_MAX_LENGTH - 1);
+  const lastSpaceIndex = clipped.lastIndexOf(" ");
+  const truncated = lastSpaceIndex > 0 ? clipped.slice(0, lastSpaceIndex) : clipped;
+  return `${truncated.replace(/[,;:.\s]+$/, "")}\u2026`;
+}
+function escapeMdxProseChars(chunk) {
+  return chunk.replaceAll(/[<{}]/g, (char) => `\\${char}`);
+}
+export {
+  computeOverloadKey,
+  ensureDirectory,
+  escapeJsString,
+  escapeJsxAttribute,
+  escapeMarkdown,
+  escapeMdxAngleBrackets,
+  escapeMdxBraces,
+  escapeMdxProse,
+  escapeYaml,
+  foldTsDocParagraphs,
+  getDisplayName,
+  getImportStatement,
+  getNamespaceDirectory,
+  memberRouteSegment,
+  memberSlug,
+  overloadRouteSegment,
+  overloadSlug,
+  replaceRegExpMatches,
+  segmentMarkdown,
+  simplifyType,
+  stripMarkdown,
+  truncateSignature
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-text-utils.ts"],"sourcesContent":["/**\n * @file\n *\n * Text/markdown/escaping utilities and identifier helpers for the API documentation generator.\n */\n\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { mkdir } from 'node:fs/promises';\nimport { dirname } from 'node:path';\n\nimport type {\n  MarkdownSegment,\n  MemberInfo,\n  TypeInfo\n} from './api-doc-types.ts';\n\nimport { EVENT_METHODS } from './api-doc-constants.ts';\nimport { registerPackageDeclaration } from './api-doc-package-sites.ts';\nimport { toRouteSegment } from './api-doc-route-segments.ts';\nimport { getApiDocSettings } from './api-doc-settings.ts';\n\ninterface OpenFence {\n  readonly closeRe: RegExp;\n  readonly lang: string;\n}\n\n/**\n * Compute an overload key for methods with distinguishing first param (e.g. on('changed',...))\n *\n * @param method - The method.\n * @returns The overload key.\n */\nexport function computeOverloadKey(method: MemberInfo): string {\n  if (EVENT_METHODS.has(method.name) && method.parameters.length > 0) {\n    const firstParameter = method.parameters[0];\n    if (firstParameter?.type.startsWith('\"') || firstParameter?.type.startsWith('\\'')) {\n      const normalizedType = firstParameter.type.replaceAll('\"', '\\'');\n      return `${method.name}(${normalizedType})`;\n    }\n  }\n  return method.name;\n}\n\n/**\n * Creates the folder a file is about to be written to.\n *\n * @param filePath - The path of the file about to be written.\n */\nexport async function ensureDirectory(filePath: string): Promise<void> {\n  await mkdir(dirname(filePath), { recursive: true });\n}\n\n/**\n * Escape text for use inside a JS string within a JSX expression: {...{key: \"...\"}}\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeJsString(text: string): string {\n  return text.replaceAll('\\\\', '\\\\\\\\').replaceAll('\"', String.raw`\\\"`).replaceAll('\\n', ' ');\n}\n\n/**\n * Escape text for use inside a JSX attribute: attr=\"...\" (MDX uses HTML-style parsing)\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeJsxAttribute(text: string): string {\n  return text.replaceAll('&', '&amp;').replaceAll('\"', '&quot;').replaceAll('\\n', ' ');\n}\n\n/**\n * Escape text for a markdown table cell.\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeMarkdown(text: string): string {\n  return text.replaceAll('|', String.raw`\\|`).replaceAll('\\n', ' ').replaceAll('{', String.raw`\\{`).replaceAll('}', String.raw`\\}`);\n}\n\n/**\n * Escape angle brackets so MDX does not read them as JSX.\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeMdxAngleBrackets(text: string): string {\n  return text.replaceAll('<', String.raw`\\<`).replaceAll('>', String.raw`\\>`);\n}\n\n/**\n * Escape curly braces in MDX markdown content to prevent JSX expression parsing\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeMdxBraces(text: string): string {\n  return text.replaceAll('{', String.raw`\\{`).replaceAll('}', String.raw`\\}`);\n}\n\n/**\n * Escape text for a double-quoted YAML value.\n *\n * @param text - The text to escape.\n * @returns The escaped text.\n */\nexport function escapeYaml(text: string): string {\n  return text.replaceAll('\"', String.raw`\\\"`);\n}\n\nconst SIGNATURE_MAX_LENGTH = 160;\nconst IMPORT_QUALIFIER_REG_EXP = /import\\((?<Quote>[\"'])[^\"']+\\k<Quote>\\)\\./g;\nconst IMPORT_TYPE_REG_EXP = /import\\((?<Quote>[\"'])(?<Path>[^\"']+)\\k<Quote>\\)\\.(?<Name>[A-Za-z_$][\\w$]*)/g;\n\n/**\n * Escape MDX-unsafe characters (`<`, `{`, `}`) in prose text, while leaving inline code spans\n * (`` `code` ``) and markdown links (`[text](url)`) untouched. MDX parses bare `<`/`{` in prose as\n * JSX/expressions, so they must be backslash-escaped to render as literal text.\n *\n * @param text - The prose to escape.\n * @returns The escaped prose.\n */\nexport function escapeMdxProse(text: string): string {\n  const protectedPattern = /`[^`]*`|\\[[^\\]]*\\]\\([^)]*\\)/g;\n  let result = '';\n  let lastIndex = 0;\n  for (const match of text.matchAll(protectedPattern)) {\n    const index = match.index;\n    result += escapeMdxProseChars(text.slice(lastIndex, index));\n    result += match[0];\n    lastIndex = index + match[0].length;\n  }\n  result += escapeMdxProseChars(text.slice(lastIndex));\n  return result;\n}\n\n/**\n * Collapse single newlines within paragraphs to spaces, preserve double newlines as paragraph breaks.\n * Fenced code blocks (backtick or tilde fences) are preserved verbatim — their internal newlines are NOT folded,\n * so embedded code survives to be re-emitted as a real code fence downstream.\n *\n * @param text - The text.\n * @returns The folded text.\n */\nexport function foldTsDocParagraphs(text: string): string {\n  const segments = segmentMarkdown(text);\n  return segments\n    .map((seg) => {\n      return seg.type === 'code'\n        ? `\\`\\`\\`${seg.lang}\\n${seg.text}\\n\\`\\`\\``\n        : seg.text\n          .split(/\\n{2,}/)\n          .map((paragraph) => paragraph.replaceAll('\\n', ' '))\n          .join('\\n\\n');\n    })\n    .map((segment) => segment.trim())\n    .filter(Boolean)\n    .join('\\n\\n');\n}\n\n/**\n * The type's name with its type parameters, without their constraints.\n *\n * @param name - The type's name.\n * @param info - The documented type.\n * @returns The name with its bare type parameters.\n */\nexport function getDisplayName(name: string, info: TypeInfo): string {\n  if (info.typeParameters.length === 0) {\n    return name;\n  }\n  const bareParams = info.typeParameters.map((tp) => tp.replace(/\\s+extends\\s+.*$/, ''));\n  return `${name}<${bareParams.join(', ')}>`;\n}\n\n/**\n * Emit the import statement for a documented export.\n *\n * The subpath equals the type's namespace (its source path relative to `src`), so `src/string.ts` of\n * `@mnaoumov/typescript-lib` is `@mnaoumov/typescript-lib/string`.\n *\n * Interfaces / type aliases / enums are imported with `import type`; classes / functions /\n * variables with a value `import`.\n *\n * @param info - The documented type.\n * @returns The import statement.\n */\nexport function getImportStatement(info: TypeInfo): string {\n  const isTypeOnly = ['enum', 'interface', 'type'].includes(info.kind);\n  const importKeyword = isTypeOnly ? 'import type' : 'import';\n  return `${importKeyword} { ${info.name} } from '${getApiDocSettings().packageName}/${info.namespace}';`;\n}\n\n/**\n * The folder a namespace's pages are written to.\n *\n * @param namespace - The type's namespace.\n * @returns The folder.\n */\nexport function getNamespaceDirectory(namespace: string): string {\n  return namespace;\n}\n\n/**\n * Sanitize a member name for use in a case-PRESERVED URL/route segment (e.g. `showNotice`).\n *\n * @param name - The member's name.\n * @returns The case-preserved segment.\n */\nexport function memberRouteSegment(name: string): string {\n  return slugifyMemberName(name);\n}\n\n/**\n * Sanitize a member name for use as an on-disk FILENAME (lowercased, collision-safe).\n *\n * @param name - The member's name.\n * @returns The lowercased file name segment.\n */\nexport function memberSlug(name: string): string {\n  return toRouteSegment(slugifyMemberName(name));\n}\n\n/**\n * Slugify an overload key for a case-PRESERVED URL/route segment: on(\"changed\") -> on-changed.\n *\n * @param overloadKey - The overload key, e.g. `on('changed')`.\n * @returns The case-preserved segment.\n */\nexport function overloadRouteSegment(overloadKey: string): string {\n  return slugifyOverloadKey(overloadKey);\n}\n\n/**\n * Slugify an overload key for an on-disk FILENAME: on(\"changed\") -> on-changed (lowercased).\n *\n * @param overloadKey - The overload key, e.g. `on('changed')`.\n * @returns The lowercased file name segment.\n */\nexport function overloadSlug(overloadKey: string): string {\n  return toRouteSegment(slugifyOverloadKey(overloadKey));\n}\n\n/**\n * Replace every match of a global regular expression with what a replacer builds from the match. The typed\n * counterpart of `String.prototype.replaceAll` with a callback, whose arguments are typed only positionally.\n *\n * @param text - The text.\n * @param regExp - The regular expression; it must carry the `g` flag.\n * @param replacer - Builds the replacement of one match.\n * @returns The text with every match replaced.\n */\nexport function replaceRegExpMatches(text: string, regExp: RegExp, replacer: (match: RegExpMatchArray) => string): string {\n  let result = '';\n  let lastIndex = 0;\n  for (const match of text.matchAll(regExp)) {\n    result += text.slice(lastIndex, match.index) + replacer(match);\n    lastIndex = match.index + match[0].length;\n  }\n  return result + text.slice(lastIndex);\n}\n\n/**\n * Split markdown text into an ordered list of prose and fenced-code segments.\n * A fenced-code segment is delimited by a line of 3+ backticks or tildes; its content is captured\n * raw (never escaped) so it can be re-emitted as a literal MDX code fence.\n *\n * @param text - The text.\n * @returns The segments, in order.\n */\nexport function segmentMarkdown(text: string): MarkdownSegment[] {\n  const lines = text.split('\\n');\n  const segments: MarkdownSegment[] = [];\n  let proseBuffer: string[] = [];\n  let codeLines: string[] = [];\n  let openFence: null | OpenFence = null;\n  for (const line of lines) {\n    if (openFence) {\n      if (openFence.closeRe.test(line)) {\n        segments.push({ lang: openFence.lang, text: codeLines.join('\\n'), type: 'code' });\n        openFence = null;\n      } else {\n        codeLines.push(line);\n      }\n      continue;\n    }\n\n    const openMatch = /^\\s*(?<fence>(?<fenceChar>[`~])\\k<fenceChar>{2,})(?<lang>.*)$/.exec(line);\n    if (openMatch) {\n      const fenceChars = getMandatoryNamedGroup(openMatch, 'fence');\n      const fenceChar = getMandatoryNamedGroup(openMatch, 'fenceChar');\n      flushProse();\n      codeLines = [];\n      openFence = {\n        closeRe: new RegExp(`^\\\\s*\\\\${fenceChar}{${String(fenceChars.length)},}\\\\s*$`),\n        lang: getMandatoryNamedGroup(openMatch, 'lang').trim()\n      };\n      continue;\n    }\n    proseBuffer.push(line);\n  }\n  // An unclosed fence runs to the end of the text.\n  if (openFence) {\n    segments.push({ lang: openFence.lang, text: codeLines.join('\\n'), type: 'code' });\n  }\n  flushProse();\n  return segments;\n\n  function flushProse(): void {\n    if (proseBuffer.length === 0) {\n      return;\n    }\n\n    segments.push({ text: proseBuffer.join('\\n'), type: 'prose' });\n    proseBuffer = [];\n  }\n}\n\n/**\n * Strip the `import(\"…\")` qualifiers ts-morph prints before a type that is not in scope, recording each one's\n * declaration file first, since it is the one place a printed type names where it was declared.\n *\n * @param typeText - The printed type.\n * @returns The type without its import qualifiers.\n */\nexport function simplifyType(typeText: string): string {\n  for (const match of typeText.matchAll(IMPORT_TYPE_REG_EXP)) {\n    registerPackageDeclaration(getMandatoryNamedGroup(match, 'Name'), getMandatoryNamedGroup(match, 'Path'));\n  }\n\n  return typeText.replaceAll(IMPORT_QUALIFIER_REG_EXP, '');\n}\n\n/**\n * Normalize a code signature for the `signature:` frontmatter / OG card: collapse whitespace to\n * single spaces and truncate to a card-friendly length with an ellipsis.\n *\n * @param signature - The signature.\n * @returns The normalized signature.\n */\nexport function truncateSignature(signature: string): string {\n  const collapsed = signature.replaceAll(/\\s+/g, ' ').trim();\n  return collapsed.length <= SIGNATURE_MAX_LENGTH ? collapsed : `${collapsed.slice(0, SIGNATURE_MAX_LENGTH - 1).trimEnd()}…`;\n}\n\nfunction slugifyMemberName(name: string): string {\n  const cleaned = name\n    .replaceAll(/^[\"']|[\"']$/g, '')\n    .replaceAll(/[^a-zA-Z0-9]/g, '-')\n    .replaceAll(/-+/g, '-')\n    .replaceAll(/^-|-$/g, '');\n  // A member literally named `index` would write `index.mdx`, colliding with the type-overview\n  // `index.mdx` in the same directory (one silently overwrites the other, 404-ing the loser).\n  return cleaned === 'index' ? 'index-member' : (cleaned || 'unnamed');\n}\n\nfunction slugifyOverloadKey(overloadKey: string): string {\n  const slug = overloadKey\n    .replaceAll(/[\"'()]/g, ' ')\n    .replaceAll(/[^a-zA-Z0-9\\s]/g, '')\n    .trim()\n    .replaceAll(/\\s+/g, '-');\n  // A method named `index` would write `index.mdx` over the type-overview page, exactly as a property would.\n  return slug === 'index' ? 'index-member' : slug;\n}\n\nconst OG_DESCRIPTION_MAX_LENGTH = 160;\n\n/**\n * Strip markdown formatting to plain text for use in meta descriptions\n *\n * @param text - The text.\n * @returns The plain text, at most 160 characters.\n */\nexport function stripMarkdown(text: string): string {\n  const plain = replaceRegExpMatches(text, /\\{@link\\s+(?:[^|}]+?)(?:\\s*\\|\\s*(?<display>[^}]+?))?\\}/g, (match) => getOptionalNamedGroup(match, 'display') ?? '')\n    .replaceAll(/\\[(?<text>[^\\]]+)\\]\\([^)]+\\)/g, '$<text>')\n    .replaceAll(/[`*_~]/g, '')\n    .replaceAll(/\\s+/g, ' ')\n    .trim();\n\n  if (plain.length <= OG_DESCRIPTION_MAX_LENGTH) {\n    return plain;\n  }\n\n  // Cut back to a word boundary: a raw slice ends descriptions mid-word (`… the string module is ob`).\n  // That fragment is what readers see on the OG card and in search results.\n  const clipped = plain.slice(0, OG_DESCRIPTION_MAX_LENGTH - 1);\n  const lastSpaceIndex = clipped.lastIndexOf(' ');\n  const truncated = lastSpaceIndex > 0 ? clipped.slice(0, lastSpaceIndex) : clipped;\n  return `${truncated.replace(/[,;:.\\s]+$/, '')}…`;\n}\n\nfunction escapeMdxProseChars(chunk: string): string {\n  return chunk.replaceAll(/[<{}]/g, (char) => `\\\\${char}`);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/docs-site/api-doc-type-merging.d.mts

@@ -0,0 +1,51 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Inheritance resolution: copies inherited members onto subtypes, substituting generic type args.
+ *
+ * (A documented package is a normal library, not an augmentation of another package's declarations, so there is no
+ * official-vs-unofficial merge machinery here — only the generic inheritance helpers.)
+ */
+import type { MemberInfo, TypeInfo } from './api-doc-types.mjs';
+/**
+ * Build a mapping from parent type parameter names to concrete type arguments.
+ * E.g., parent has `typeParameters: ['Instance extends BaseInstance']` and
+ * child extends `Parent<CanvasPluginInstance>` → `{Instance: 'CanvasPluginInstance'}`
+ *
+ * @param baseInfo - The base type.
+ * @param typeArguments - The type arguments the base type is given.
+ * @returns The parameter names mapped to their arguments.
+ */
+export declare function buildTypeParameterMap(baseInfo: TypeInfo, typeArguments: string[]): Map<string, string>;
+/**
+ * Parse generic type arguments from a base type expression.
+ * E.g., `InternalPlugin<CanvasPluginInstance>` → `['CanvasPluginInstance']`
+ * Handles nested angle brackets: `Foo<Bar<Baz>, Qux>` → `['Bar<Baz>', 'Qux']`
+ *
+ * @param baseTypeName - The base type expression, e.g. `Foo<Bar, Baz>`.
+ * @returns The type arguments.
+ */
+export declare function parseTypeArguments(baseTypeName: string): string[];
+/**
+ * Copies every inherited member onto its subtypes, substituting the type arguments the subtype passes.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ */
+export declare function resolveInheritedMembers(types: Map<string, TypeInfo>): void;
+/**
+ * Apply type parameter substitution to all type-bearing fields of a member
+ *
+ * @param member - The member.
+ * @param mapping - Type parameter names mapped to their arguments.
+ * @returns The member with its types substituted.
+ */
+export declare function substituteMemberTypes(member: MemberInfo, mapping: Map<string, string>): MemberInfo;
+/**
+ * Substitute generic type parameters in a type string using a mapping
+ *
+ * @param typeText - The type text.
+ * @param mapping - Type parameter names mapped to their arguments.
+ * @returns The substituted type text.
+ */
+export declare function substituteTypeParams(typeText: string, mapping: Map<string, string>): string;

package/dist/lib/esm/docs-site/api-doc-type-merging.mjs

@@ -0,0 +1,129 @@
+/*
+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();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { findType } from "./api-doc-link-rendering.mjs";
+function buildTypeParameterMap(baseInfo, typeArguments) {
+  const mapping = /* @__PURE__ */ new Map();
+  const count = Math.min(baseInfo.typeParameters.length, typeArguments.length);
+  for (let index = 0; index < count; index++) {
+    const parameter = ensureNonNullable(baseInfo.typeParameters[index]);
+    const argument = ensureNonNullable(typeArguments[index]);
+    const bareParameter = parameter.replace(/\s+extends\s+.*$/, "");
+    mapping.set(bareParameter, argument);
+  }
+  return mapping;
+}
+function parseTypeArguments(baseTypeName) {
+  const openIndex = baseTypeName.indexOf("<");
+  if (openIndex === -1) {
+    return [];
+  }
+  const inner = baseTypeName.slice(openIndex + 1, -1);
+  const $arguments = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of inner) {
+    if (ch === "<") {
+      depth++;
+      current += ch;
+    } else if (ch === ">") {
+      depth--;
+      current += ch;
+    } else if (ch === "," && depth === 0) {
+      $arguments.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) {
+    $arguments.push(current.trim());
+  }
+  return $arguments;
+}
+function resolveInheritedMembers(types) {
+  for (const [, info] of types) {
+    for (const baseTypeName of [...info.baseTypes, ...info.implementsTypes]) {
+      const cleanBase = baseTypeName.replace(/<.*>$/, "").trim();
+      const baseInfo = findType(types, cleanBase, info.namespace);
+      if (!baseInfo) {
+        continue;
+      }
+      const typeArguments = parseTypeArguments(baseTypeName);
+      const typeParameterMap = buildTypeParameterMap(baseInfo, typeArguments);
+      for (const property of baseInfo.properties) {
+        if (info.properties.every((p) => p.name !== property.name)) {
+          info.properties.push(substituteMemberTypes({ ...property, inheritedFrom: baseInfo.name }, typeParameterMap));
+        }
+      }
+      for (const method of baseInfo.methods) {
+        const hasOwnMethod = info.methods.some((m) => m.name === method.name && m.signature === method.signature);
+        const hasInheritedMethod = info.methods.some((m) => m.inheritedFrom === baseInfo.name && m.overloadKey === method.overloadKey);
+        if (!hasOwnMethod && !hasInheritedMethod) {
+          info.methods.push(substituteMemberTypes({ ...method, inheritedFrom: baseInfo.name }, typeParameterMap));
+        }
+      }
+    }
+  }
+}
+function substituteMemberTypes(member, mapping) {
+  return mapping.size === 0 ? member : {
+    ...member,
+    parameters: member.parameters.map((p) => ({
+      ...p,
+      type: substituteTypeParams(p.type, mapping)
+    })),
+    returnType: substituteTypeParams(member.returnType, mapping),
+    signature: substituteTypeParams(member.signature, mapping),
+    type: substituteTypeParams(member.type, mapping)
+  };
+}
+function substituteTypeParams(typeText, mapping) {
+  return mapping.size === 0 ? typeText : typeText.replaceAll(/\b(?<typeName>[a-zA-Z][a-zA-Z0-9]*)\b/g, (match) => {
+    return mapping.get(match) ?? match;
+  });
+}
+export {
+  buildTypeParameterMap,
+  parseTypeArguments,
+  resolveInheritedMembers,
+  substituteMemberTypes,
+  substituteTypeParams
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-type-merging.ts"],"sourcesContent":["/**\n * @file\n *\n * Inheritance resolution: copies inherited members onto subtypes, substituting generic type args.\n *\n * (A documented package is a normal library, not an augmentation of another package's declarations, so there is no\n * official-vs-unofficial merge machinery here — only the generic inheritance helpers.)\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type {\n  MemberInfo,\n  TypeInfo\n} from './api-doc-types.ts';\n\nimport { findType } from './api-doc-link-rendering.ts';\n\n/**\n * Build a mapping from parent type parameter names to concrete type arguments.\n * E.g., parent has `typeParameters: ['Instance extends BaseInstance']` and\n * child extends `Parent<CanvasPluginInstance>` → `{Instance: 'CanvasPluginInstance'}`\n *\n * @param baseInfo - The base type.\n * @param typeArguments - The type arguments the base type is given.\n * @returns The parameter names mapped to their arguments.\n */\nexport function buildTypeParameterMap(baseInfo: TypeInfo, typeArguments: string[]): Map<string, string> {\n  const mapping = new Map<string, string>();\n  const count = Math.min(baseInfo.typeParameters.length, typeArguments.length);\n  for (let index = 0; index < count; index++) {\n    // Both lists are longer than `index`.\n    const parameter = ensureNonNullable(baseInfo.typeParameters[index]);\n    const argument = ensureNonNullable(typeArguments[index]);\n    const bareParameter = parameter.replace(/\\s+extends\\s+.*$/, '');\n    mapping.set(bareParameter, argument);\n  }\n  return mapping;\n}\n\n/**\n * Parse generic type arguments from a base type expression.\n * E.g., `InternalPlugin<CanvasPluginInstance>` → `['CanvasPluginInstance']`\n * Handles nested angle brackets: `Foo<Bar<Baz>, Qux>` → `['Bar<Baz>', 'Qux']`\n *\n * @param baseTypeName - The base type expression, e.g. `Foo<Bar, Baz>`.\n * @returns The type arguments.\n */\nexport function parseTypeArguments(baseTypeName: string): string[] {\n  const openIndex = baseTypeName.indexOf('<');\n  if (openIndex === -1) {\n    return [];\n  }\n  const inner = baseTypeName.slice(openIndex + 1, -1);\n  const $arguments: string[] = [];\n  let depth = 0;\n  let current = '';\n  for (const ch of inner) {\n    if (ch === '<') {\n      depth++;\n      current += ch;\n    } else if (ch === '>') {\n      depth--;\n      current += ch;\n    } else if (ch === ',' && depth === 0) {\n      $arguments.push(current.trim());\n      current = '';\n    } else {\n      current += ch;\n    }\n  }\n  if (current.trim()) {\n    $arguments.push(current.trim());\n  }\n  return $arguments;\n}\n\n/**\n * Copies every inherited member onto its subtypes, substituting the type arguments the subtype passes.\n *\n * @param types - The documented types, keyed by qualified id.\n */\nexport function resolveInheritedMembers(types: Map<string, TypeInfo>): void {\n  for (const [, info] of types) {\n    for (const baseTypeName of [...info.baseTypes, ...info.implementsTypes]) {\n      const cleanBase = baseTypeName.replace(/<.*>$/, '').trim();\n      const baseInfo = findType(types, cleanBase, info.namespace);\n      if (!baseInfo) {\n        continue;\n      }\n\n      const typeArguments = parseTypeArguments(baseTypeName);\n      const typeParameterMap = buildTypeParameterMap(baseInfo, typeArguments);\n\n      for (const property of baseInfo.properties) {\n        if (info.properties.every((p) => p.name !== property.name)) {\n          info.properties.push(substituteMemberTypes({ ...property, inheritedFrom: baseInfo.name }, typeParameterMap));\n        }\n      }\n\n      for (const method of baseInfo.methods) {\n        const hasOwnMethod = info.methods.some((m) => m.name === method.name && m.signature === method.signature);\n        const hasInheritedMethod = info.methods.some((m) => m.inheritedFrom === baseInfo.name && m.overloadKey === method.overloadKey);\n        if (!hasOwnMethod && !hasInheritedMethod) {\n          info.methods.push(substituteMemberTypes({ ...method, inheritedFrom: baseInfo.name }, typeParameterMap));\n        }\n      }\n    }\n  }\n}\n\n/**\n * Apply type parameter substitution to all type-bearing fields of a member\n *\n * @param member - The member.\n * @param mapping - Type parameter names mapped to their arguments.\n * @returns The member with its types substituted.\n */\nexport function substituteMemberTypes(member: MemberInfo, mapping: Map<string, string>): MemberInfo {\n  return mapping.size === 0\n    ? member\n    : {\n      ...member,\n      parameters: member.parameters.map((p) => ({\n        ...p,\n        type: substituteTypeParams(p.type, mapping)\n      })),\n      returnType: substituteTypeParams(member.returnType, mapping),\n      signature: substituteTypeParams(member.signature, mapping),\n      type: substituteTypeParams(member.type, mapping)\n    };\n}\n\n/**\n * Substitute generic type parameters in a type string using a mapping\n *\n * @param typeText - The type text.\n * @param mapping - Type parameter names mapped to their arguments.\n * @returns The substituted type text.\n */\nexport function substituteTypeParams(typeText: string, mapping: Map<string, string>): string {\n  return mapping.size === 0\n    ? typeText\n    : typeText.replaceAll(/\\b(?<typeName>[a-zA-Z][a-zA-Z0-9]*)\\b/g, (match) => {\n      return mapping.get(match) ?? match;\n    });\n}\n"],"mappings":"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","names":[]}