@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.1.0

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

@@ -0,0 +1,149 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * JSDoc/declaration extraction: turns ts-morph declarations into the generator's `TypeInfo`/`MemberInfo`.
+ */
+import type { ClassDeclaration, ConstructorDeclaration, EnumDeclaration, InterfaceDeclaration, JSDocableNode, MethodDeclaration, MethodSignature, PropertyDeclaration, PropertySignature, SourceFile, TypeAliasDeclaration } from 'ts-morph';
+import type { MemberInfo, ReturnTypeProvider, TypeInfo } from './api-doc-types.mjs';
+/**
+ * Extracts a class's model: its constructor, non-private properties and methods, and documentation.
+ *
+ * @param cls - The class declaration.
+ * @param namespace - The type's namespace.
+ * @returns The class's model.
+ */
+export declare function extractClassInfo(cls: ClassDeclaration, namespace: string): TypeInfo;
+/**
+ * Extracts a constructor's model.
+ *
+ * @param ctor - The constructor declaration.
+ * @returns The constructor's model.
+ */
+export declare function extractConstructorInfo(ctor: ConstructorDeclaration): MemberInfo;
+/**
+ * Extracts an enum's model.
+ *
+ * @param enumDeclaration - The enum declaration.
+ * @param namespace - The type's namespace.
+ * @returns The enum's model.
+ */
+export declare function extractEnumInfo(enumDeclaration: EnumDeclaration, namespace: string): TypeInfo;
+/**
+ * Extract the module-level `@file` description text, if any.
+ *
+ * @param src - The source file.
+ * @returns The overview, or an empty string when the file has no `@file` block.
+ */
+export declare function extractFileOverview(src: SourceFile): string;
+/**
+ * Extracts an interface's model.
+ *
+ * @param iface - The interface declaration.
+ * @param namespace - The type's namespace.
+ * @returns The interface's model.
+ */
+export declare function extractInterfaceInfo(iface: InterfaceDeclaration, namespace: string): TypeInfo;
+/**
+ * Extracts a class method's model.
+ *
+ * @param method - The method.
+ * @returns The method's model.
+ */
+export declare function extractMethodInfo(method: MethodDeclaration): MemberInfo;
+/**
+ * Extracts an interface method's model.
+ *
+ * @param method - The method.
+ * @returns The method's model.
+ */
+export declare function extractMethodSignatureInfo(method: MethodSignature): MemberInfo;
+/**
+ * Extracts a class property's model.
+ *
+ * @param property - The property.
+ * @returns The property's model.
+ */
+export declare function extractPropertyInfo(property: PropertyDeclaration): MemberInfo;
+/**
+ * Extracts an interface property's model.
+ *
+ * @param property - The property.
+ * @returns The property's model.
+ */
+export declare function extractPropertySignatureInfo(property: PropertySignature): MemberInfo;
+/**
+ * Extracts a type alias's model.
+ *
+ * @param alias - The type alias declaration.
+ * @param namespace - The type's namespace.
+ * @returns The type alias's model.
+ */
+export declare function extractTypeAliasInfo(alias: TypeAliasDeclaration, namespace: string): TypeInfo;
+/**
+ * Get the return type as declared in source (preserves union order), falling back to resolved type
+ *
+ * @param method - The method or function.
+ * @returns The return type.
+ */
+export declare function getDeclaredReturnType(method: ReturnTypeProvider): string;
+/**
+ * Extracts the JSDoc description of a node.
+ *
+ * @param node - The node.
+ * @returns The description, or an empty string.
+ */
+export declare function getDescription(node: JSDocableNode): string;
+/**
+ * Extract
+ *
+ * @param node - The node.
+ * @returns The examples' texts.
+ * @example blocks from JSDoc
+ */
+export declare function getExamples(node: JSDocableNode): string[];
+/**
+ * Extract
+ *
+ * @param node - The node.
+ * @returns Each parameter's name mapped to its description.
+ */
+export declare function getParameterDescriptions(node: JSDocableNode): Map<string, string>;
+/**
+ * Strip `| undefined` only when it was implicitly added by ts-morph for optional properties
+ *
+ * @param property - The property.
+ * @returns The type text.
+ */
+export declare function getPropertyType(property: PropertyDeclaration | PropertySignature): string;
+/**
+ * Extract
+ *
+ * @param node - The node.
+ * @returns The remarks, or an empty string.
+ * @remarks text from JSDoc
+ */
+export declare function getRemarks(node: JSDocableNode): string;
+/**
+ * Extract
+ *
+ * @param node - The node.
+ * @returns description from JSDoc
+ */
+export declare function getReturnDescription(node: JSDocableNode): string;
+/**
+ * Extract the version a JSDoc `since` tag names.
+ *
+ * @param node - The node.
+ * @returns The version, or an empty string.
+ */
+export declare function getSince(node: JSDocableNode): string;
+/**
+ * Resolve `typeof aliasName` patterns where aliasName is an import alias.
+ * E.g., `typeof momentInstance` → `typeof moment` when `import { moment as momentInstance }`.
+ *
+ * @param typeText - The type text.
+ * @param sourceFile - The source file holding the imports.
+ * @returns The type text with the original names.
+ */
+export declare function resolveTypeofAliases(typeText: string, sourceFile: SourceFile): string;

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

