@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/inspect/inspect-reverse-module-closure.js

@@ -0,0 +1,338 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseReverseModuleClosureForUsageTarget = shouldUseReverseModuleClosureForUsageTarget;
+exports.buildReverseModuleEntityClosure = buildReverseModuleEntityClosure;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function shouldUseReverseModuleClosureForUsageTarget(ts, role, node, exported = false) {
+    return role === "export" || (role === "self" && exported) || ts.isExportSpecifier(node) || ts.isExportDeclaration(node);
+}
+function buildReverseModuleEntityClosure(input) {
+    const started = performance.now();
+    const rssBeforeMiB = process.memoryUsage().rss / 1024 / 1024;
+    const namedEdges = new Map();
+    const openEdges = [];
+    const uncertainties = [];
+    const uncertaintyKeys = new Set();
+    const packageNameCache = new Map();
+    let bytesScanned = 0;
+    let edgeCount = 0;
+    const maxUncertainties = input.maxUncertainties ?? 100;
+    for (const rawFile of uniqueFiles(input.files)) {
+        let sourceText;
+        try {
+            sourceText = fs.readFileSync(rawFile, "utf8");
+        }
+        catch {
+            continue;
+        }
+        bytesScanned += Buffer.byteLength(sourceText);
+        const sourceFile = input.ts.createSourceFile(rawFile, sourceText, input.ts.ScriptTarget.Latest, true);
+        for (const edge of collectModuleEdges(input.ts, sourceFile)) {
+            edgeCount += 1;
+            if (edge.sourceName) {
+                const edges = namedEdges.get(edge.sourceName) ?? [];
+                edges.push(edge);
+                namedEdges.set(edge.sourceName, edges);
+            }
+            else {
+                openEdges.push(edge);
+            }
+        }
+    }
+    const occurrences = [];
+    const occurrenceKeys = new Set();
+    const visited = new Set();
+    const queue = input.seeds.map((seed) => ({ ...seed, file: path.normalize(seed.file) }));
+    // The indexed graph is finite and `visited` bounds cycles. Normal product
+    // traversal therefore has no arbitrary cutoff; a caller that explicitly
+    // requests a bound receives honest incomplete evidence below.
+    const maxStates = input.maxStates ?? Number.POSITIVE_INFINITY;
+    while (queue.length > 0 && visited.size < maxStates) {
+        const state = queue.shift();
+        const stateKey = `${state.id}\0${fileKey(state.file)}\0${state.entity}`;
+        if (visited.has(stateKey)) {
+            continue;
+        }
+        visited.add(stateKey);
+        for (const edge of [...(namedEdges.get(state.entity) ?? []), ...openEdges]) {
+            if (!edge.resolutionAttempted) {
+                edge.resolutionAttempted = true;
+                edge.toFile = input.resolveModule(edge.fromFile, edge.moduleSpecifier);
+            }
+            if (!edge.toFile) {
+                if (!edge.sourceName && !couldUnresolvedEdgeReachState(edge, state.file, packageNameCache)) {
+                    continue;
+                }
+                if (input.includeOccurrence(edge.fromFile)) {
+                    const kind = edge.kind === "namespace" ? "namespace" : edge.kind === "dynamic" ? "dynamic" : "unresolved";
+                    const key = `${fileKey(edge.fromFile)}\0${edge.start}\0${kind}`;
+                    if (!uncertaintyKeys.has(key)) {
+                        uncertaintyKeys.add(key);
+                        if (uncertainties.length < maxUncertainties) {
+                            uncertainties.push({ file: path.normalize(edge.fromFile), kind, moduleSpecifier: edge.moduleSpecifier, line: edge.line + 1 });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (fileKey(edge.toFile) !== fileKey(state.file)) {
+                continue;
+            }
+            if (edge.kind === "namespace" || edge.kind === "dynamic") {
+                addOccurrence(state, edge, true);
+                continue;
+            }
+            if (edge.kind === "exportStar") {
+                addOccurrence(state, edge, true);
+                queue.push({ id: state.id, file: edge.fromFile, entity: state.entity });
+                continue;
+            }
+            if (edge.sourceName !== state.entity) {
+                continue;
+            }
+            addOccurrence(state, edge, edge.uncertain);
+            if (edge.kind === "reexport" && edge.exposedName) {
+                queue.push({ id: state.id, file: edge.fromFile, entity: edge.exposedName });
+            }
+        }
+    }
+    const complete = queue.length === 0;
+    return {
+        occurrences: occurrences.sort(compareOccurrences),
+        uncertainties,
+        complete,
+        truncated: !complete,
+        pendingStateCount: queue.length,
+        uncertaintyTotal: uncertaintyKeys.size,
+        uncertaintiesTruncated: uncertaintyKeys.size > uncertainties.length,
+        filesScanned: uniqueFiles(input.files).length,
+        bytesScanned,
+        edgeCount,
+        statesVisited: visited.size,
+        programBuildCount: 0,
+        durationMs: performance.now() - started,
+        rssBeforeMiB,
+        rssAfterMiB: process.memoryUsage().rss / 1024 / 1024
+    };
+    function addOccurrence(state, edge, uncertain) {
+        if (!input.includeOccurrence(edge.fromFile)) {
+            return;
+        }
+        const key = `${state.id}\0${fileKey(edge.fromFile)}\0${edge.start}\0${edge.length}\0${edge.kind}`;
+        if (occurrenceKeys.has(key)) {
+            return;
+        }
+        occurrenceKeys.add(key);
+        occurrences.push({
+            seedId: state.id,
+            entity: state.entity,
+            file: path.normalize(edge.fromFile),
+            start: edge.start,
+            length: edge.length,
+            line: edge.line,
+            character: edge.character,
+            kind: edge.kind,
+            moduleSpecifier: edge.moduleSpecifier,
+            ...(edge.toFile ? { targetFile: path.normalize(edge.toFile) } : {}),
+            ...(edge.sourceName ? { importedName: edge.sourceName } : {}),
+            ...(edge.exposedName ? { exposedName: edge.exposedName } : {}),
+            ...(edge.localName ? { localName: edge.localName } : {}),
+            typeOnly: edge.typeOnly,
+            uncertain
+        });
+    }
+}
+function couldUnresolvedEdgeReachState(edge, stateFile, packageNameCache) {
+    if (edge.moduleSpecifier.startsWith(".")) {
+        const candidate = path.resolve(path.dirname(edge.fromFile), edge.moduleSpecifier);
+        const stateWithoutExtension = stripRuntimeExtension(path.resolve(stateFile));
+        return stateWithoutExtension === candidate ||
+            stateWithoutExtension === path.join(candidate, "index");
+    }
+    const packageName = containingPackageName(stateFile, packageNameCache);
+    return packageName !== null &&
+        (edge.moduleSpecifier === packageName || edge.moduleSpecifier.startsWith(`${packageName}/`));
+}
+function containingPackageName(file, cache) {
+    let current = path.dirname(path.resolve(file));
+    const visited = [];
+    while (true) {
+        const cached = cache.get(current);
+        if (cached !== undefined) {
+            for (const directory of visited)
+                cache.set(directory, cached);
+            return cached;
+        }
+        visited.push(current);
+        const packageJson = path.join(current, "package.json");
+        if (fs.existsSync(packageJson)) {
+            try {
+                const name = JSON.parse(fs.readFileSync(packageJson, "utf8"))?.name;
+                const result = typeof name === "string" && name.length > 0 ? name : null;
+                for (const directory of visited)
+                    cache.set(directory, result);
+                return result;
+            }
+            catch {
+                for (const directory of visited)
+                    cache.set(directory, null);
+                return null;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            for (const directory of visited)
+                cache.set(directory, null);
+            return null;
+        }
+        current = parent;
+    }
+}
+function stripRuntimeExtension(file) {
+    return file.replace(/\.(?:[cm]?[jt]sx?)$/i, "");
+}
+function collectModuleEdges(ts, sourceFile) {
+    const edges = [];
+    const importedLocals = new Map();
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+            const specifier = statement.moduleSpecifier.text;
+            const target = null;
+            const clause = statement.importClause;
+            if (!clause) {
+                continue;
+            }
+            if (clause.name) {
+                const edge = makeEdge(sourceFile, clause.name, "import", specifier, target, "default", clause.name.text, clause.isTypeOnly, false);
+                edges.push(edge);
+                importedLocals.set(clause.name.text, edge);
+            }
+            if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                    const sourceName = element.propertyName?.text ?? element.name.text;
+                    const node = element.propertyName ?? element.name;
+                    const edge = makeEdge(sourceFile, node, "import", specifier, target, sourceName, element.name.text, clause.isTypeOnly || element.isTypeOnly, false);
+                    edges.push(edge);
+                    importedLocals.set(element.name.text, edge);
+                }
+            }
+            else if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+                edges.push(makeEdge(sourceFile, clause.namedBindings.name, "namespace", specifier, target, undefined, clause.namedBindings.name.text, clause.isTypeOnly, true));
+            }
+            continue;
+        }
+        if (ts.isExportDeclaration(statement)) {
+            const specifier = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+                ? statement.moduleSpecifier.text
+                : null;
+            if (!statement.exportClause && specifier) {
+                edges.push(makeEdge(sourceFile, statement.moduleSpecifier, "exportStar", specifier, null, undefined, undefined, statement.isTypeOnly, true));
+                continue;
+            }
+            if (statement.exportClause && ts.isNamespaceExport(statement.exportClause) && specifier) {
+                edges.push(makeEdge(sourceFile, statement.exportClause.name, "namespace", specifier, null, undefined, statement.exportClause.name.text, statement.isTypeOnly, true));
+                continue;
+            }
+            if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+                for (const element of statement.exportClause.elements) {
+                    const localName = element.propertyName?.text ?? element.name.text;
+                    const exposedName = element.name.text;
+                    if (specifier) {
+                        edges.push(makeEdge(sourceFile, element.propertyName ?? element.name, "reexport", specifier, null, localName, undefined, statement.isTypeOnly || element.isTypeOnly, false, exposedName));
+                        continue;
+                    }
+                    const imported = importedLocals.get(localName);
+                    if (imported) {
+                        edges.push({
+                            ...imported,
+                            fromFile: sourceFile.fileName,
+                            kind: "reexport",
+                            exposedName,
+                            typeOnly: statement.isTypeOnly || element.isTypeOnly || imported.typeOnly
+                        });
+                    }
+                    else {
+                        edges.push(makeEdge(sourceFile, element.propertyName ?? element.name, "reexport", "", sourceFile.fileName, localName, undefined, statement.isTypeOnly || element.isTypeOnly, false, exposedName));
+                    }
+                }
+            }
+        }
+    }
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0])) {
+            const isDynamic = node.expression.kind === ts.SyntaxKind.ImportKeyword;
+            const isRequire = ts.isIdentifier(node.expression) && node.expression.text === "require";
+            if (isDynamic || isRequire) {
+                const specifier = node.arguments[0].text;
+                edges.push(makeEdge(sourceFile, node.arguments[0], "dynamic", specifier, null, undefined, undefined, false, true));
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return edges;
+}
+function makeEdge(sourceFile, node, kind, moduleSpecifier, toFile, sourceName, localName, typeOnly, uncertain, exposedName) {
+    const start = node.getStart(sourceFile);
+    const position = sourceFile.getLineAndCharacterOfPosition(start);
+    return {
+        fromFile: path.normalize(sourceFile.fileName),
+        toFile: toFile ? path.normalize(toFile) : null,
+        kind,
+        moduleSpecifier,
+        ...(sourceName ? { sourceName } : {}),
+        ...(exposedName ? { exposedName } : {}),
+        ...(localName ? { localName } : {}),
+        typeOnly,
+        uncertain,
+        start,
+        length: node.getWidth(sourceFile),
+        line: position.line,
+        character: position.character,
+        resolutionAttempted: Boolean(toFile)
+    };
+}
+function uniqueFiles(files) {
+    return [...new Map(files.map((file) => [fileKey(file), path.normalize(file)])).values()].sort();
+}
+function fileKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function compareOccurrences(left, right) {
+    return left.seedId.localeCompare(right.seedId) || left.file.localeCompare(right.file) || left.start - right.start || left.kind.localeCompare(right.kind);
+}

package/dist/inspect/inspect-source-ranges.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceSourceByRange = sliceSourceByRange;
+exports.positionToOffset = positionToOffset;
+exports.toRangeInfo = toRangeInfo;
+exports.rangeToPayload = rangeToPayload;
+exports.getNameStart = getNameStart;
+exports.getNameEnd = getNameEnd;
+exports.getNameNode = getNameNode;
+exports.firstLine = firstLine;
+exports.normalizeWhitespace = normalizeWhitespace;
+function sliceSourceByRange(sourceText, range) {
+    const startOffset = positionToOffset(sourceText, range.start);
+    const endOffset = positionToOffset(sourceText, range.end);
+    return sourceText.slice(startOffset, endOffset);
+}
+function positionToOffset(text, position) {
+    const lineStartOffsets = [0];
+    const newlinePattern = /\r\n|\r|\n/g;
+    let match;
+    while ((match = newlinePattern.exec(text)) !== null) {
+        lineStartOffsets.push(match.index + match[0].length);
+    }
+    const lineStart = lineStartOffsets[Math.min(position.line, lineStartOffsets.length - 1)] ?? 0;
+    return Math.max(0, Math.min(text.length, lineStart + position.character));
+}
+function toRangeInfo(sourceFile, startOffset, endOffset) {
+    const start = sourceFile.getLineAndCharacterOfPosition(startOffset);
+    const end = sourceFile.getLineAndCharacterOfPosition(endOffset);
+    return {
+        start: {
+            line: start.line,
+            character: start.character
+        },
+        end: {
+            line: end.line,
+            character: end.character
+        }
+    };
+}
+function rangeToPayload(range) {
+    return {
+        start: {
+            line: range.start.line,
+            character: range.start.character
+        },
+        end: {
+            line: range.end.line,
+            character: range.end.character
+        }
+    };
+}
+function getNameStart(ts, node) {
+    const nameNode = getNameNode(ts, node);
+    return nameNode ? nameNode.getStart() : node.getStart();
+}
+function getNameEnd(ts, node) {
+    const nameNode = getNameNode(ts, node);
+    return nameNode ? nameNode.getEnd() : node.getEnd();
+}
+function getNameNode(ts, node) {
+    if (ts.isConstructorDeclaration(node)) {
+        return null;
+    }
+    const maybeNamed = node;
+    if (maybeNamed.name) {
+        return maybeNamed.name;
+    }
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+        return node.name;
+    }
+    if (ts.isVariableStatement(node)) {
+        return node.declarationList.declarations[0]?.name ?? null;
+    }
+    return null;
+}
+function firstLine(text) {
+    return text.split(/\r?\n/, 1)[0]?.trim() ?? "";
+}
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, " ").trim();
+}