@codemap-ai/code-index 1.0.0

package/dist/parsers/typescript.js

@@ -0,0 +1,549 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeScriptOrJavaScriptFile = parseTypeScriptOrJavaScriptFile;
+const typescript_1 = __importDefault(require("typescript"));
+const shared_js_1 = require("./shared.js");
+function createSourceFile(file) {
+    return typescript_1.default.createSourceFile(file.baseName, file.content ?? "", typescript_1.default.ScriptTarget.Latest, true, file.extension === "tsx" || file.extension === "jsx"
+        ? typescript_1.default.ScriptKind.TSX
+        : typescript_1.default.ScriptKind.TS);
+}
+function getLineCol(sourceFile, pos) {
+    const lc = sourceFile.getLineAndCharacterOfPosition(pos);
+    return { line: lc.line + 1, col: lc.character };
+}
+// ─── Import/export extraction ─────────────────────────────────────────────────
+function extractImportsWithAst(file, sourceFile, filePathSet, projectImportId, workspacePath, resolverConfigs) {
+    const imports = [];
+    const exports = [];
+    const issues = [];
+    const externalSymbols = [];
+    function getNodeRange(node) {
+        const start = getLineCol(sourceFile, node.getStart(sourceFile));
+        const end = getLineCol(sourceFile, node.getEnd());
+        return {
+            line: start.line,
+            col: start.col,
+            endLine: end.line,
+            endCol: end.col,
+        };
+    }
+    const pushImport = (moduleSpecifier, importKind, isTypeOnly, node, importedNames) => {
+        const { line, col, endLine, endCol } = getNodeRange(node);
+        const isRelative = moduleSpecifier.startsWith(".");
+        const aliasResolution = !isRelative
+            ? (0, shared_js_1.resolveTsconfigAliasTargetPath)(workspacePath, file.path, moduleSpecifier, file.language, filePathSet, resolverConfigs)
+            : null;
+        const resolution = isRelative
+            ? (0, shared_js_1.resolveRelativeTargetPath)(file.path, moduleSpecifier, file.language, filePathSet)
+            : (aliasResolution ?? { resolvedPath: null, attemptedPath: null });
+        const importLocalKey = (0, shared_js_1.buildImportLocalKey)(file.path, importKind, moduleSpecifier, line, col);
+        imports.push({
+            localKey: importLocalKey,
+            moduleSpecifier,
+            importKind,
+            isTypeOnly,
+            importedNames,
+            line,
+            col,
+            endLine,
+            endCol,
+            resolutionKind: isRelative
+                ? resolution.resolvedPath ? "relative_path" : "unresolved"
+                : aliasResolution?.resolvedPath ? "tsconfig_alias"
+                    : aliasResolution?.matched ? "unresolved" : "package",
+            targetPathText: resolution.resolvedPath ?? resolution.attemptedPath,
+            targetExternalSymbolKey: isRelative || aliasResolution?.matched
+                ? null
+                : `${file.language?.toLowerCase()}:${moduleSpecifier}`,
+        });
+        if (!isRelative && !aliasResolution?.matched) {
+            externalSymbols.push((0, shared_js_1.createExternalSymbolDraft)(projectImportId, file.language, moduleSpecifier));
+        }
+        else if (!resolution.resolvedPath) {
+            issues.push({
+                projectImportId,
+                severity: "warning",
+                code: "UNRESOLVED_IMPORT",
+                message: `Unable to resolve module "${moduleSpecifier}" from ${file.path}`,
+                detailJson: { filePath: file.path, moduleSpecifier },
+            });
+        }
+        return importLocalKey;
+    };
+    function getModuleSpecifier(node) {
+        const spec = node.moduleSpecifier;
+        if (!spec || !typescript_1.default.isStringLiteral(spec))
+            return null;
+        return spec.text;
+    }
+    function extractNamedBindings(clause) {
+        return clause.elements.map((el) => {
+            // el.name is the local alias; el.propertyName is the original — we want the original
+            if ("propertyName" in el && el.propertyName) {
+                return el.propertyName.text;
+            }
+            return el.name.text;
+        });
+    }
+    typescript_1.default.forEachChild(sourceFile, (node) => {
+        // import ... from '...'
+        if (typescript_1.default.isImportDeclaration(node)) {
+            const specifier = getModuleSpecifier(node);
+            if (!specifier)
+                return;
+            const isTypeOnly = node.importClause?.isTypeOnly ?? false;
+            const clause = node.importClause;
+            const importedNames = [];
+            if (clause) {
+                // import Foo from '...' — default import, no named
+                // import { A, B } from '...'
+                if (clause.namedBindings) {
+                    if (typescript_1.default.isNamedImports(clause.namedBindings)) {
+                        importedNames.push(...extractNamedBindings(clause.namedBindings));
+                    }
+                    // import * as ns — namespace import
+                    if (typescript_1.default.isNamespaceImport(clause.namedBindings)) {
+                        const nsName = clause.namedBindings.name.text;
+                        const localKey = pushImport(specifier, "import", isTypeOnly, node, importedNames);
+                        // patch namespaceName onto the last pushed import
+                        const last = imports[imports.length - 1];
+                        if (last && last.localKey === localKey)
+                            last.namespaceName = nsName;
+                        return;
+                    }
+                }
+            }
+            pushImport(specifier, "import", isTypeOnly, node, importedNames);
+            return;
+        }
+        // export { A } from '...' / export * from '...' / export { A } (local)
+        if (typescript_1.default.isExportDeclaration(node)) {
+            const specifier = getModuleSpecifier(node);
+            const { line, col, endLine, endCol } = getNodeRange(node);
+            if (!specifier) {
+                // export { A, B } — local, no from
+                if (node.exportClause && typescript_1.default.isNamedExports(node.exportClause)) {
+                    for (const el of node.exportClause.elements) {
+                        const localName = el.propertyName?.text ?? el.name.text;
+                        const exportName = el.name.text;
+                        exports.push({
+                            exportName,
+                            exportKind: "named",
+                            line,
+                            col,
+                            endLine,
+                            endCol,
+                            symbolLocalKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, "variable", localName),
+                        });
+                    }
+                }
+                return;
+            }
+            const isTypeOnly = node.isTypeOnly;
+            if (node.exportClause && typescript_1.default.isNamedExports(node.exportClause)) {
+                // export { A, B } from '...'
+                const importLocalKey = pushImport(specifier, "export_from", isTypeOnly, node, []);
+                for (const el of node.exportClause.elements) {
+                    exports.push({
+                        exportName: el.name.text,
+                        exportKind: "re_export",
+                        line,
+                        col,
+                        endLine,
+                        endCol,
+                        sourceImportLocalKey: importLocalKey,
+                        targetExternalSymbolKey: specifier.startsWith(".") ? null : `${file.language?.toLowerCase()}:${specifier}`,
+                    });
+                }
+            }
+            else {
+                // export * from '...'
+                const importLocalKey = pushImport(specifier, "export_from", isTypeOnly, node, []);
+                exports.push({
+                    exportName: "*",
+                    exportKind: "wildcard",
+                    line,
+                    col,
+                    endLine,
+                    endCol,
+                    sourceImportLocalKey: importLocalKey,
+                    targetExternalSymbolKey: specifier.startsWith(".") ? null : `${file.language?.toLowerCase()}:${specifier}`,
+                });
+            }
+            return;
+        }
+        // require('...') and import('...') via CallExpression — walk full subtree
+        function walkForCalls(n) {
+            if (typescript_1.default.isCallExpression(n)) {
+                const expr = n.expression;
+                const args = n.arguments;
+                if (args.length === 1 && typescript_1.default.isStringLiteral(args[0])) {
+                    const specifier = args[0].text;
+                    if (typescript_1.default.isIdentifier(expr) && expr.text === "require") {
+                        pushImport(specifier, "require", false, n, []);
+                    }
+                    else if (expr.kind === typescript_1.default.SyntaxKind.ImportKeyword) {
+                        pushImport(specifier, "dynamic_import", false, n, []);
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(n, walkForCalls);
+        }
+        // Only walk statements that aren't import/export declarations (already handled)
+        if (!typescript_1.default.isImportDeclaration(node) && !typescript_1.default.isExportDeclaration(node)) {
+            walkForCalls(node);
+        }
+    });
+    return { imports, exports, issues, externalSymbols };
+}
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+function extractSymbolsWithAst(file, sourceFile) {
+    const content = file.content ?? "";
+    const symbols = [];
+    const relationships = [];
+    const lines = content.split(/\r?\n/);
+    function getSignature(node) {
+        const { line } = getLineCol(sourceFile, node.getStart(sourceFile));
+        return (lines[line - 1] ?? "").trim().slice(0, 200);
+    }
+    function getReturnType(node) {
+        if (typescript_1.default.isFunctionDeclaration(node) ||
+            typescript_1.default.isMethodDeclaration(node) ||
+            typescript_1.default.isFunctionExpression(node) ||
+            typescript_1.default.isArrowFunction(node)) {
+            return node.type ? node.type.getText(sourceFile).slice(0, 200) : null;
+        }
+        return null;
+    }
+    function getJSDoc(node) {
+        const tags = typescript_1.default.getJSDocCommentsAndTags(node);
+        if (tags.length === 0)
+            return null;
+        const parts = [];
+        for (const tag of tags) {
+            if (typescript_1.default.isJSDoc(tag) && tag.comment) {
+                const text = typeof tag.comment === "string"
+                    ? tag.comment
+                    : tag.comment.map((c) => c.text).join("");
+                if (text.trim())
+                    parts.push(text.trim());
+            }
+        }
+        return parts.length > 0 ? parts.join("\n").slice(0, 500) : null;
+    }
+    function pushSymbol(name, kind, node, isExported, isDefaultExport) {
+        const nameStart = content.indexOf(name, node.getStart(sourceFile));
+        const { line, col } = nameStart >= 0
+            ? getLineCol(sourceFile, nameStart)
+            : getLineCol(sourceFile, node.getStart(sourceFile));
+        const end = getLineCol(sourceFile, node.getEnd());
+        symbols.push({
+            localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, name),
+            stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, kind, name, line),
+            displayName: name,
+            kind,
+            language: file.language,
+            signature: getSignature(node),
+            returnType: getReturnType(node),
+            doc: getJSDoc(node),
+            isExported,
+            isDefaultExport,
+            line,
+            col,
+            endLine: end.line,
+            endCol: end.col,
+        });
+    }
+    // ─── Factory return-object method extraction (heuristic #1 + type-driven #2) ──
+    function getReturnedObjectLiteral(body) {
+        if (!body)
+            return null;
+        // Arrow function shorthand: () => ({ ... })
+        if (typescript_1.default.isParenthesizedExpression(body)) {
+            const inner = body.expression;
+            return typescript_1.default.isObjectLiteralExpression(inner) ? inner : null;
+        }
+        if (typescript_1.default.isObjectLiteralExpression(body))
+            return body;
+        if (!typescript_1.default.isBlock(body))
+            return null;
+        // Block body: find the last return statement
+        let returnedObj = null;
+        for (const stmt of body.statements) {
+            if (typescript_1.default.isReturnStatement(stmt) && stmt.expression) {
+                const expr = typescript_1.default.isParenthesizedExpression(stmt.expression)
+                    ? stmt.expression.expression
+                    : stmt.expression;
+                if (typescript_1.default.isObjectLiteralExpression(expr)) {
+                    returnedObj = expr;
+                }
+            }
+        }
+        return returnedObj;
+    }
+    // Heuristic #2: if the function has a return type annotation that is a TypeLiteral
+    // (e.g., ): { foo(): void; bar(): string }), extract allowed method names from it.
+    // Returns null if no type annotation or annotation is not a resolvable object type.
+    function getAllowedNamesFromReturnType(node) {
+        if (!node.type)
+            return null;
+        // ): { method1(): T; method2(): U }
+        if (typescript_1.default.isTypeLiteralNode(node.type)) {
+            const names = new Set();
+            for (const member of node.type.members) {
+                if ((typescript_1.default.isMethodSignature(member) || typescript_1.default.isPropertySignature(member)) &&
+                    typescript_1.default.isIdentifier(member.name)) {
+                    names.add(member.name.text);
+                }
+            }
+            return names.size > 0 ? names : null;
+        }
+        return null;
+    }
+    function extractReturnObjectMethods(fnNode, parentLocalKey, isParentExported) {
+        const body = fnNode.body;
+        // Extract inner function declarations defined inside the factory body (private helpers).
+        // Use line number as disambiguator so two factories in the same file can have
+        // identically-named helpers without a localKey collision.
+        const blockBody = body && "statements" in body ? body : null;
+        if (blockBody) {
+            for (const stmt of blockBody.statements) {
+                if (typescript_1.default.isFunctionDeclaration(stmt) && stmt.name) {
+                    const name = stmt.name.text;
+                    const { line, col } = getLineCol(sourceFile, stmt.getStart(sourceFile));
+                    const end = getLineCol(sourceFile, stmt.getEnd());
+                    const uniqueName = `${name}@${line}`;
+                    symbols.push({
+                        localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, "function", uniqueName),
+                        stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, "function", uniqueName, line),
+                        displayName: name,
+                        kind: "function",
+                        language: file.language,
+                        signature: getSignature(stmt),
+                        returnType: getReturnType(stmt),
+                        doc: getJSDoc(stmt),
+                        isExported: false,
+                        isDefaultExport: false,
+                        line,
+                        col,
+                        endLine: end.line,
+                        endCol: end.col,
+                        parentSymbolLocalKey: parentLocalKey,
+                    });
+                }
+            }
+        }
+        const obj = getReturnedObjectLiteral(body);
+        if (!obj)
+            return;
+        const allowedNames = getAllowedNamesFromReturnType(fnNode);
+        for (const prop of obj.properties) {
+            let name = null;
+            let methodNode = prop;
+            let isMethod = false;
+            if (typescript_1.default.isMethodDeclaration(prop) && typescript_1.default.isIdentifier(prop.name)) {
+                name = prop.name.text;
+                isMethod = true;
+            }
+            else if (typescript_1.default.isPropertyAssignment(prop) && typescript_1.default.isIdentifier(prop.name)) {
+                const init = prop.initializer;
+                if (typescript_1.default.isArrowFunction(init) || typescript_1.default.isFunctionExpression(init)) {
+                    name = prop.name.text;
+                    methodNode = prop;
+                    isMethod = true;
+                }
+            }
+            else if (typescript_1.default.isShorthandPropertyAssignment(prop)) {
+                // { foo } — reference to existing symbol, not a new method definition, skip
+            }
+            if (!name || !isMethod)
+                continue;
+            // If type annotation present, only index names that appear in it
+            if (allowedNames && !allowedNames.has(name))
+                continue;
+            const { line, col } = getLineCol(sourceFile, methodNode.getStart(sourceFile));
+            const end = getLineCol(sourceFile, methodNode.getEnd());
+            symbols.push({
+                localKey: (0, shared_js_1.buildLocalSymbolKey)(file.path, "method", name),
+                stableKey: (0, shared_js_1.buildStableSymbolKey)(file.path, "method", name, line),
+                displayName: name,
+                kind: "method",
+                language: file.language,
+                signature: getSignature(methodNode),
+                returnType: getReturnType(typescript_1.default.isMethodDeclaration(prop)
+                    ? prop
+                    : typescript_1.default.isPropertyAssignment(prop)
+                        ? prop.initializer
+                        : prop),
+                doc: getJSDoc(prop),
+                isExported: isParentExported,
+                isDefaultExport: false,
+                line,
+                col,
+                endLine: end.line,
+                endCol: end.col,
+                parentSymbolLocalKey: parentLocalKey,
+            });
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    function visitTopLevel(node) {
+        if (typescript_1.default.isExportAssignment(node)) {
+            const expr = node.expression;
+            if ((typescript_1.default.isFunctionExpression(expr) || typescript_1.default.isArrowFunction(expr)) &&
+                typescript_1.default.isIdentifier(expr.name ?? null)) {
+                const name = expr.name.text;
+                pushSymbol(name, "function", node, true, true);
+            }
+            return;
+        }
+        if (!typescript_1.default.isStatement(node))
+            return;
+        const modifiers = typescript_1.default.canHaveModifiers(node) ? typescript_1.default.getModifiers(node) : undefined;
+        const isExported = modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword) ?? false;
+        const isDefault = modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.DefaultKeyword) ?? false;
+        if (typescript_1.default.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            pushSymbol(name, "function", node, isExported, isDefault);
+            const localKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, "function", name);
+            extractReturnObjectMethods(node, localKey, isExported);
+            return;
+        }
+        if (typescript_1.default.isClassDeclaration(node) && node.name) {
+            const name = node.name.text;
+            pushSymbol(name, "class", node, isExported, isDefault);
+            const localKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, "class", name);
+            for (const clause of node.heritageClauses ?? []) {
+                const kind = clause.token === typescript_1.default.SyntaxKind.ExtendsKeyword ? "extends" : "implements";
+                for (const type of clause.types) {
+                    const targetName = type.expression.getText(sourceFile);
+                    relationships.push({ fromSymbolLocalKey: localKey, toSymbolName: targetName, relationshipKind: kind });
+                }
+            }
+            return;
+        }
+        if (typescript_1.default.isInterfaceDeclaration(node)) {
+            const name = node.name.text;
+            pushSymbol(name, "interface", node, isExported, false);
+            const localKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, "interface", name);
+            for (const clause of node.heritageClauses ?? []) {
+                for (const type of clause.types) {
+                    const targetName = type.expression.getText(sourceFile);
+                    relationships.push({ fromSymbolLocalKey: localKey, toSymbolName: targetName, relationshipKind: "extends" });
+                }
+            }
+            return;
+        }
+        if (typescript_1.default.isTypeAliasDeclaration(node)) {
+            pushSymbol(node.name.text, "type_alias", node, isExported, false);
+            return;
+        }
+        if (typescript_1.default.isEnumDeclaration(node)) {
+            pushSymbol(node.name.text, "enum", node, isExported, false);
+            return;
+        }
+        if (typescript_1.default.isVariableStatement(node) && isExported) {
+            for (const decl of node.declarationList.declarations) {
+                if (!typescript_1.default.isIdentifier(decl.name))
+                    continue;
+                const name = decl.name.text;
+                const isPascalCase = /^[A-Z]/.test(name);
+                let kind = "variable";
+                if (isPascalCase) {
+                    kind = "component";
+                }
+                else if (decl.initializer &&
+                    (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer))) {
+                    kind = "function";
+                }
+                pushSymbol(name, kind, decl, isExported, false);
+                if (decl.initializer &&
+                    (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer))) {
+                    const localKey = (0, shared_js_1.buildLocalSymbolKey)(file.path, kind, name);
+                    extractReturnObjectMethods(decl.initializer, localKey, isExported);
+                }
+            }
+        }
+    }
+    typescript_1.default.forEachChild(sourceFile, visitTopLevel);
+    return { symbols, relationships };
+}
+// ─── Call extraction ─────────────────────────────────────────────────────────
+function extractCallsWithAst(file, sourceFile) {
+    const calls = [];
+    function walk(node) {
+        if (typescript_1.default.isCallExpression(node)) {
+            const expr = node.expression;
+            let calleeName = null;
+            if (typescript_1.default.isIdentifier(expr)) {
+                calleeName = expr.text;
+            }
+            else if (typescript_1.default.isPropertyAccessExpression(expr) && typescript_1.default.isIdentifier(expr.name)) {
+                calleeName = expr.name.text;
+            }
+            if (calleeName && calleeName !== "require") {
+                const { line, col } = getLineCol(sourceFile, expr.getStart(sourceFile));
+                const namespaceName = typescript_1.default.isPropertyAccessExpression(expr) && typescript_1.default.isIdentifier(expr.expression)
+                    ? expr.expression.text
+                    : undefined;
+                calls.push({ calleeName, namespaceName, line, col, endCol: col + calleeName.length });
+            }
+            // don't skip children — call args may contain more references
+        }
+        else if (typescript_1.default.isPropertyAccessExpression(node) && typescript_1.default.isIdentifier(node.expression)) {
+            // standalone property access: CACHE_NAMESPACES.foo (not the expression of a call — already handled above)
+            const objectName = node.expression.text;
+            const { line, col } = getLineCol(sourceFile, node.expression.getStart(sourceFile));
+            calls.push({ calleeName: objectName, namespaceName: undefined, line, col, endCol: col + objectName.length });
+        }
+        else if (typescript_1.default.isIdentifier(node) &&
+            !typescript_1.default.isPropertyAccessExpression(node.parent) &&
+            !typescript_1.default.isCallExpression(node.parent) &&
+            !typescript_1.default.isImportDeclaration(node.parent) &&
+            !typescript_1.default.isImportSpecifier(node.parent) &&
+            !typescript_1.default.isVariableDeclaration(node.parent) &&
+            !typescript_1.default.isParameter(node.parent) &&
+            !typescript_1.default.isPropertyAssignment(node.parent) &&
+            !typescript_1.default.isShorthandPropertyAssignment(node.parent) &&
+            !typescript_1.default.isTypeReferenceNode(node.parent) &&
+            !typescript_1.default.isExportSpecifier(node.parent)) {
+            // bare identifier reference: CACHE_PREFIX used standalone (array element, argument, etc.)
+            const { line, col } = getLineCol(sourceFile, node.getStart(sourceFile));
+            calls.push({ calleeName: node.text, namespaceName: undefined, line, col, endCol: col + node.text.length });
+        }
+        typescript_1.default.forEachChild(node, walk);
+    }
+    typescript_1.default.forEachChild(sourceFile, walk);
+    return calls;
+}
+// ─── Entry point ──────────────────────────────────────────────────────────────
+function parseTypeScriptOrJavaScriptFile(file, filePathSet, projectImportId, workspacePath, resolverConfigs) {
+    const sourceFile = createSourceFile(file);
+    const { imports, exports, issues, externalSymbols } = extractImportsWithAst(file, sourceFile, filePathSet, projectImportId, workspacePath, resolverConfigs);
+    const { symbols: astSymbols, relationships } = extractSymbolsWithAst(file, sourceFile);
+    const calls = extractCallsWithAst(file, sourceFile);
+    const symbolExports = astSymbols
+        .filter((s) => s.isExported)
+        .map((s) => ({
+        exportName: s.isDefaultExport ? "default" : s.displayName,
+        exportKind: s.isDefaultExport ? "default" : "named",
+        line: s.line,
+        col: s.col,
+        endLine: s.endLine,
+        endCol: s.endCol,
+        symbolLocalKey: s.localKey,
+    }));
+    return {
+        symbols: astSymbols,
+        imports,
+        exports: [...exports, ...symbolExports],
+        relationships,
+        calls,
+        issues,
+        externalSymbols,
+    };
+}

