adnbn 0.2.4 → 0.2.6

package/dist/cli/entrypoint/file/parsers/TypeResolver.js

@@ -0,0 +1,347 @@
+import ts from "typescript";
+import fs from "fs";
+import NodeFinder from "./NodeFinder.js";
+class TypeResolver {
+  /**
+   * Constructor for the TypeResolver.
+   *
+   * @param sourceFile The source file to resolve types from
+   * @param nodeFinder Optional NodeFinder instance to use for finding nodes
+   */
+  constructor(sourceFile, nodeFinder) {
+    this.sourceFile = sourceFile;
+    this.nodeFinder = nodeFinder;
+  }
+  /**
+   * Resolves a TypeScript type node to a string, inlining type aliases when possible.
+   *
+   * @param typeNode The type node to resolve
+   * @returns The resolved type as a string
+   */
+  resolveTypeNode(typeNode) {
+    if (ts.isUnionTypeNode(typeNode)) {
+      return this.resolveUnionType(typeNode);
+    }
+    if (ts.isArrayTypeNode(typeNode)) {
+      return this.resolveArrayType(typeNode);
+    }
+    if (ts.isTypeReferenceNode(typeNode)) {
+      return this.resolveTypeReference(typeNode);
+    }
+    return typeNode.getText();
+  }
+  /**
+   * Resolves a union type node to a string.
+   *
+   * @param typeNode The union type node to resolve
+   * @returns The resolved union type as a string
+   */
+  resolveUnionType(typeNode) {
+    const types = typeNode.types.map((t) => this.resolveTypeNode(t));
+    return types.join(" | ");
+  }
+  /**
+   * Resolves an array type node to a string.
+   *
+   * @param typeNode The array type node to resolve
+   * @returns The resolved array type as a string
+   */
+  resolveArrayType(typeNode) {
+    const elementType = this.resolveTypeNode(typeNode.elementType);
+    return `${elementType}[]`;
+  }
+  /**
+   * Resolves a type reference node to a string, inlining type aliases when possible.
+   *
+   * @param typeNode The type reference node to resolve
+   * @returns The resolved type reference as a string
+   */
+  resolveTypeReference(typeNode) {
+    const name = typeNode.typeName.getText();
+    const inlined = this.inlineAliasType(name);
+    if (inlined) {
+      return inlined;
+    }
+    const importPath = this.sourceFile.getImports().get(name);
+    if (importPath) {
+      try {
+        if (!fs.existsSync(importPath)) {
+          console.warn(`File not found: ${importPath} when resolving type reference ${name}`);
+          return typeNode.getText();
+        }
+        const parser = this.sourceFile.constructor.make(importPath);
+        const typeResolver = new TypeResolver(parser);
+        const nodeFinder = new NodeFinder(parser);
+        const interfaceDecl = nodeFinder.findInterfaceDeclaration(name);
+        if (interfaceDecl) {
+          const props = typeResolver.extractInterfaceProperties(interfaceDecl);
+          return props.length ? `{${props.join("; ")};}` : `{}`;
+        }
+        const aliasDecl = nodeFinder.findTypeAliasDeclaration(name);
+        if (aliasDecl) {
+          if (ts.isIntersectionTypeNode(aliasDecl.type)) {
+            return typeResolver.processIntersectionType(aliasDecl.type);
+          }
+          return typeResolver.resolveTypeNode(aliasDecl.type);
+        }
+      } catch (error) {
+        console.warn(`Error resolving type reference ${name} from ${importPath}:`, error);
+      }
+    }
+    if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
+      const aliasName = typeNode.typeName.getText();
+      const resolvedArgs = typeNode.typeArguments.map((arg) => this.resolveTypeNode(arg));
+      return `${aliasName}<${resolvedArgs.join(", ")}>`;
+    }
+    return typeNode.getText();
+  }
+  /**
+   * Attempts to inline a type alias.
+   *
+   * @param name The name of the type alias
+   * @returns The inlined type alias or undefined if it cannot be inlined
+   */
+  inlineAliasType(name) {
+    const importPath = this.sourceFile.getImports().get(name);
+    if (importPath && (importPath.startsWith("chrome.") || importPath.startsWith("browser."))) {
+      return importPath;
+    }
+    if (importPath && !importPath.startsWith(".") && !importPath.startsWith("/") && !fs.existsSync(importPath)) {
+      return `import('${importPath}').${name}`;
+    }
+    const nodeFinder = this.nodeFinder || new NodeFinder(this.sourceFile);
+    const importEquals = nodeFinder.findImportEqualsDeclaration(name);
+    if (importEquals && importEquals.moduleReference) {
+      if (ts.isQualifiedName(importEquals.moduleReference)) {
+        return importEquals.moduleReference.getText();
+      } else if (ts.isExternalModuleReference(importEquals.moduleReference) && importEquals.moduleReference.expression && ts.isStringLiteral(importEquals.moduleReference.expression)) {
+        const libPath = importEquals.moduleReference.expression.text;
+        return `import('${libPath}').${name}`;
+      } else {
+        return importEquals.moduleReference.getText();
+      }
+    }
+    const aliasDecl = this.findTypeAliasDeclaration(name);
+    if (aliasDecl) {
+      const typeNode = aliasDecl.type;
+      if (ts.isIntersectionTypeNode(typeNode)) {
+        return this.processIntersectionType(typeNode);
+      }
+      if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        return typeNode.getText();
+      }
+      return this.resolveTypeNode(typeNode);
+    }
+    const localInterface = nodeFinder.findInterfaceDeclaration(name);
+    if (localInterface) {
+      const props = this.extractInterfaceProperties(localInterface);
+      return props.length ? `{${props.join("; ")};}` : `{}`;
+    }
+    if (importPath) {
+      try {
+        if (!fs.existsSync(importPath)) {
+          console.warn(`File not found: ${importPath} when resolving type alias ${name}`);
+          return void 0;
+        }
+        const parser = this.sourceFile.constructor.make(importPath);
+        const typeResolver = new TypeResolver(parser);
+        const aliasDecl2 = nodeFinder.findTypeAliasDeclaration(name);
+        if (aliasDecl2) {
+          return typeResolver.inlineAliasType(name);
+        }
+        const interfaceDecl = nodeFinder.findInterfaceDeclaration(name);
+        if (interfaceDecl) {
+          const props = this.extractInterfaceProperties(interfaceDecl);
+          return props.length ? `{${props.join("; ")};}` : `{}`;
+        }
+      } catch (error) {
+        console.warn(`Error resolving type alias ${name} from ${importPath}:`, error);
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Processes an intersection type node by flattening its members
+   */
+  processIntersectionType(typeNode) {
+    const parts = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of typeNode.types) {
+      if (ts.isTypeLiteralNode(t)) {
+        for (const m of t.members) {
+          let keyName;
+          let entry;
+          if (ts.isPropertySignature(m) && m.type) {
+            keyName = this.getName(m.name);
+            const typeText = this.resolveTypeNode(m.type);
+            const formattedTypeText = typeText.replace(/\{\s+/g, "{").replace(/\s+\}/g, "}");
+            entry = `${keyName}: ${formattedTypeText}`;
+          } else if (ts.isMethodSignature(m) && m.name) {
+            keyName = this.getName(m.name);
+            const typeParams = m.typeParameters ? m.typeParameters.map((tp) => tp.getText()) : [];
+            const tpText = typeParams.length ? `<${typeParams.join(",")}>` : "";
+            const paramsText = m.parameters.map((p) => {
+              const pname = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();
+              const ptype = p.type ? this.resolveTypeNode(p.type) : "any";
+              const formattedPType = ptype.replace(/\{\s+/g, "{").replace(/\s+\}/g, "}");
+              return `${pname}: ${formattedPType}`;
+            }).join(",");
+            const returnType = m.type ? this.resolveTypeNode(m.type) : "any";
+            const formattedReturnType = returnType.replace(/\{\s+/g, "{").replace(/\s+\}/g, "}");
+            entry = `${keyName}${tpText}(${paramsText}): ${formattedReturnType}`;
+          } else if (ts.isIndexSignatureDeclaration(m) && m.type) {
+            const paramName = m.parameters[0].name.getText();
+            const paramType = m.parameters[0].type ? this.resolveTypeNode(m.parameters[0].type) : "any";
+            const returnType = this.resolveTypeNode(m.type);
+            keyName = `[${paramName}:${paramType}]`;
+            entry = `[${paramName}: ${paramType}]: ${returnType}`;
+          } else {
+            continue;
+          }
+          if (!seen.has(keyName)) {
+            seen.add(keyName);
+            parts.push(entry);
+          }
+        }
+      } else if (ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName)) {
+        const refName = t.typeName.text;
+        const sub = this.inlineAliasType(refName);
+        if (sub) {
+          this.extractSegmentsFromType(sub, seen, parts);
+        }
+      }
+    }
+    return `{${parts.join("; ")};}`;
+  }
+  /**
+   * Extracts segments from a type string, handling nested braces
+   */
+  extractSegmentsFromType(typeStr, seen, parts) {
+    const inner = typeStr.slice(1, -1).trim();
+    if (!inner) return;
+    const segments = [];
+    let depth = 0;
+    let buf = "";
+    for (const ch of inner) {
+      if (ch === "{") {
+        depth++;
+        buf += ch;
+      } else if (ch === "}") {
+        depth--;
+        buf += ch;
+      } else if (ch === ";" && depth === 0) {
+        const seg = buf.trim();
+        if (seg) segments.push(seg);
+        buf = "";
+      } else {
+        buf += ch;
+      }
+    }
+    const last = buf.trim();
+    if (last) segments.push(last);
+    for (const s of segments) {
+      const keyName = s.split(/[:(]/)[0];
+      if (!seen.has(keyName)) {
+        seen.add(keyName);
+        parts.push(s);
+      }
+    }
+  }
+  /**
+   * Extracts a textual property name.
+   */
+  getName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+      return name.text;
+    }
+    return name.getText();
+  }
+  /**
+   * Extracts properties from an interface declaration
+   */
+  extractInterfaceProperties(interfaceDecl, parser = this) {
+    const props = [];
+    if (interfaceDecl.heritageClauses) {
+      for (const clause of interfaceDecl.heritageClauses) {
+        if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+          for (const typeNode of clause.types) {
+            const expr = typeNode.expression;
+            if (ts.isIdentifier(expr)) {
+              const parent = parser.inlineAliasType(expr.text);
+              if (parent) {
+                const inner = parent.slice(1, -1).trim();
+                if (inner) {
+                  props.push(
+                    ...inner.split(/;\s*/).map((s) => s.trim()).filter(Boolean)
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (const member of interfaceDecl.members) {
+      if (ts.isPropertySignature(member) && member.type) {
+        const key = parser.getName(member.name);
+        const optional = member.questionToken ? "?" : "";
+        const typeText = parser.resolveTypeNode(member.type);
+        props.push(`${key}${optional}: ${typeText}`);
+      } else if (ts.isMethodSignature(member) && member.name) {
+        const key = parser.getName(member.name);
+        const typeParams = member.typeParameters ? member.typeParameters.map((tp) => tp.getText()) : [];
+        const tpText = typeParams.length ? `<${typeParams.join(",")}>` : "";
+        const params = member.parameters.map((p) => {
+          const pname = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();
+          const ptype = p.type ? parser.resolveTypeNode(p.type) : "any";
+          return `${pname}: ${ptype}`;
+        }).join(", ");
+        const returnType = member.type ? parser.resolveTypeNode(member.type) : "any";
+        props.push(`${key}${tpText}(${params}): ${returnType}`);
+      } else if (ts.isIndexSignatureDeclaration(member) && member.type) {
+        const paramName = member.parameters[0].name.getText();
+        const paramType = member.parameters[0].type ? parser.resolveTypeNode(member.parameters[0].type) : "any";
+        const returnType = parser.resolveTypeNode(member.type);
+        props.push(`[${paramName}: ${paramType}]: ${returnType}`);
+      }
+    }
+    return props;
+  }
+  /**
+   * Searches the AST of this file for a type alias declaration by name.
+   *
+   * @param name The name of the type alias to find
+   * @returns The type alias declaration or undefined if not found
+   */
+  findTypeAliasDeclaration(name) {
+    return this.findNodeByName(
+      (node, searchName) => ts.isTypeAliasDeclaration(node) && node.name.text === searchName,
+      name
+    );
+  }
+  /**
+   * Generic method to find a node of a specific type by name in the AST.
+   *
+   * @param predicate The predicate to match the node
+   * @param name The name to search for
+   * @returns The found node or undefined if not found
+   */
+  findNodeByName(predicate, name) {
+    const sf = this.sourceFile.getSourceFile();
+    let found;
+    const visit = (node) => {
+      if (predicate(node, name)) {
+        found = node;
+      } else {
+        ts.forEachChild(node, visit);
+      }
+    };
+    ts.forEachChild(sf, visit);
+    return found;
+  }
+}
+export {
+  TypeResolver as default
+};
+//# sourceMappingURL=TypeResolver.js.map

package/dist/cli/entrypoint/file/parsers/TypeResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/TypeResolver.ts"],"sourcesContent":["import ts from \"typescript\";\nimport fs from \"fs\";\nimport SourceFile from \"../SourceFile\";\nimport NodeFinder from \"./NodeFinder\";\n\n/**\n * Resolves TypeScript type nodes to string representations.\n */\nexport default class TypeResolver {\n    /**\n     * Constructor for the TypeResolver.\n     *\n     * @param sourceFile The source file to resolve types from\n     * @param nodeFinder Optional NodeFinder instance to use for finding nodes\n     */\n    constructor(\n        private readonly sourceFile: SourceFile,\n        private readonly nodeFinder?: NodeFinder\n    ) {}\n\n    /**\n     * Resolves a TypeScript type node to a string, inlining type aliases when possible.\n     *\n     * @param typeNode The type node to resolve\n     * @returns The resolved type as a string\n     */\n    public resolveTypeNode(typeNode: ts.TypeNode): string {\n        // Handle union types (like Tab | undefined)\n        if (ts.isUnionTypeNode(typeNode)) {\n            return this.resolveUnionType(typeNode);\n        }\n\n        // Handle array types (like Tab[])\n        if (ts.isArrayTypeNode(typeNode)) {\n            return this.resolveArrayType(typeNode);\n        }\n\n        // inline type aliases\n        if (ts.isTypeReferenceNode(typeNode)) {\n            return this.resolveTypeReference(typeNode);\n        }\n\n        // fallback: use textual representation\n        return typeNode.getText();\n    }\n\n    /**\n     * Resolves a union type node to a string.\n     *\n     * @param typeNode The union type node to resolve\n     * @returns The resolved union type as a string\n     */\n    public resolveUnionType(typeNode: ts.UnionTypeNode): string {\n        const types = typeNode.types.map(t => this.resolveTypeNode(t));\n        return types.join(\" | \");\n    }\n\n    /**\n     * Resolves an array type node to a string.\n     *\n     * @param typeNode The array type node to resolve\n     * @returns The resolved array type as a string\n     */\n    public resolveArrayType(typeNode: ts.ArrayTypeNode): string {\n        const elementType = this.resolveTypeNode(typeNode.elementType);\n        return `${elementType}[]`;\n    }\n\n    /**\n     * Resolves a type reference node to a string, inlining type aliases when possible.\n     *\n     * @param typeNode The type reference node to resolve\n     * @returns The resolved type reference as a string\n     */\n    public resolveTypeReference(typeNode: ts.TypeReferenceNode): string {\n        const name = typeNode.typeName.getText();\n\n        // Try to inline the type alias\n        const inlined = this.inlineAliasType(name);\n        if (inlined) {\n            return inlined;\n        }\n\n        // Check if the type is imported\n        const importPath = this.sourceFile.getImports().get(name);\n        if (importPath) {\n            try {\n                // Check if the file exists before creating a parser\n                if (!fs.existsSync(importPath)) {\n                    console.warn(`File not found: ${importPath} when resolving type reference ${name}`);\n                    return typeNode.getText();\n                }\n\n                const parser = (this.sourceFile.constructor as typeof SourceFile).make(importPath);\n                const typeResolver = new TypeResolver(parser);\n                const nodeFinder = new NodeFinder(parser);\n\n                // Check for interface declaration\n                const interfaceDecl = nodeFinder.findInterfaceDeclaration(name);\n                if (interfaceDecl) {\n                    const props = typeResolver.extractInterfaceProperties(interfaceDecl);\n                    return props.length ? `{${props.join(\"; \")};}` : `{}`;\n                }\n\n                // Check for type alias declaration\n                const aliasDecl = nodeFinder.findTypeAliasDeclaration(name);\n                if (aliasDecl) {\n                    // Handle intersection types specially\n                    if (ts.isIntersectionTypeNode(aliasDecl.type)) {\n                        return typeResolver.processIntersectionType(aliasDecl.type);\n                    }\n                    return typeResolver.resolveTypeNode(aliasDecl.type);\n                }\n            } catch (error) {\n                console.warn(`Error resolving type reference ${name} from ${importPath}:`, error);\n            }\n        }\n\n        // If there are type arguments, resolve them\n        if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {\n            const aliasName = typeNode.typeName.getText();\n            // Resolve each type argument\n            const resolvedArgs = typeNode.typeArguments.map(arg => this.resolveTypeNode(arg));\n            // Construct the type with resolved arguments\n            return `${aliasName}<${resolvedArgs.join(\", \")}>`;\n        }\n\n        // preserve generics and other references\n        return typeNode.getText();\n    }\n\n    /**\n     * Attempts to inline a type alias.\n     *\n     * @param name The name of the type alias\n     * @returns The inlined type alias or undefined if it cannot be inlined\n     */\n    public inlineAliasType(name: string): string | undefined {\n        // Check if the type is imported from an external library\n        const importPath = this.sourceFile.getImports().get(name);\n\n        // Special case for chrome.* namespaces\n        if (importPath && (importPath.startsWith(\"chrome.\") || importPath.startsWith(\"browser.\"))) {\n            return importPath;\n        }\n\n        if (importPath && !importPath.startsWith(\".\") && !importPath.startsWith(\"/\") && !fs.existsSync(importPath)) {\n            // This is an external library import, format it as import('libraryName').TypeName\n            return `import('${importPath}').${name}`;\n        }\n\n        // Check for import equals declaration (import X = Y.Z)\n        const nodeFinder = this.nodeFinder || new NodeFinder(this.sourceFile);\n        const importEquals = nodeFinder.findImportEqualsDeclaration(name);\n        if (importEquals && importEquals.moduleReference) {\n            // For qualified names like chrome.tabs.Tab, return the qualified name\n            if (ts.isQualifiedName(importEquals.moduleReference)) {\n                return importEquals.moduleReference.getText();\n            }\n            // For external module references like 'somelib', handle as external library\n            else if (\n                ts.isExternalModuleReference(importEquals.moduleReference) &&\n                importEquals.moduleReference.expression &&\n                ts.isStringLiteral(importEquals.moduleReference.expression)\n            ) {\n                const libPath = importEquals.moduleReference.expression.text;\n                return `import('${libPath}').${name}`;\n            }\n            // For other module references, return the text representation\n            else {\n                return importEquals.moduleReference.getText();\n            }\n        }\n\n        // Find the type alias declaration\n        const aliasDecl = this.findTypeAliasDeclaration(name);\n        if (aliasDecl) {\n            const typeNode = aliasDecl.type;\n\n            // handle intersection type alias by flattening members\n            if (ts.isIntersectionTypeNode(typeNode)) {\n                return this.processIntersectionType(typeNode);\n            }\n\n            // For type reference nodes (like aliases to other types), preserve the original type\n            if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {\n                // Get the full text of the type node, which includes any namespace qualifiers\n                return typeNode.getText();\n            }\n\n            return this.resolveTypeNode(typeNode);\n        }\n\n        // local interface\n        const localInterface = nodeFinder.findInterfaceDeclaration(name);\n        if (localInterface) {\n            const props = this.extractInterfaceProperties(localInterface);\n            return props.length ? `{${props.join(\"; \")};}` : `{}`;\n        }\n\n        // Handle imported types\n        if (importPath) {\n            try {\n                // Check if the file exists before creating a parser\n                if (!fs.existsSync(importPath)) {\n                    console.warn(`File not found: ${importPath} when resolving type alias ${name}`);\n                    return undefined;\n                }\n\n                const parser = (this.sourceFile.constructor as typeof SourceFile).make(importPath);\n                const typeResolver = new TypeResolver(parser);\n\n                // imported type alias\n                const aliasDecl = nodeFinder.findTypeAliasDeclaration(name);\n                if (aliasDecl) {\n                    // inline imported type alias (including intersections)\n                    return typeResolver.inlineAliasType(name);\n                }\n\n                // imported interface\n                const interfaceDecl = nodeFinder.findInterfaceDeclaration(name);\n                if (interfaceDecl) {\n                    const props = this.extractInterfaceProperties(interfaceDecl);\n                    return props.length ? `{${props.join(\"; \")};}` : `{}`;\n                }\n            } catch (error) {\n                console.warn(`Error resolving type alias ${name} from ${importPath}:`, error);\n                return undefined;\n            }\n        }\n\n        return undefined;\n    }\n\n    /**\n     * Processes an intersection type node by flattening its members\n     */\n    private processIntersectionType(typeNode: ts.IntersectionTypeNode): string {\n        const parts: string[] = [];\n        const seen = new Set<string>();\n\n        for (const t of typeNode.types) {\n            // inline object literal types\n            if (ts.isTypeLiteralNode(t)) {\n                for (const m of t.members) {\n                    let keyName: string;\n                    let entry: string;\n                    if (ts.isPropertySignature(m) && m.type) {\n                        keyName = this.getName(m.name!);\n                        const typeText = this.resolveTypeNode(m.type);\n                        // Remove spaces in object types to match expected format\n                        const formattedTypeText = typeText.replace(/\\{\\s+/g, \"{\").replace(/\\s+\\}/g, \"}\");\n                        entry = `${keyName}: ${formattedTypeText}`;\n                    } else if (ts.isMethodSignature(m) && m.name) {\n                        keyName = this.getName(m.name);\n                        const typeParams = m.typeParameters ? m.typeParameters.map(tp => tp.getText()) : [];\n                        const tpText = typeParams.length ? `<${typeParams.join(\",\")}>` : \"\";\n                        const paramsText = m.parameters\n                            .map(p => {\n                                const pname = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();\n                                const ptype = p.type ? this.resolveTypeNode(p.type) : \"any\";\n                                // Remove spaces in object types to match expected format\n                                const formattedPType = ptype.replace(/\\{\\s+/g, \"{\").replace(/\\s+\\}/g, \"}\");\n                                return `${pname}: ${formattedPType}`;\n                            })\n                            .join(\",\");\n                        const returnType = m.type ? this.resolveTypeNode(m.type) : \"any\";\n                        // Remove spaces in object types to match expected format\n                        const formattedReturnType = returnType.replace(/\\{\\s+/g, \"{\").replace(/\\s+\\}/g, \"}\");\n                        entry = `${keyName}${tpText}(${paramsText}): ${formattedReturnType}`;\n                    } else if (ts.isIndexSignatureDeclaration(m) && m.type) {\n                        // Handle index signatures like [domain: string]: number;\n                        const paramName = m.parameters[0].name.getText();\n                        const paramType = m.parameters[0].type ? this.resolveTypeNode(m.parameters[0].type) : \"any\";\n                        const returnType = this.resolveTypeNode(m.type);\n                        // Use a special key for index signatures to avoid conflicts\n                        keyName = `[${paramName}:${paramType}]`;\n                        entry = `[${paramName}: ${paramType}]: ${returnType}`;\n                    } else {\n                        continue;\n                    }\n                    if (!seen.has(keyName)) {\n                        seen.add(keyName);\n                        parts.push(entry);\n                    }\n                }\n            }\n            // inline referenced aliases or interfaces\n            else if (ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName)) {\n                const refName = t.typeName.text;\n                const sub = this.inlineAliasType(refName);\n                if (sub) {\n                    this.extractSegmentsFromType(sub, seen, parts);\n                }\n            }\n        }\n\n        return `{${parts.join(\"; \")};}`;\n    }\n\n    /**\n     * Extracts segments from a type string, handling nested braces\n     */\n    private extractSegmentsFromType(typeStr: string, seen: Set<string>, parts: string[]): void {\n        const inner = typeStr.slice(1, -1).trim();\n        if (!inner) return;\n\n        // split on top-level semicolons (ignore semicolons within braces)\n        const segments: string[] = [];\n        let depth = 0;\n        let buf = \"\";\n\n        for (const ch of inner) {\n            if (ch === \"{\") {\n                depth++;\n                buf += ch;\n            } else if (ch === \"}\") {\n                depth--;\n                buf += ch;\n            } else if (ch === \";\" && depth === 0) {\n                const seg = buf.trim();\n                if (seg) segments.push(seg);\n                buf = \"\";\n            } else {\n                buf += ch;\n            }\n        }\n\n        const last = buf.trim();\n        if (last) segments.push(last);\n\n        for (const s of segments) {\n            const keyName = s.split(/[:(]/)[0];\n            if (!seen.has(keyName)) {\n                seen.add(keyName);\n                parts.push(s);\n            }\n        }\n    }\n\n    /**\n     * Extracts a textual property name.\n     */\n    private getName(name: ts.PropertyName | ts.BindingName | ts.Node): string {\n        if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {\n            return name.text;\n        }\n\n        return name.getText();\n    }\n\n    /**\n     * Extracts properties from an interface declaration\n     */\n    public extractInterfaceProperties(interfaceDecl: ts.InterfaceDeclaration, parser: TypeResolver = this): string[] {\n        const props: string[] = [];\n\n        // include inherited members from extended interfaces\n        if (interfaceDecl.heritageClauses) {\n            for (const clause of interfaceDecl.heritageClauses) {\n                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {\n                    for (const typeNode of clause.types) {\n                        const expr = typeNode.expression;\n                        if (ts.isIdentifier(expr)) {\n                            const parent = parser.inlineAliasType(expr.text);\n                            if (parent) {\n                                const inner = parent.slice(1, -1).trim();\n                                if (inner) {\n                                    props.push(\n                                        ...inner\n                                            .split(/;\\s*/)\n                                            .map(s => s.trim())\n                                            .filter(Boolean)\n                                    );\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        // Add interface members\n        for (const member of interfaceDecl.members) {\n            if (ts.isPropertySignature(member) && member.type) {\n                const key = parser.getName(member.name!);\n                const optional = member.questionToken ? \"?\" : \"\";\n                const typeText = parser.resolveTypeNode(member.type);\n                props.push(`${key}${optional}: ${typeText}`);\n            } else if (ts.isMethodSignature(member) && member.name) {\n                const key = parser.getName(member.name);\n                const typeParams = member.typeParameters ? member.typeParameters.map(tp => tp.getText()) : [];\n                const tpText = typeParams.length ? `<${typeParams.join(\",\")}>` : \"\";\n\n                const params = member.parameters\n                    .map(p => {\n                        const pname = ts.isIdentifier(p.name) ? p.name.text : p.name.getText();\n                        const ptype = p.type ? parser.resolveTypeNode(p.type) : \"any\";\n                        return `${pname}: ${ptype}`;\n                    })\n                    .join(\", \");\n\n                const returnType = member.type ? parser.resolveTypeNode(member.type) : \"any\";\n\n                props.push(`${key}${tpText}(${params}): ${returnType}`);\n            } else if (ts.isIndexSignatureDeclaration(member) && member.type) {\n                // Handle index signatures like [domain: string]: number;\n                const paramName = member.parameters[0].name.getText();\n                const paramType = member.parameters[0].type ? parser.resolveTypeNode(member.parameters[0].type) : \"any\";\n                const returnType = parser.resolveTypeNode(member.type);\n                props.push(`[${paramName}: ${paramType}]: ${returnType}`);\n            }\n        }\n\n        return props;\n    }\n\n    /**\n     * Searches the AST of this file for a type alias declaration by name.\n     *\n     * @param name The name of the type alias to find\n     * @returns The type alias declaration or undefined if not found\n     */\n    private findTypeAliasDeclaration(name: string): ts.TypeAliasDeclaration | undefined {\n        return this.findNodeByName<ts.TypeAliasDeclaration>(\n            (node, searchName): node is ts.TypeAliasDeclaration =>\n                ts.isTypeAliasDeclaration(node) && node.name.text === searchName,\n            name\n        );\n    }\n\n    /**\n     * Generic method to find a node of a specific type by name in the AST.\n     *\n     * @param predicate The predicate to match the node\n     * @param name The name to search for\n     * @returns The found node or undefined if not found\n     */\n    private findNodeByName<T extends ts.Node>(\n        predicate: (node: ts.Node, name: string) => node is T,\n        name: string\n    ): T | undefined {\n        const sf = this.sourceFile.getSourceFile();\n        let found: T | undefined;\n\n        const visit = (node: ts.Node) => {\n            if (predicate(node, name)) {\n                found = node;\n            } else {\n                ts.forEachChild(node, visit);\n            }\n        };\n\n        ts.forEachChild(sf, visit);\n        return found;\n    }\n}\n"],"mappings":"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","names":["aliasDecl"]}

package/dist/cli/entrypoint/file/parsers/helpers/memberFilters.d.ts

@@ -0,0 +1,3 @@
+declare const shouldIncludeMember: (name: string) => boolean;
+
+export { shouldIncludeMember };

package/dist/cli/entrypoint/file/parsers/helpers/memberFilters.js

@@ -0,0 +1,7 @@
+const shouldIncludeMember = (name) => {
+  return !name.startsWith("_");
+};
+export {
+  shouldIncludeMember
+};
+//# sourceMappingURL=memberFilters.js.map

package/dist/cli/entrypoint/file/parsers/helpers/memberFilters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/cli/entrypoint/file/parsers/helpers/memberFilters.ts"],"sourcesContent":["export const shouldIncludeMember = (name: string): boolean => {\n    return !name.startsWith(\"_\");\n};\n"],"mappings":"AAAO,MAAM,sBAAsB,CAAC,SAA0B;AAC1D,SAAO,CAAC,KAAK,WAAW,GAAG;AAC/B;","names":[]}

package/dist/cli/entrypoint/file/parsers/index.d.ts

@@ -0,0 +1,14 @@
+export { default as FunctionParser } from './FunctionParser.js';
+export { default as ObjectParser } from './ObjectParser.js';
+export { default as ClassParser } from './ClassParser.js';
+export { default as TypeResolver } from './TypeResolver.js';
+export { default as SignatureBuilder } from './SignatureBuilder.js';
+export { default as NodeFinder } from './NodeFinder.js';
+export { default as JSDocParser } from './JSDocParser.js';
+import 'typescript';
+import '../SourceFile.js';
+import '../resolvers/ImportResolver.js';
+import '../resolvers/TsResolver.js';
+import '../types.js';
+import './AbstractParser.js';
+import './types.js';

package/dist/cli/entrypoint/file/parsers/index.js

@@ -0,0 +1,17 @@
+import { default as default2 } from "./FunctionParser.js";
+import { default as default3 } from "./ObjectParser.js";
+import { default as default4 } from "./ClassParser.js";
+import { default as default5 } from "./TypeResolver.js";
+import { default as default6 } from "./SignatureBuilder.js";
+import { default as default7 } from "./NodeFinder.js";
+import { default as default8 } from "./JSDocParser.js";
+export {
+  default4 as ClassParser,
+  default2 as FunctionParser,
+  default8 as JSDocParser,
+  default7 as NodeFinder,
+  default3 as ObjectParser,
+  default6 as SignatureBuilder,
+  default5 as TypeResolver
+};
+//# sourceMappingURL=index.js.map

package/dist/cli/entrypoint/file/parsers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/parsers/index.ts"],"sourcesContent":["export {default as FunctionParser} from \"./FunctionParser\";\nexport {default as ObjectParser} from \"./ObjectParser\";\nexport {default as ClassParser} from \"./ClassParser\";\nexport {default as TypeResolver} from \"./TypeResolver\";\nexport {default as SignatureBuilder} from \"./SignatureBuilder\";\nexport {default as NodeFinder} from \"./NodeFinder\";\nexport {default as JSDocParser} from \"./JSDocParser\";\n"],"mappings":"AAAA,SAAmB,WAAXA,gBAAgC;AACxC,SAAmB,WAAXA,gBAA8B;AACtC,SAAmB,WAAXA,gBAA6B;AACrC,SAAmB,WAAXA,gBAA8B;AACtC,SAAmB,WAAXA,gBAAkC;AAC1C,SAAmB,WAAXA,gBAA4B;AACpC,SAAmB,WAAXA,gBAA6B;","names":["default"]}

package/dist/cli/entrypoint/file/parsers/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Signature of a method parameter.
+ */
+interface ParameterSignature {
+    name: string;
+    type: string;
+    optional: boolean;
+}
+/**
+ * Signature of a method.
+ */
+interface MethodSignature {
+    kind: "method";
+    typeParameters: string[];
+    parameters: ParameterSignature[];
+    returnType: string;
+}
+/**
+ * Signature of a property.
+ */
+interface PropertySignature {
+    kind: "property";
+    type: string;
+    optional?: boolean;
+}
+/**
+ * Member of an interface: either a method or a property.
+ */
+type MemberSignature = MethodSignature | PropertySignature;
+
+export type { MemberSignature, MethodSignature, ParameterSignature, PropertySignature };

package/dist/cli/entrypoint/file/parsers/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/cli/entrypoint/file/parsers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/cli/entrypoint/file/resolvers/ImportResolver.d.ts

@@ -0,0 +1,13 @@
+import TsResolver from './TsResolver.js';
+import 'typescript';
+
+declare class export_default{
+    protected ts: TsResolver;
+    protected baseDir: string;
+    constructor(ts?: TsResolver);
+    setTs(ts: TsResolver): this;
+    setBaseDir(baseDir: string): this;
+    get(importPath: string): string;
+}
+
+export { export_default as default };

package/dist/cli/entrypoint/file/resolvers/ImportResolver.js

@@ -0,0 +1,72 @@
+import path from "path";
+import fs from "fs";
+import { createRequire } from "module";
+import TsResolver from "./TsResolver.js";
+import { PackageName } from "./../../../../types/app.js";
+import { EntrypointFileExtensions } from "./../../../../types/entrypoint.js";
+const extPattern = [...EntrypointFileExtensions].map((ext) => ext.replace(".", "\\.")).join("|");
+const extRegex = new RegExp(`\\.(${extPattern})$`, "i");
+const isValid = (filePath) => {
+  return extRegex.test(filePath);
+};
+const findFile = (basePath) => {
+  const candidates = [basePath, path.join(basePath, "index")];
+  for (const ext of EntrypointFileExtensions) {
+    for (const candidate of candidates) {
+      const pathname = `${candidate}.${ext}`;
+      if (fs.existsSync(pathname)) {
+        return pathname;
+      }
+    }
+  }
+};
+class ImportResolver_default {
+  constructor(ts = TsResolver.make()) {
+    this.ts = ts;
+    this.baseDir = process.cwd();
+  }
+  baseDir;
+  setTs(ts) {
+    this.ts = ts;
+    return this;
+  }
+  setBaseDir(baseDir) {
+    this.baseDir = baseDir;
+    return this;
+  }
+  get(importPath) {
+    if (importPath.startsWith(".") || importPath.startsWith("/")) {
+      let resolvedLocal = path.resolve(this.baseDir, importPath);
+      if (isValid(resolvedLocal) && fs.existsSync(resolvedLocal)) {
+        return resolvedLocal;
+      }
+      resolvedLocal = findFile(resolvedLocal);
+      if (resolvedLocal) {
+        return resolvedLocal;
+      }
+      return importPath;
+    }
+    let aliased = this.ts.matchPath(importPath);
+    if (aliased) {
+      if (isValid(aliased) && fs.existsSync(aliased)) {
+        return path.resolve(aliased);
+      }
+      aliased = findFile(aliased);
+      if (aliased) {
+        return path.resolve(aliased);
+      }
+    }
+    try {
+      if (importPath === PackageName || importPath.startsWith(`${PackageName}/`)) {
+        return importPath;
+      }
+      return createRequire(import.meta.url).resolve(importPath, { paths: [this.baseDir] });
+    } catch {
+      return importPath;
+    }
+  }
+}
+export {
+  ImportResolver_default as default
+};
+//# sourceMappingURL=ImportResolver.js.map

package/dist/cli/entrypoint/file/resolvers/ImportResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/cli/entrypoint/file/resolvers/ImportResolver.ts"],"sourcesContent":["import path from \"path\";\nimport fs from \"fs\";\nimport {createRequire} from \"module\";\n\nimport TsResolver from \"./TsResolver\";\n\nimport {PackageName} from \"@typing/app\";\nimport {EntrypointFileExtensions} from \"@typing/entrypoint\";\n\nconst extPattern = [...EntrypointFileExtensions].map(ext => ext.replace(\".\", \"\\\\.\")).join(\"|\");\n\nconst extRegex = new RegExp(`\\\\.(${extPattern})$`, \"i\");\n\nconst isValid = (filePath: string): boolean => {\n    return extRegex.test(filePath);\n};\n\nconst findFile = (basePath: string): string | undefined => {\n    const candidates = [basePath, path.join(basePath, \"index\")];\n\n    for (const ext of EntrypointFileExtensions) {\n        for (const candidate of candidates) {\n            const pathname = `${candidate}.${ext}`;\n\n            if (fs.existsSync(pathname)) {\n                return pathname;\n            }\n        }\n    }\n};\n\nexport default class {\n    protected baseDir: string;\n\n    constructor(protected ts: TsResolver = TsResolver.make()) {\n        this.baseDir = process.cwd();\n    }\n\n    public setTs(ts: TsResolver): this {\n        this.ts = ts;\n\n        return this;\n    }\n\n    public setBaseDir(baseDir: string): this {\n        this.baseDir = baseDir;\n\n        return this;\n    }\n\n    public get(importPath: string): string {\n        if (importPath.startsWith(\".\") || importPath.startsWith(\"/\")) {\n            let resolvedLocal: string | undefined = path.resolve(this.baseDir, importPath);\n\n            if (isValid(resolvedLocal) && fs.existsSync(resolvedLocal)) {\n                return resolvedLocal;\n            }\n\n            resolvedLocal = findFile(resolvedLocal);\n\n            if (resolvedLocal) {\n                return resolvedLocal;\n            }\n\n            return importPath;\n        }\n\n        let aliased = this.ts.matchPath(importPath);\n\n        if (aliased) {\n            if (isValid(aliased) && fs.existsSync(aliased)) {\n                return path.resolve(aliased);\n            }\n\n            aliased = findFile(aliased);\n\n            if (aliased) {\n                return path.resolve(aliased);\n            }\n        }\n\n        try {\n            if (importPath === PackageName || importPath.startsWith(`${PackageName}/`)) {\n                return importPath;\n            }\n\n            return createRequire(import.meta.url).resolve(importPath, {paths: [this.baseDir]});\n        } catch {\n            return importPath;\n        }\n    }\n}\n"],"mappings":"AAAA,OAAO,UAAU;AACjB,OAAO,QAAQ;AACf,SAAQ,qBAAoB;AAE5B,OAAO,gBAAgB;AAEvB,SAAQ,mBAAkB;AAC1B,SAAQ,gCAA+B;AAEvC,MAAM,aAAa,CAAC,GAAG,wBAAwB,EAAE,IAAI,SAAO,IAAI,QAAQ,KAAK,KAAK,CAAC,EAAE,KAAK,GAAG;AAE7F,MAAM,WAAW,IAAI,OAAO,OAAO,UAAU,MAAM,GAAG;AAEtD,MAAM,UAAU,CAAC,aAA8B;AAC3C,SAAO,SAAS,KAAK,QAAQ;AACjC;AAEA,MAAM,WAAW,CAAC,aAAyC;AACvD,QAAM,aAAa,CAAC,UAAU,KAAK,KAAK,UAAU,OAAO,CAAC;AAE1D,aAAW,OAAO,0BAA0B;AACxC,eAAW,aAAa,YAAY;AAChC,YAAM,WAAW,GAAG,SAAS,IAAI,GAAG;AAEpC,UAAI,GAAG,WAAW,QAAQ,GAAG;AACzB,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACJ;AACJ;AAEA,MAAO,uBAAc;AAAA,EAGjB,YAAsB,KAAiB,WAAW,KAAK,GAAG;AAApC;AAClB,SAAK,UAAU,QAAQ,IAAI;AAAA,EAC/B;AAAA,EAJU;AAAA,EAMH,MAAM,IAAsB;AAC/B,SAAK,KAAK;AAEV,WAAO;AAAA,EACX;AAAA,EAEO,WAAW,SAAuB;AACrC,SAAK,UAAU;AAEf,WAAO;AAAA,EACX;AAAA,EAEO,IAAI,YAA4B;AACnC,QAAI,WAAW,WAAW,GAAG,KAAK,WAAW,WAAW,GAAG,GAAG;AAC1D,UAAI,gBAAoC,KAAK,QAAQ,KAAK,SAAS,UAAU;AAE7E,UAAI,QAAQ,aAAa,KAAK,GAAG,WAAW,aAAa,GAAG;AACxD,eAAO;AAAA,MACX;AAEA,sBAAgB,SAAS,aAAa;AAEtC,UAAI,eAAe;AACf,eAAO;AAAA,MACX;AAEA,aAAO;AAAA,IACX;AAEA,QAAI,UAAU,KAAK,GAAG,UAAU,UAAU;AAE1C,QAAI,SAAS;AACT,UAAI,QAAQ,OAAO,KAAK,GAAG,WAAW,OAAO,GAAG;AAC5C,eAAO,KAAK,QAAQ,OAAO;AAAA,MAC/B;AAEA,gBAAU,SAAS,OAAO;AAE1B,UAAI,SAAS;AACT,eAAO,KAAK,QAAQ,OAAO;AAAA,MAC/B;AAAA,IACJ;AAEA,QAAI;AACA,UAAI,eAAe,eAAe,WAAW,WAAW,GAAG,WAAW,GAAG,GAAG;AACxE,eAAO;AAAA,MACX;AAEA,aAAO,cAAc,YAAY,GAAG,EAAE,QAAQ,YAAY,EAAC,OAAO,CAAC,KAAK,OAAO,EAAC,CAAC;AAAA,IACrF,QAAQ;AACJ,aAAO;AAAA,IACX;AAAA,EACJ;AACJ;","names":[]}

package/dist/cli/entrypoint/file/resolvers/TsResolver.d.ts

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+
+declare class TsResolver {
+    protected static readonly instances: Map<string, TsResolver>;
+    protected filename: string;
+    protected config?: ts.ParsedCommandLine;
+    get matchPath(): {
+        (path: string): string | undefined;
+    };
+    static make(filename?: string): TsResolver;
+    constructor(filename?: string);
+    getFilename(): string;
+    setFilename(filename: string): this;
+    getConfig(): ts.ParsedCommandLine;
+}
+
+export { TsResolver as default };