@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/mutation/semantic-export-index.js

@@ -0,0 +1,474 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemanticWorkspaceExportContext = createSemanticWorkspaceExportContext;
+exports.buildSemanticExportIndex = buildSemanticExportIndex;
+exports.buildSemanticExportIndexFromProvider = buildSemanticExportIndexFromProvider;
+exports.buildSemanticModuleExportSurface = buildSemanticModuleExportSurface;
+exports.resolveSemanticExportEdgeSelector = resolveSemanticExportEdgeSelector;
+exports.normalizeExportEdgeSelector = normalizeExportEdgeSelector;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const semantic_workspace_1 = require("./semantic-workspace");
+function createSemanticWorkspaceExportContext(workspace) {
+    const handles = new Map(workspace.projects.map((project) => [project, {
+            id: repoPath(workspace.root, project.config.file),
+            checker: project.checker,
+            getSourceFile: (file) => project.program.getSourceFile(path.resolve(workspace.root, file)),
+            resolveModule: (fromFile, specifier) => typescript_1.default.resolveModuleName(specifier, path.resolve(workspace.root, fromFile), project.config.parsed.options, typescript_1.default.sys).resolvedModule?.resolvedFileName ?? null,
+            symbolIdentity: (symbol) => (0, semantic_workspace_1.resolveSemanticSymbolIdentity)(workspace, project, symbol),
+            diagnosticsForFile: (file) => {
+                const source = project.program.getSourceFile(path.resolve(workspace.root, file));
+                return source ? project.program.getSemanticDiagnostics(source) : [];
+            }
+        }]));
+    return {
+        root: workspace.root,
+        projectsForFile: (file) => (0, semantic_workspace_1.ownersForSemanticFile)(workspace, file).map((project) => handles.get(project))
+    };
+}
+function buildSemanticExportIndex(workspace, input, hooks = {}) {
+    return buildSemanticExportIndexFromProvider(createSemanticWorkspaceExportContext(workspace), input, hooks);
+}
+function buildSemanticExportIndexFromProvider(provider, input, hooks = {}) {
+    const barrels = [...new Set(input.barrelFiles.map((file) => repoPath(provider.root, path.resolve(provider.root, file))))]
+        .sort()
+        .map((file) => buildBarrel(provider, file, hooks));
+    return {
+        version: 1,
+        root: provider.root,
+        barrels,
+        issues: dedupeIssues(barrels.flatMap((barrel) => barrel.issues))
+    };
+}
+function buildSemanticModuleExportSurface(provider, file) {
+    const absoluteFile = path.resolve(provider.root, file);
+    const displayFile = repoPath(provider.root, absoluteFile);
+    const projects = [...provider.projectsForFile(absoluteFile)];
+    if (projects.length === 0) {
+        return {
+            status: "unresolved",
+            file: displayFile,
+            owners: [],
+            bindings: [],
+            issues: [{ code: "moduleNotOwned", file: displayFile }]
+        };
+    }
+    return aggregateProjectSurfaces(provider, absoluteFile, projects, "target", true);
+}
+function resolveSemanticExportEdgeSelector(barrel, selector, modes = ["runtime-star", "type-star"]) {
+    const candidates = barrel.edges.filter((edge) => modes.includes(edge.mode));
+    const exact = candidates.filter((edge) => edge.specifier === selector);
+    if (exact.length === 1) {
+        return { status: "resolved", match: "exact", edge: exact[0] };
+    }
+    if (exact.length > 1) {
+        return { status: "ambiguous", selector, candidates: exact };
+    }
+    const normalized = normalizeExportEdgeSelector(selector);
+    const matches = candidates.filter((edge) => edge.normalizedSpecifier === normalized);
+    if (matches.length === 1) {
+        return { status: "resolved", match: "normalized", edge: matches[0] };
+    }
+    if (matches.length > 1) {
+        return { status: "ambiguous", selector, candidates: matches };
+    }
+    return { status: "notFound", selector };
+}
+function normalizeExportEdgeSelector(value) {
+    return value.replace(/\.(?:mjs|cjs|jsx|js)$/i, "");
+}
+function buildBarrel(provider, file, hooks) {
+    const absoluteFile = path.resolve(provider.root, file);
+    const owners = [...provider.projectsForFile(absoluteFile)];
+    const ownerNames = owners.map((project) => project.id).sort();
+    if (owners.length === 0) {
+        const issue = { code: "barrelNotOwned", file };
+        return withHookEvidence(provider.root, {
+            file,
+            owners: [],
+            bindings: [],
+            edges: [],
+            collisions: [],
+            diagnostics: [],
+            issues: [issue]
+        }, hooks);
+    }
+    const source = owners[0].getSourceFile(absoluteFile);
+    if (!source) {
+        const issue = { code: "barrelMissingFromProgram", file, projects: ownerNames };
+        return withHookEvidence(provider.root, {
+            file,
+            owners: ownerNames,
+            bindings: [],
+            edges: [],
+            collisions: [],
+            diagnostics: [],
+            issues: [issue]
+        }, hooks);
+    }
+    const barrelSurface = aggregateProjectSurfaces(provider, absoluteFile, owners, "barrel", true);
+    const explicitNames = collectExplicitExportNames(source);
+    for (const binding of barrelSurface.bindings) {
+        if (binding.symbol.declarationFile === file) {
+            explicitNames.add(binding.publicName);
+        }
+    }
+    const rawEdges = collectRawExportEdges(source);
+    const edges = rawEdges.map((edge, index) => buildEdge(provider, file, absoluteFile, owners, edge, index));
+    for (const barrelBinding of barrelSurface.bindings) {
+        const providers = edges.flatMap((edge) => edge.bindings).filter((binding) => binding.publicName === barrelBinding.publicName && binding.symbol.key === barrelBinding.symbol.key);
+        if (providers.length > 0) {
+            barrelBinding.exposure = providers.some((binding) => binding.exposure === "runtime") ? "runtime" : "typeOnly";
+        }
+    }
+    const starProviders = new Map();
+    for (const edge of edges.filter((candidate) => candidate.mode === "runtime-star" || candidate.mode === "type-star")) {
+        for (const binding of edge.bindings) {
+            const items = starProviders.get(binding.publicName) ?? [];
+            items.push({ edge, binding });
+            starProviders.set(binding.publicName, items);
+        }
+    }
+    const collisions = new Set();
+    for (const [name, providers] of starProviders) {
+        const identities = new Set(providers.map((item) => item.binding.symbol.key));
+        const explicit = explicitNames.has(name);
+        if (identities.size > 1 && !explicit) {
+            collisions.add(name);
+        }
+        const barrelBinding = barrelSurface.bindings.find((binding) => binding.publicName === name);
+        for (const providerItem of providers) {
+            const sameIdentity = barrelBinding?.symbol.key === providerItem.binding.symbol.key;
+            providerItem.binding.collision = collisions.has(name);
+            providerItem.binding.shadowed = explicit || Boolean(barrelBinding && !sameIdentity);
+            providerItem.binding.exposed = Boolean(sameIdentity && !explicit && !providerItem.binding.collision);
+        }
+    }
+    const diagnostics = owners.flatMap((project) => project.diagnosticsForFile(absoluteFile)
+        .filter((diagnostic) => diagnostic.code === 2308)
+        .map((diagnostic) => ({
+        project: project.id,
+        code: diagnostic.code,
+        message: typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, " ")
+    })))
+        .sort((left, right) => left.project.localeCompare(right.project) || left.message.localeCompare(right.message));
+    for (const diagnostic of diagnostics) {
+        const match = diagnostic.message.match(/named ['"]([^'"]+)['"]/);
+        if (match?.[1]) {
+            collisions.add(match[1]);
+        }
+    }
+    for (const edge of edges) {
+        edge.collisions = edge.bindings.filter((binding) => collisions.has(binding.publicName)).map((binding) => binding.publicName).sort();
+        edge.shadowed = edge.bindings.filter((binding) => binding.shadowed).map((binding) => binding.publicName).sort();
+        for (const name of edge.collisions) {
+            edge.issues.push({ code: "exportCollision", file, specifier: edge.specifier, name });
+        }
+        edge.issues = dedupeIssues(edge.issues);
+    }
+    const issues = dedupeIssues([
+        ...barrelSurface.issues,
+        ...edges.flatMap((edge) => edge.issues),
+        ...[...collisions].map((name) => ({ code: "exportCollision", file, name }))
+    ]);
+    return withHookEvidence(provider.root, {
+        file,
+        owners: ownerNames,
+        bindings: barrelSurface.bindings,
+        edges,
+        collisions: [...collisions].sort(),
+        diagnostics,
+        issues
+    }, hooks);
+}
+function withHookEvidence(root, barrel, hooks) {
+    const context = { root, barrel };
+    return {
+        ...barrel,
+        ...(hooks.collectConsumers ? { consumerEvidence: hooks.collectConsumers(context) } : {}),
+        ...(hooks.collectUsage ? { usageEvidence: hooks.collectUsage(context) } : {})
+    };
+}
+function buildEdge(provider, barrelFile, absoluteBarrel, owners, raw, index) {
+    const ownerProjects = owners.map((project) => project.id).sort();
+    const outcomes = owners.map((project) => ({
+        project,
+        projectName: project.id,
+        resolved: project.resolveModule(absoluteBarrel, raw.specifier)
+    }));
+    const distinct = new Set(outcomes.map((outcome) => outcome.resolved ? (0, semantic_workspace_1.canonicalPathIdentity)(outcome.resolved) : null));
+    const base = {
+        id: `${barrelFile}:${raw.start}:${index}`,
+        barrelFile,
+        start: raw.start,
+        end: raw.end,
+        specifier: raw.specifier,
+        normalizedSpecifier: normalizeExportEdgeSelector(raw.specifier),
+        mode: raw.mode,
+        ownerProjects
+    };
+    if (distinct.size > 1) {
+        const issue = {
+            code: "moduleResolutionAmbiguous",
+            file: barrelFile,
+            specifier: raw.specifier,
+            projects: ownerProjects,
+            outcomes: outcomes.map((outcome) => ({
+                project: outcome.projectName,
+                result: outcome.resolved ? repoPath(provider.root, outcome.resolved) : null
+            })).sort((left, right) => left.project.localeCompare(right.project))
+        };
+        return { ...base, resolution: "ambiguous", bindings: [], collisions: [], shadowed: [], issues: [issue] };
+    }
+    const resolved = outcomes[0]?.resolved ?? null;
+    if (!resolved) {
+        const issue = {
+            code: "moduleResolutionFailed",
+            file: barrelFile,
+            specifier: raw.specifier,
+            projects: ownerProjects
+        };
+        return { ...base, resolution: "unresolved", bindings: [], collisions: [], shadowed: [], issues: [issue] };
+    }
+    const projectSurfaces = outcomes.map((outcome) => collectProjectSurface(provider, outcome.project, resolved, raw.mode, raw.named, false));
+    const aggregate = aggregateKnownProjectSurfaces(repoPath(provider.root, resolved), projectSurfaces, "target");
+    return {
+        ...base,
+        resolution: aggregate.status === "resolved" ? "resolved" : "ambiguous",
+        resolvedFile: repoPath(provider.root, resolved),
+        bindings: aggregate.bindings,
+        collisions: [],
+        shadowed: [],
+        issues: aggregate.issues.map((issue) => ({ ...issue, file: barrelFile, specifier: raw.specifier }))
+    };
+}
+function aggregateProjectSurfaces(provider, absoluteFile, projects, kind, includeDefault) {
+    const file = repoPath(provider.root, absoluteFile);
+    const surfaces = projects.map((project) => collectProjectSurface(provider, project, absoluteFile, "runtime-star", [], includeDefault));
+    return aggregateKnownProjectSurfaces(file, surfaces, kind);
+}
+function aggregateKnownProjectSurfaces(file, surfaces, kind) {
+    const owners = surfaces.map((surface) => surface.project).sort();
+    const missing = surfaces.filter((surface) => !surface.found);
+    const signatures = new Set(surfaces.map((surface) => surfaceSignature(surface.bindings)));
+    if (missing.length === surfaces.length) {
+        return {
+            status: "unresolved",
+            file,
+            owners,
+            bindings: [],
+            issues: [{ code: kind === "barrel" ? "barrelMissingFromProgram" : "targetMissingFromProgram", file, projects: owners }]
+        };
+    }
+    if (missing.length > 0) {
+        return {
+            status: "ambiguous",
+            file,
+            owners,
+            bindings: [],
+            issues: [{ code: kind === "barrel" ? "barrelSurfaceAmbiguous" : "targetSurfaceAmbiguous", file, projects: owners }]
+        };
+    }
+    if (signatures.size > 1) {
+        return {
+            status: "ambiguous",
+            file,
+            owners,
+            bindings: [],
+            issues: [{ code: kind === "barrel" ? "barrelSurfaceAmbiguous" : "targetSurfaceAmbiguous", file, projects: owners }]
+        };
+    }
+    return {
+        status: "resolved",
+        file,
+        owners,
+        bindings: cloneBindings(surfaces[0]?.bindings ?? []),
+        issues: []
+    };
+}
+function collectProjectSurface(provider, project, absoluteFile, mode, named, includeDefault) {
+    const projectName = project.id;
+    const source = project.getSourceFile(absoluteFile);
+    const moduleSymbol = source ? project.checker.getSymbolAtLocation(source) : undefined;
+    if (!source || !moduleSymbol) {
+        return { project: projectName, found: false, bindings: [] };
+    }
+    const requested = named.length > 0 ? new Map(named.map((item) => [item.targetPublicName, item])) : null;
+    const bindings = project.checker.getExportsOfModule(moduleSymbol).flatMap((exportSymbol) => {
+        const publicName = exportSymbol.getName();
+        if (publicName === "default" && !includeDefault && !requested?.has("default")) {
+            return [];
+        }
+        const request = requested?.get(publicName);
+        if (requested && !request) {
+            return [];
+        }
+        const target = resolveAlias(project.checker, exportSymbol);
+        const identity = project.symbolIdentity(target);
+        if (!identity) {
+            return [];
+        }
+        const value = (target.flags & typescript_1.default.SymbolFlags.Value) !== 0;
+        const type = (target.flags & typescript_1.default.SymbolFlags.Type) !== 0;
+        const forcedTypeOnly = mode === "type-star" || mode === "named-type" || request?.typeOnly === true;
+        return [{
+                publicName: request?.publicName ?? publicName,
+                targetName: target.getName(),
+                symbol: identity,
+                facets: { value, type },
+                exposure: forcedTypeOnly || !value ? "typeOnly" : "runtime",
+                isDefault: publicName === "default" || target.getName() === "default",
+                declarationFiles: [...new Set((target.declarations ?? [])
+                        .map((declaration) => repoPath(provider.root, declaration.getSourceFile().fileName)))].sort(),
+                exposed: true,
+                shadowed: false,
+                collision: false
+            }];
+    }).sort(compareBindings);
+    return { project: projectName, found: true, bindings };
+}
+function collectRawExportEdges(source) {
+    const edges = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isExportDeclaration(statement) || !statement.moduleSpecifier || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)) {
+            continue;
+        }
+        const named = statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause)
+            ? statement.exportClause.elements.map((element) => ({
+                publicName: element.name.text,
+                targetPublicName: (element.propertyName ?? element.name).text,
+                typeOnly: statement.isTypeOnly || element.isTypeOnly
+            }))
+            : [];
+        edges.push({
+            start: statement.getStart(source),
+            end: statement.end,
+            specifier: statement.moduleSpecifier.text,
+            mode: readEdgeMode(statement),
+            named
+        });
+    }
+    return edges;
+}
+function readEdgeMode(statement) {
+    if (statement.exportClause && typescript_1.default.isNamespaceExport(statement.exportClause)) {
+        return "namespace";
+    }
+    if (statement.exportClause && typescript_1.default.isNamedExports(statement.exportClause)) {
+        return statement.isTypeOnly ? "named-type" : "named-runtime";
+    }
+    return statement.isTypeOnly ? "type-star" : "runtime-star";
+}
+function collectExplicitExportNames(source) {
+    const names = new Set();
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isExportDeclaration(statement) || !statement.exportClause) {
+            continue;
+        }
+        if (typescript_1.default.isNamespaceExport(statement.exportClause)) {
+            names.add(statement.exportClause.name.text);
+            continue;
+        }
+        for (const element of statement.exportClause.elements) {
+            names.add(element.name.text);
+        }
+    }
+    return names;
+}
+function resolveAlias(checker, symbol) {
+    if ((symbol.flags & typescript_1.default.SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    try {
+        return checker.getAliasedSymbol(symbol);
+    }
+    catch {
+        return symbol;
+    }
+}
+function surfaceSignature(bindings) {
+    return bindings.map((binding) => [
+        binding.publicName,
+        binding.targetName,
+        binding.symbol.key,
+        binding.facets.value ? "v" : "",
+        binding.facets.type ? "t" : "",
+        binding.exposure,
+        binding.isDefault ? "default" : "named"
+    ].join(":"))
+        .sort()
+        .join("\n");
+}
+function cloneBindings(bindings) {
+    return bindings.map((binding) => ({
+        ...binding,
+        facets: { ...binding.facets },
+        declarationFiles: [...binding.declarationFiles]
+    }));
+}
+function compareBindings(left, right) {
+    return left.publicName.localeCompare(right.publicName) || left.symbol.key.localeCompare(right.symbol.key);
+}
+function repoPath(root, file) {
+    const relative = path.relative(root, path.resolve(file));
+    return relative && !relative.startsWith("..") && !path.isAbsolute(relative)
+        ? relative.replace(/\\/g, "/")
+        : path.resolve(file).replace(/\\/g, "/");
+}
+function dedupeIssues(issues) {
+    const byKey = new Map();
+    for (const issue of issues) {
+        const key = stableStringify(issue);
+        byKey.set(key, issue);
+    }
+    return [...byKey.values()].sort((left, right) => left.file.localeCompare(right.file) || left.code.localeCompare(right.code) ||
+        (left.specifier ?? "").localeCompare(right.specifier ?? "") || (left.name ?? "").localeCompare(right.name ?? ""));
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}