package/dist/ts-resolver.d.ts

@@ -0,0 +1,17 @@
+export interface TypeScriptPathAliasPattern {
+    pattern: string;
+    hasWildcard: boolean;
+    prefix: string;
+    suffix: string;
+    targets: string[];
+}
+export interface TypeScriptResolverConfig {
+    configPath: string;
+    configDirPath: string;
+    configDirRelativePath: string;
+    baseUrlPath: string;
+    pathAliases: TypeScriptPathAliasPattern[];
+}
+export declare function normalizeWorkspaceRelativePath(workspacePath: string, targetPath: string): string;
+export declare function loadTypeScriptResolverConfigs(workspacePath: string): Promise<TypeScriptResolverConfig[]>;
+//# sourceMappingURL=ts-resolver.d.ts.map

package/dist/ts-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-resolver.d.ts","sourceRoot":"","sources":["../src/ts-resolver.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,0BAA0B,EAAE,CAAC;CAC3C;AAOD,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,UAKnB;AA2CD,wBAAsB,6BAA6B,CACjD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAwErC"}

package/dist/ts-resolver.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWorkspaceRelativePath = normalizeWorkspaceRelativePath;
+exports.loadTypeScriptResolverConfigs = loadTypeScriptResolverConfigs;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const file_discovery_js_1 = require("./file-discovery.js");
+function normalizeWorkspaceRelativePath(workspacePath, targetPath) {
+    const relativePath = node_path_1.default.relative(workspacePath, targetPath);
+    if (!relativePath)
+        return "";
+    return (0, file_discovery_js_1.normalizeRepositoryFilePath)(relativePath.split(node_path_1.default.sep).join("/"));
+}
+function readTsConfigFile(configPath) {
+    const readResult = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    if (readResult.error)
+        return null;
+    return readResult.config;
+}
+async function readTypeScriptCompilerOptionsConfig(configPath, visited = new Set()) {
+    if (visited.has(configPath))
+        return null;
+    visited.add(configPath);
+    try {
+        const parsed = readTsConfigFile(configPath);
+        const configDirPath = node_path_1.default.dirname(configPath);
+        let inheritedConfig = null;
+        if (parsed?.extends && parsed?.extends.startsWith(".")) {
+            const extendsPath = parsed.extends.endsWith(".json")
+                ? parsed.extends
+                : `${parsed.extends}.json`;
+            inheritedConfig = await readTypeScriptCompilerOptionsConfig(node_path_1.default.resolve(configDirPath, extendsPath), visited);
+        }
+        return {
+            baseUrl: parsed?.compilerOptions?.baseUrl ?? inheritedConfig?.baseUrl,
+            paths: parsed?.compilerOptions?.paths ?? inheritedConfig?.paths,
+        };
+    }
+    catch (error) {
+        console.log(error);
+        return null;
+    }
+}
+async function loadTypeScriptResolverConfigs(workspacePath) {
+    const configRelativePaths = ["tsconfig.json", "jsconfig.json"];
+    const discoveredConfigs = new Set();
+    async function visit(absolutePath) {
+        const entryStats = await (0, promises_1.lstat)(absolutePath);
+        if (entryStats.isSymbolicLink())
+            return;
+        const name = node_path_1.default.basename(absolutePath);
+        if (entryStats.isDirectory()) {
+            if (file_discovery_js_1.IGNORED_NAMES.has(name))
+                return;
+            const entries = await (0, promises_1.readdir)(absolutePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    await visit(node_path_1.default.join(absolutePath, entry.name));
+                    continue;
+                }
+                if (entry.isFile() && (entry.name === "tsconfig.json" || entry.name === "jsconfig.json")) {
+                    discoveredConfigs.add(node_path_1.default.join(absolutePath, entry.name));
+                }
+            }
+        }
+    }
+    for (const relativePath of configRelativePaths) {
+        discoveredConfigs.add(node_path_1.default.join(workspacePath, relativePath));
+    }
+    await visit(workspacePath);
+    const resolverConfigs = [];
+    for (const configPath of discoveredConfigs) {
+        try {
+            const compilerOptions = await readTypeScriptCompilerOptionsConfig(configPath);
+            if (!compilerOptions?.paths)
+                continue;
+            const configDirPath = node_path_1.default.dirname(configPath);
+            const baseUrlPath = node_path_1.default.resolve(configDirPath, compilerOptions.baseUrl ?? ".");
+            const pathAliases = Object.entries(compilerOptions.paths ?? {})
+                .filter(([, targets]) => Array.isArray(targets) && targets.length > 0)
+                .map(([pattern, targets]) => {
+                const wildcardIndex = pattern.indexOf("*");
+                return {
+                    pattern,
+                    hasWildcard: wildcardIndex >= 0,
+                    prefix: wildcardIndex >= 0 ? pattern.slice(0, wildcardIndex) : pattern,
+                    suffix: wildcardIndex >= 0 ? pattern.slice(wildcardIndex + 1) : "",
+                    targets,
+                };
+            });
+            if (pathAliases.length === 0)
+                continue;
+            resolverConfigs.push({
+                configPath,
+                configDirPath,
+                configDirRelativePath: normalizeWorkspaceRelativePath(workspacePath, configDirPath),
+                baseUrlPath,
+                pathAliases,
+            });
+        }
+        catch (error) {
+            console.log(`Failed to read TypeScript resolver config at ${configPath}`, error);
+        }
+    }
+    return resolverConfigs.sort((left, right) => right.configDirPath.length - left.configDirPath.length);
+}