@@ -0,0 +1,377 @@
+/*
+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 } from "@mnaoumov/typescript-lib/reg-exp";
+import { Scope } from "ts-morph";
+import {
+  computeOverloadKey,
+  foldTsDocParagraphs,
+  replaceRegExpMatches,
+  simplifyType
+} from "./api-doc-text-utils.mjs";
+function extractClassInfo(cls, namespace) {
+  const name = cls.getNameOrThrow();
+  const constructor = cls.getConstructors().find((c) => c.getScope() !== Scope.Private);
+  const extendsClause = cls.getExtends();
+  return {
+    baseTypes: extendsClause ? [extendsClause.getText()] : [],
+    constructorInfo: constructor ? extractConstructorInfo(constructor) : void 0,
+    description: getDescription(cls),
+    enumMembers: [],
+    examples: getExamples(cls),
+    implementsTypes: cls.getImplements().map((index) => index.getText()),
+    kind: "class",
+    methods: cls.getMethods().filter((m) => m.getScope() !== Scope.Private).map((m) => extractMethodInfo(m)),
+    name,
+    namespace,
+    properties: cls.getProperties().filter((p) => p.getScope() !== Scope.Private).map((p) => extractPropertyInfo(p)),
+    remarks: getRemarks(cls),
+    typeParameters: cls.getTypeParameters().map((tp) => tp.getText())
+  };
+}
+function extractConstructorInfo(ctor) {
+  const parameterDescriptions = getParameterDescriptions(ctor);
+  const params = ctor.getParameters().map((p) => {
+    const isOptional = p.isOptional();
+    const optionalSuffix = isOptional ? "?" : "";
+    return {
+      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? "*(Optional)*" : ""),
+      name: `${p.getName()}${optionalSuffix}`,
+      type: simplifyType(p.getType().getText())
+    };
+  });
+  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  return {
+    description: getDescription(ctor),
+    examples: getExamples(ctor),
+    inheritedFrom: "",
+    isStatic: false,
+    name: "constructor",
+    overloadKey: "constructor",
+    parameters: params,
+    remarks: getRemarks(ctor),
+    returnDescription: "",
+    returnType: "",
+    signature: `(${parameterString})`,
+    since: getSince(ctor),
+    type: ""
+  };
+}
+function extractEnumInfo(enumDeclaration, namespace) {
+  const members = enumDeclaration.getMembers().map((m) => {
+    const initializer = m.getInitializer()?.getText() ?? "";
+    return {
+      description: getDescription(m),
+      name: m.getName(),
+      value: initializer
+    };
+  });
+  return {
+    baseTypes: [],
+    description: getDescription(enumDeclaration),
+    enumMembers: members,
+    examples: getExamples(enumDeclaration),
+    implementsTypes: [],
+    kind: "enum",
+    methods: [],
+    name: enumDeclaration.getName(),
+    namespace,
+    properties: [],
+    remarks: getRemarks(enumDeclaration),
+    typeParameters: []
+  };
+}
+function extractFileOverview(src) {
+  const text = src.getFullText();
+  const blockMatch = /\/\*\*(?<body>[\s\S]*?)\*\//.exec(text);
+  if (!blockMatch) {
+    return "";
+  }
+  const body = getMandatoryNamedGroup(blockMatch, "body");
+  if (!/@file\b/.test(body)) {
+    return "";
+  }
+  const stripped = body.split("\n").map((line) => line.replace(/^\s*\*?\s?/, "")).join("\n");
+  const afterFileTag = stripped.replace(/[\s\S]*?@file[ \t]*\r?\n?/, "");
+  return foldTsDocParagraphs(afterFileTag.trim());
+}
+function extractInterfaceInfo(iface, namespace) {
+  return {
+    baseTypes: iface.getExtends().map((error) => error.getText()),
+    description: getDescription(iface),
+    enumMembers: [],
+    examples: getExamples(iface),
+    implementsTypes: [],
+    kind: "interface",
+    methods: iface.getMethods().map((m) => extractMethodSignatureInfo(m)),
+    name: iface.getName(),
+    namespace,
+    properties: iface.getProperties().map((p) => extractPropertySignatureInfo(p)),
+    remarks: getRemarks(iface),
+    typeParameters: iface.getTypeParameters().map((tp) => tp.getText())
+  };
+}
+function extractMethodInfo(method) {
+  const name = method.getName();
+  const parameterDescriptions = getParameterDescriptions(method);
+  const params = method.getParameters().map((p) => {
+    const isOptional = p.isOptional();
+    const optionalSuffix = isOptional ? "?" : "";
+    return {
+      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? "*(Optional)*" : ""),
+      name: `${p.getName()}${optionalSuffix}`,
+      type: simplifyType(p.getType().getText())
+    };
+  });
+  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const info = {
+    description: getDescription(method),
+    examples: getExamples(method),
+    inheritedFrom: "",
+    isStatic: method.isStatic(),
+    name,
+    overloadKey: "",
+    parameters: params,
+    remarks: getRemarks(method),
+    returnDescription: getReturnDescription(method),
+    returnType: getDeclaredReturnType(method),
+    signature: `${name}(${parameterString})`,
+    since: getSince(method),
+    type: ""
+  };
+  info.overloadKey = computeOverloadKey(info);
+  return info;
+}
+function extractMethodSignatureInfo(method) {
+  const name = method.getName();
+  const parameterDescriptions = getParameterDescriptions(method);
+  const params = method.getParameters().map((p) => {
+    const isOptional = p.isOptional();
+    const optionalSuffix = isOptional ? "?" : "";
+    return {
+      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? "*(Optional)*" : ""),
+      name: `${p.getName()}${optionalSuffix}`,
+      type: simplifyType(p.getType().getText())
+    };
+  });
+  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+  const info = {
+    description: getDescription(method),
+    examples: getExamples(method),
+    inheritedFrom: "",
+    isStatic: false,
+    name,
+    overloadKey: "",
+    parameters: params,
+    remarks: getRemarks(method),
+    returnDescription: getReturnDescription(method),
+    returnType: getDeclaredReturnType(method),
+    signature: `${name}(${parameterString})`,
+    since: getSince(method),
+    type: ""
+  };
+  info.overloadKey = computeOverloadKey(info);
+  return info;
+}
+function extractPropertyInfo(property) {
+  const name = property.getName();
+  const isOptional = property.hasQuestionToken();
+  const optionalSuffix = isOptional ? "?" : "";
+  return {
+    description: getDescription(property),
+    examples: getExamples(property),
+    inheritedFrom: "",
+    isStatic: property.isStatic(),
+    name: `${name}${optionalSuffix}`,
+    overloadKey: "",
+    parameters: [],
+    remarks: getRemarks(property),
+    returnDescription: "",
+    returnType: "",
+    signature: `${name}${optionalSuffix}`,
+    since: getSince(property),
+    type: getPropertyType(property)
+  };
+}
+function extractPropertySignatureInfo(property) {
+  const name = property.getName();
+  const isOptional = property.hasQuestionToken();
+  const optionalSuffix = isOptional ? "?" : "";
+  return {
+    description: getDescription(property),
+    examples: getExamples(property),
+    inheritedFrom: "",
+    isStatic: false,
+    name: `${name}${optionalSuffix}`,
+    overloadKey: "",
+    parameters: [],
+    remarks: getRemarks(property),
+    returnDescription: "",
+    returnType: "",
+    signature: `${name}${optionalSuffix}`,
+    since: getSince(property),
+    type: getPropertyType(property)
+  };
+}
+function extractTypeAliasInfo(alias, namespace) {
+  return {
+    baseTypes: [],
+    description: getDescription(alias),
+    enumMembers: [],
+    examples: getExamples(alias),
+    implementsTypes: [],
+    kind: "type",
+    methods: [],
+    name: alias.getName(),
+    namespace,
+    properties: [],
+    remarks: getRemarks(alias),
+    typeAliasText: simplifyType(alias.getTypeNodeOrThrow().getText()),
+    typeParameters: alias.getTypeParameters().map((tp) => tp.getText())
+  };
+}
+function getDeclaredReturnType(method) {
+  const annotation = method.getReturnTypeNode?.()?.getText();
+  return simplifyType(annotation ?? method.getReturnType().getText());
+}
+function getDescription(node) {
+  const lastDoc = node.getJsDocs().at(-1);
+  return lastDoc ? foldTsDocParagraphs(lastDoc.getDescription().trim()) : "";
+}
+function getExamples(node) {
+  const examples = [];
+  for (const doc of node.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() !== "example") {
+        continue;
+      }
+      const text = tag.getCommentText()?.trim() ?? "";
+      if (text) {
+        examples.push(text);
+      }
+    }
+  }
+  return examples;
+}
+function getParameterDescriptions(node) {
+  const result = /* @__PURE__ */ new Map();
+  const docs = node.getJsDocs();
+  for (const doc of docs) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() !== "param") {
+        continue;
+      }
+      const comment = foldTsDocParagraphs(tag.getCommentText()?.trim().replaceAll(/\s*\*\s*$/g, "").replace(/^-\s*/, "").trim() ?? "");
+      const tagText = tag.getText();
+      const nameMatch = /@param\s+(?:\{[^}]*\}\s+)?(?<paramName>\w+)/.exec(tagText);
+      if (nameMatch) {
+        result.set(getMandatoryNamedGroup(nameMatch, "paramName"), comment);
+      }
+    }
+  }
+  return result;
+}
+function getPropertyType(property) {
+  const typeNode = property.getTypeNode();
+  return typeNode ? resolveTypeofAliases(simplifyType(typeNode.getText()), property.getSourceFile()) : simplifyType(property.getType().getText());
+}
+function getRemarks(node) {
+  for (const doc of node.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === "remarks" || tag.getTagName() === "remark") {
+        return foldTsDocParagraphs(tag.getCommentText()?.trim().replaceAll(/\s*\*\s*$/g, "").trim() ?? "");
+      }
+    }
+  }
+  return "";
+}
+function getReturnDescription(node) {
+  for (const doc of node.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === "returns") {
+        return foldTsDocParagraphs(tag.getCommentText()?.trim().replace(/^-\s*/, "").replaceAll(/\s*\*\s*$/g, "").trim() ?? "");
+      }
+    }
+  }
+  return "";
+}
+function getSince(node) {
+  for (const doc of node.getJsDocs()) {
+    for (const tag of doc.getTags()) {
+      if (tag.getTagName() === "since") {
+        return tag.getCommentText()?.trim().replaceAll(/\s*\*\s*$/g, "").trim() ?? "";
+      }
+    }
+  }
+  return "";
+}
+function resolveTypeofAliases(typeText, sourceFile) {
+  return replaceRegExpMatches(typeText, /\btypeof (?<alias>[a-zA-Z][a-zA-Z0-9]*)\b/g, (match) => {
+    const alias = getMandatoryNamedGroup(match, "alias");
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+      for (const namedImport of importDeclaration.getNamedImports()) {
+        if (namedImport.getAliasNode()?.getText() === alias) {
+          return `typeof ${namedImport.getName()}`;
+        }
+      }
+    }
+    return match[0];
+  });
+}
+export {
+  extractClassInfo,
+  extractConstructorInfo,
+  extractEnumInfo,
+  extractFileOverview,
+  extractInterfaceInfo,
+  extractMethodInfo,
+  extractMethodSignatureInfo,
+  extractPropertyInfo,
+  extractPropertySignatureInfo,
+  extractTypeAliasInfo,
+  getDeclaredReturnType,
+  getDescription,
+  getExamples,
+  getParameterDescriptions,
+  getPropertyType,
+  getRemarks,
+  getReturnDescription,
+  getSince,
+  resolveTypeofAliases
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-jsdoc.ts"],"sourcesContent":["/**\n * @file\n *\n * JSDoc/declaration extraction: turns ts-morph declarations into the generator's `TypeInfo`/`MemberInfo`.\n */\n\nimport type {\n  ClassDeclaration,\n  ConstructorDeclaration,\n  EnumDeclaration,\n  InterfaceDeclaration,\n  JSDocableNode,\n  MethodDeclaration,\n  MethodSignature,\n  PropertyDeclaration,\n  PropertySignature,\n  SourceFile,\n  TypeAliasDeclaration\n} from 'ts-morph';\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport { Scope } from 'ts-morph';\n\nimport type {\n  EnumMemberInfo,\n  MemberInfo,\n  ReturnTypeProvider,\n  TypeInfo\n} from './api-doc-types.ts';\n\nimport {\n  computeOverloadKey,\n  foldTsDocParagraphs,\n  replaceRegExpMatches,\n  simplifyType\n} from './api-doc-text-utils.ts';\n\n/**\n * Extracts a class's model: its constructor, non-private properties and methods, and documentation.\n *\n * @param cls - The class declaration.\n * @param namespace - The type's namespace.\n * @returns The class's model.\n */\nexport function extractClassInfo(cls: ClassDeclaration, namespace: string): TypeInfo {\n  const name = cls.getNameOrThrow();\n  const constructor = cls.getConstructors().find((c) => c.getScope() !== Scope.Private);\n  const extendsClause = cls.getExtends();\n  return {\n    baseTypes: extendsClause ? [extendsClause.getText()] : [],\n    constructorInfo: constructor ? extractConstructorInfo(constructor) : undefined,\n    description: getDescription(cls),\n    enumMembers: [],\n    examples: getExamples(cls),\n    implementsTypes: cls.getImplements().map((index) => index.getText()),\n    kind: 'class',\n    methods: cls.getMethods().filter((m) => m.getScope() !== Scope.Private).map((m) => extractMethodInfo(m)),\n    name,\n    namespace,\n    properties: cls.getProperties().filter((p) => p.getScope() !== Scope.Private).map((p) => extractPropertyInfo(p)),\n    remarks: getRemarks(cls),\n    typeParameters: cls.getTypeParameters().map((tp) => tp.getText())\n  };\n}\n\n/**\n * Extracts a constructor's model.\n *\n * @param ctor - The constructor declaration.\n * @returns The constructor's model.\n */\nexport function extractConstructorInfo(ctor: ConstructorDeclaration): MemberInfo {\n  const parameterDescriptions = getParameterDescriptions(ctor);\n  const params = ctor.getParameters().map((p) => {\n    const isOptional = p.isOptional();\n    const optionalSuffix = isOptional ? '?' : '';\n    return {\n      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? '*(Optional)*' : ''),\n      name: `${p.getName()}${optionalSuffix}`,\n      type: simplifyType(p.getType().getText())\n    };\n  });\n  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(', ');\n  return {\n    description: getDescription(ctor),\n    examples: getExamples(ctor),\n    inheritedFrom: '',\n    isStatic: false,\n    name: 'constructor',\n    overloadKey: 'constructor',\n    parameters: params,\n    remarks: getRemarks(ctor),\n    returnDescription: '',\n    returnType: '',\n    signature: `(${parameterString})`,\n    since: getSince(ctor),\n    type: ''\n  };\n}\n\n/**\n * Extracts an enum's model.\n *\n * @param enumDeclaration - The enum declaration.\n * @param namespace - The type's namespace.\n * @returns The enum's model.\n */\nexport function extractEnumInfo(enumDeclaration: EnumDeclaration, namespace: string): TypeInfo {\n  const members: EnumMemberInfo[] = enumDeclaration.getMembers().map((m) => {\n    const initializer = m.getInitializer()?.getText() ?? '';\n    return {\n      description: getDescription(m),\n      name: m.getName(),\n      value: initializer\n    };\n  });\n  return {\n    baseTypes: [],\n    description: getDescription(enumDeclaration),\n    enumMembers: members,\n    examples: getExamples(enumDeclaration),\n    implementsTypes: [],\n    kind: 'enum',\n    methods: [],\n    name: enumDeclaration.getName(),\n    namespace,\n    properties: [],\n    remarks: getRemarks(enumDeclaration),\n    typeParameters: []\n  };\n}\n\n/**\n * Extract the module-level `@file` description text, if any.\n *\n * @param src - The source file.\n * @returns The overview, or an empty string when the file has no `@file` block.\n */\nexport function extractFileOverview(src: SourceFile): string {\n  const text = src.getFullText();\n  const blockMatch = /\\/\\*\\*(?<body>[\\s\\S]*?)\\*\\//.exec(text);\n  if (!blockMatch) {\n    return '';\n  }\n  const body = getMandatoryNamedGroup(blockMatch, 'body');\n  if (!/@file\\b/.test(body)) {\n    return '';\n  }\n  const stripped = body\n    .split('\\n')\n    .map((line) => line.replace(/^\\s*\\*?\\s?/, ''))\n    .join('\\n');\n  const afterFileTag = stripped.replace(/[\\s\\S]*?@file[ \\t]*\\r?\\n?/, '');\n  return foldTsDocParagraphs(afterFileTag.trim());\n}\n\n/**\n * Extracts an interface's model.\n *\n * @param iface - The interface declaration.\n * @param namespace - The type's namespace.\n * @returns The interface's model.\n */\nexport function extractInterfaceInfo(iface: InterfaceDeclaration, namespace: string): TypeInfo {\n  return {\n    baseTypes: iface.getExtends().map((error) => error.getText()),\n    description: getDescription(iface),\n    enumMembers: [],\n    examples: getExamples(iface),\n    implementsTypes: [],\n    kind: 'interface',\n    methods: iface.getMethods().map((m) => extractMethodSignatureInfo(m)),\n    name: iface.getName(),\n    namespace,\n    properties: iface.getProperties().map((p) => extractPropertySignatureInfo(p)),\n    remarks: getRemarks(iface),\n    typeParameters: iface.getTypeParameters().map((tp) => tp.getText())\n  };\n}\n\n/**\n * Extracts a class method's model.\n *\n * @param method - The method.\n * @returns The method's model.\n */\nexport function extractMethodInfo(method: MethodDeclaration): MemberInfo {\n  const name = method.getName();\n  const parameterDescriptions = getParameterDescriptions(method);\n  const params = method.getParameters().map((p) => {\n    const isOptional = p.isOptional();\n    const optionalSuffix = isOptional ? '?' : '';\n    return {\n      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? '*(Optional)*' : ''),\n      name: `${p.getName()}${optionalSuffix}`,\n      type: simplifyType(p.getType().getText())\n    };\n  });\n  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(', ');\n  const info: MemberInfo = {\n    description: getDescription(method),\n    examples: getExamples(method),\n    inheritedFrom: '',\n    isStatic: method.isStatic(),\n    name,\n    overloadKey: '',\n    parameters: params,\n    remarks: getRemarks(method),\n    returnDescription: getReturnDescription(method),\n    returnType: getDeclaredReturnType(method),\n    signature: `${name}(${parameterString})`,\n    since: getSince(method),\n    type: ''\n  };\n  info.overloadKey = computeOverloadKey(info);\n  return info;\n}\n\n/**\n * Extracts an interface method's model.\n *\n * @param method - The method.\n * @returns The method's model.\n */\nexport function extractMethodSignatureInfo(method: MethodSignature): MemberInfo {\n  const name = method.getName();\n  const parameterDescriptions = getParameterDescriptions(method);\n  const params = method.getParameters().map((p) => {\n    const isOptional = p.isOptional();\n    const optionalSuffix = isOptional ? '?' : '';\n    return {\n      description: parameterDescriptions.get(p.getName()) ?? (isOptional ? '*(Optional)*' : ''),\n      name: `${p.getName()}${optionalSuffix}`,\n      type: simplifyType(p.getType().getText())\n    };\n  });\n  const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(', ');\n  const info: MemberInfo = {\n    description: getDescription(method),\n    examples: getExamples(method),\n    inheritedFrom: '',\n    isStatic: false,\n    name,\n    overloadKey: '',\n    parameters: params,\n    remarks: getRemarks(method),\n    returnDescription: getReturnDescription(method),\n    returnType: getDeclaredReturnType(method),\n    signature: `${name}(${parameterString})`,\n    since: getSince(method),\n    type: ''\n  };\n  info.overloadKey = computeOverloadKey(info);\n  return info;\n}\n\n/**\n * Extracts a class property's model.\n *\n * @param property - The property.\n * @returns The property's model.\n */\nexport function extractPropertyInfo(property: PropertyDeclaration): MemberInfo {\n  const name = property.getName();\n  const isOptional = property.hasQuestionToken();\n  const optionalSuffix = isOptional ? '?' : '';\n  return {\n    description: getDescription(property),\n    examples: getExamples(property),\n    inheritedFrom: '',\n    isStatic: property.isStatic(),\n    name: `${name}${optionalSuffix}`,\n    overloadKey: '',\n    parameters: [],\n    remarks: getRemarks(property),\n    returnDescription: '',\n    returnType: '',\n    signature: `${name}${optionalSuffix}`,\n    since: getSince(property),\n    type: getPropertyType(property)\n  };\n}\n\n/**\n * Extracts an interface property's model.\n *\n * @param property - The property.\n * @returns The property's model.\n */\nexport function extractPropertySignatureInfo(property: PropertySignature): MemberInfo {\n  const name = property.getName();\n  const isOptional = property.hasQuestionToken();\n  const optionalSuffix = isOptional ? '?' : '';\n  return {\n    description: getDescription(property),\n    examples: getExamples(property),\n    inheritedFrom: '',\n    isStatic: false,\n    name: `${name}${optionalSuffix}`,\n    overloadKey: '',\n    parameters: [],\n    remarks: getRemarks(property),\n    returnDescription: '',\n    returnType: '',\n    signature: `${name}${optionalSuffix}`,\n    since: getSince(property),\n    type: getPropertyType(property)\n  };\n}\n\n/**\n * Extracts a type alias's model.\n *\n * @param alias - The type alias declaration.\n * @param namespace - The type's namespace.\n * @returns The type alias's model.\n */\nexport function extractTypeAliasInfo(alias: TypeAliasDeclaration, namespace: string): TypeInfo {\n  return {\n    baseTypes: [],\n    description: getDescription(alias),\n    enumMembers: [],\n    examples: getExamples(alias),\n    implementsTypes: [],\n    kind: 'type',\n    methods: [],\n    name: alias.getName(),\n    namespace,\n    properties: [],\n    remarks: getRemarks(alias),\n    typeAliasText: simplifyType(alias.getTypeNodeOrThrow().getText()),\n    typeParameters: alias.getTypeParameters().map((tp) => tp.getText())\n  };\n}\n\n/**\n * Get the return type as declared in source (preserves union order), falling back to resolved type\n *\n * @param method - The method or function.\n * @returns The return type.\n */\nexport function getDeclaredReturnType(method: ReturnTypeProvider): string {\n  const annotation = method.getReturnTypeNode?.()?.getText();\n  return simplifyType(annotation ?? method.getReturnType().getText());\n}\n\n/**\n * Extracts the JSDoc description of a node.\n *\n * @param node - The node.\n * @returns The description, or an empty string.\n */\nexport function getDescription(node: JSDocableNode): string {\n  const lastDoc = node.getJsDocs().at(-1);\n  return lastDoc ? foldTsDocParagraphs(lastDoc.getDescription().trim()) : '';\n}\n\n/**\n * Extract\n *\n * @param node - The node.\n * @returns The examples' texts.\n * @example blocks from JSDoc\n */\nexport function getExamples(node: JSDocableNode): string[] {\n  const examples: string[] = [];\n  for (const doc of node.getJsDocs()) {\n    for (const tag of doc.getTags()) {\n      if (tag.getTagName() !== 'example') {\n        continue;\n      }\n\n      const text = tag.getCommentText()?.trim() ?? '';\n      if (text) {\n        examples.push(text);\n      }\n    }\n  }\n  return examples;\n}\n\n/**\n * Extract\n *\n * @param node - The node.\n * @returns Each parameter's name mapped to its description.\n */\nexport function getParameterDescriptions(node: JSDocableNode): Map<string, string> {\n  const result = new Map<string, string>();\n  const docs = node.getJsDocs();\n  for (const doc of docs) {\n    for (const tag of doc.getTags()) {\n      if (tag.getTagName() !== 'param') {\n        continue;\n      }\n\n      const comment = foldTsDocParagraphs(tag.getCommentText()?.trim().replaceAll(/\\s*\\*\\s*$/g, '').replace(/^-\\s*/, '').trim() ?? '');\n      const tagText = tag.getText();\n      const nameMatch = /@param\\s+(?:\\{[^}]*\\}\\s+)?(?<paramName>\\w+)/.exec(tagText);\n      if (nameMatch) {\n        result.set(getMandatoryNamedGroup(nameMatch, 'paramName'), comment);\n      }\n    }\n  }\n  return result;\n}\n\n/**\n * Strip `| undefined` only when it was implicitly added by ts-morph for optional properties\n *\n * @param property - The property.\n * @returns The type text.\n */\nexport function getPropertyType(property: PropertyDeclaration | PropertySignature): string {\n  const typeNode = property.getTypeNode();\n  return typeNode ? resolveTypeofAliases(simplifyType(typeNode.getText()), property.getSourceFile()) : simplifyType(property.getType().getText());\n}\n\n/**\n * Extract\n *\n * @param node - The node.\n * @returns The remarks, or an empty string.\n * @remarks text from JSDoc\n */\nexport function getRemarks(node: JSDocableNode): string {\n  for (const doc of node.getJsDocs()) {\n    for (const tag of doc.getTags()) {\n      if (tag.getTagName() === 'remarks' || tag.getTagName() === 'remark') {\n        return foldTsDocParagraphs(tag.getCommentText()?.trim().replaceAll(/\\s*\\*\\s*$/g, '').trim() ?? '');\n      }\n    }\n  }\n  return '';\n}\n\n/**\n * Extract\n *\n * @param node - The node.\n * @returns description from JSDoc\n */\nexport function getReturnDescription(node: JSDocableNode): string {\n  for (const doc of node.getJsDocs()) {\n    for (const tag of doc.getTags()) {\n      if (tag.getTagName() === 'returns') {\n        return foldTsDocParagraphs(tag.getCommentText()?.trim().replace(/^-\\s*/, '').replaceAll(/\\s*\\*\\s*$/g, '').trim() ?? '');\n      }\n    }\n  }\n  return '';\n}\n\n/**\n * Extract the version a JSDoc `since` tag names.\n *\n * @param node - The node.\n * @returns The version, or an empty string.\n */\nexport function getSince(node: JSDocableNode): string {\n  for (const doc of node.getJsDocs()) {\n    for (const tag of doc.getTags()) {\n      if (tag.getTagName() === 'since') {\n        return tag.getCommentText()?.trim().replaceAll(/\\s*\\*\\s*$/g, '').trim() ?? '';\n      }\n    }\n  }\n  return '';\n}\n\n/**\n * Resolve `typeof aliasName` patterns where aliasName is an import alias.\n * E.g., `typeof momentInstance` → `typeof moment` when `import { moment as momentInstance }`.\n *\n * @param typeText - The type text.\n * @param sourceFile - The source file holding the imports.\n * @returns The type text with the original names.\n */\nexport function resolveTypeofAliases(typeText: string, sourceFile: SourceFile): string {\n  return replaceRegExpMatches(typeText, /\\btypeof (?<alias>[a-zA-Z][a-zA-Z0-9]*)\\b/g, (match) => {\n    const alias = getMandatoryNamedGroup(match, 'alias');\n    for (const importDeclaration of sourceFile.getImportDeclarations()) {\n      for (const namedImport of importDeclaration.getNamedImports()) {\n        if (namedImport.getAliasNode()?.getText() === alias) {\n          return `typeof ${namedImport.getName()}`;\n        }\n      }\n    }\n    return match[0];\n  });\n}\n"],"mappings":"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","names":[]}