xbintsc 0.3.15 → 0.3.18

package/dist/src/driver/modules.js

@@ -6,649 +6,13 @@
  * Each module's top-level bindings are renamed to a globally unique name and
  * imported names are rewritten to the (renamed) exported binding.
  *
- * This is intentionally simple: it supports named imports/exports, namespace
- * imports, `export default` for declarations, `export ... from` and `export *`.
- * Namespace names are live bindings only at the granularity of the module's
- * final names, and circular graphs are reported as an error.
- */
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { ModifierKind, SyntaxKind, } from "../ast/nodes.js";
-import { bind, SymbolKind } from "../binder/binder.js";
-import { DiagnosticCode } from "../diagnostics/diagnostic.js";
-import { SourceFile } from "../diagnostics/source.js";
-import { Parser } from "../parser/parser.js";
-/**
- * Source extensions probed for an extension-less specifier. TypeScript suffixes
- * are tried before their JavaScript counterparts so a project that ships both
- * `foo.ts` and a compiled `foo.js` prefers the source it is compiled from.
- */
-const RESOLVE_SUFFIXES = ["", ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-/** File extensions a directory `index` entry may use. */
-const INDEX_SUFFIXES = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-/** Conditions consulted, in order, when reading a package `exports` map. */
-const EXPORT_CONDITIONS = ["import", "module", "default", "node", "require"];
-/** A specifier is a file path (`./x`, `../x`, `/x`) rather than a package. */
-function isRelativeSpecifier(specifier) {
-    return specifier.startsWith(".") || isAbsolute(specifier);
-}
-/**
- * Resolve a path on disk, tolerating TypeScript's `.js` import convention
- * (`import "./foo.js"` pointing at `foo.ts`) and Node's directory/`index`
- * conventions.
- */
-function resolvePath(base) {
-    // A JavaScript specifier may refer to a TypeScript source that will emit it
-    // (`import "./foo.js"` pointing at `foo.ts`). Probe the matching TypeScript
-    // extensions after the literal path: `.js`/`.jsx` -> `.ts`/`.tsx`,
-    // `.mjs` -> `.mts`, `.cjs` -> `.cts`.
-    const candidates = [base];
-    const jsExtension = /\.((?:m|c)?jsx?)$/.exec(base);
-    if (jsExtension) {
-        const stem = base.slice(0, jsExtension.index);
-        switch (jsExtension[1]) {
-            case "jsx":
-                candidates.push(`${stem}.tsx`, `${stem}.ts`);
-                break;
-            case "mjs":
-                candidates.push(`${stem}.mts`);
-                break;
-            case "cjs":
-                candidates.push(`${stem}.cts`);
-                break;
-            default:
-                candidates.push(`${stem}.ts`, `${stem}.tsx`);
-                break;
-        }
-    }
-    for (const candidate of candidates) {
-        if (existsSync(candidate) && statSync(candidate).isFile())
-            return candidate;
-    }
-    for (const suffix of RESOLVE_SUFFIXES) {
-        const candidate = base + suffix;
-        if (existsSync(candidate) && statSync(candidate).isFile())
-            return candidate;
-    }
-    if (existsSync(base) && statSync(base).isDirectory())
-        return resolveDirectory(base);
-    return undefined;
-}
-/** Resolve a directory to its package entry or an `index` file. */
-function resolveDirectory(directory) {
-    const pkg = readPackageJson(directory);
-    if (pkg && typeof pkg.main === "string") {
-        const main = resolvePath(resolve(directory, pkg.main));
-        if (main)
-            return main;
-    }
-    for (const suffix of INDEX_SUFFIXES) {
-        const candidate = join(directory, `index${suffix}`);
-        if (existsSync(candidate) && statSync(candidate).isFile())
-            return candidate;
-    }
-    return undefined;
-}
-function resolveModule(fromDir, specifier) {
-    return resolvePath(resolve(fromDir, specifier));
-}
-function readPackageJson(directory) {
-    const file = join(directory, "package.json");
-    if (!existsSync(file) || !statSync(file).isFile())
-        return undefined;
-    try {
-        const parsed = JSON.parse(readFileSync(file, "utf8"));
-        return parsed && typeof parsed === "object" ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Split `pkg/sub/path` or `@scope/pkg/sub/path` into package name and subpath. */
-function splitPackageSpecifier(specifier) {
-    const parts = specifier.split("/");
-    if (specifier.startsWith("@")) {
-        return { packageName: parts.slice(0, 2).join("/"), subpath: parts.slice(2).join("/") };
-    }
-    return { packageName: parts[0] ?? specifier, subpath: parts.slice(1).join("/") };
-}
-/**
- * Resolve a bare specifier against the `node_modules` directories above
- * `fromDir`, following a package's `exports` map and falling back to
- * `module`/`main`/`index`. Packages that only ship CommonJS resolve here too;
- * their `require` calls are then rejected during code generation.
- */
-function resolveNodePackage(fromDir, specifier) {
-    const { packageName, subpath } = splitPackageSpecifier(specifier);
-    if (!packageName || packageName.startsWith("."))
-        return undefined;
-    let directory = fromDir;
-    for (;;) {
-        const packageDir = join(directory, "node_modules", packageName);
-        if (existsSync(packageDir) && statSync(packageDir).isDirectory()) {
-            const resolved = subpath
-                ? resolvePackageSubpath(packageDir, subpath)
-                : resolvePackageEntry(packageDir);
-            if (resolved)
-                return resolved;
-        }
-        const parent = dirname(directory);
-        if (parent === directory)
-            return undefined;
-        directory = parent;
-    }
-}
-function resolvePackageEntry(packageDir) {
-    const pkg = readPackageJson(packageDir);
-    if (pkg) {
-        const exported = resolveExportTarget(subpathValue(pkg.exports, "."));
-        if (exported) {
-            const resolved = resolvePath(resolve(packageDir, exported));
-            if (resolved)
-                return resolved;
-        }
-        if (typeof pkg.module === "string") {
-            const resolved = resolvePath(resolve(packageDir, pkg.module));
-            if (resolved)
-                return resolved;
-        }
-        if (typeof pkg.main === "string") {
-            const resolved = resolvePath(resolve(packageDir, pkg.main));
-            if (resolved)
-                return resolved;
-        }
-    }
-    return resolveDirectory(packageDir);
-}
-function resolvePackageSubpath(packageDir, subpath) {
-    const pkg = readPackageJson(packageDir);
-    const exported = resolveExportTarget(subpathValue(pkg?.exports, `./${subpath}`));
-    if (exported) {
-        const resolved = resolvePath(resolve(packageDir, exported));
-        if (resolved)
-            return resolved;
-    }
-    return resolvePath(join(packageDir, subpath));
-}
-/** Pick the export target for a subpath (`"."` or `"./sub"`) from an exports map. */
-function subpathValue(exportsField, subpath) {
-    if (exportsField === undefined)
-        return undefined;
-    if (typeof exportsField === "string" || Array.isArray(exportsField)) {
-        return subpath === "." ? exportsField : undefined;
-    }
-    if (!exportsField || typeof exportsField !== "object")
-        return undefined;
-    const record = exportsField;
-    const keys = Object.keys(record);
-    // A map without `.`-prefixed keys is a condition map for the root export.
-    if (!keys.some((key) => key.startsWith("."))) {
-        return subpath === "." ? exportsField : undefined;
-    }
-    if (subpath in record)
-        return record[subpath];
-    // Wildcard patterns such as `"./*": "./dist/*.js"`.
-    for (const key of keys) {
-        const star = key.indexOf("*");
-        if (star === -1)
-            continue;
-        const prefix = key.slice(0, star);
-        const suffix = key.slice(star + 1);
-        if (subpath.startsWith(prefix) && subpath.endsWith(suffix)) {
-            const matched = subpath.slice(prefix.length, subpath.length - suffix.length);
-            return substituteStar(record[key], matched);
-        }
-    }
-    return undefined;
-}
-function substituteStar(target, matched) {
-    if (typeof target === "string")
-        return target.split("*").join(matched);
-    if (Array.isArray(target))
-        return target.map((entry) => substituteStar(entry, matched));
-    if (target && typeof target === "object") {
-        const record = {};
-        for (const [key, value] of Object.entries(target))
-            record[key] = substituteStar(value, matched);
-        return record;
-    }
-    return target;
-}
-/** Pick a runtime string from a (possibly conditional) exports target. */
-function resolveExportTarget(target) {
-    if (typeof target === "string")
-        return target;
-    if (Array.isArray(target)) {
-        for (const entry of target) {
-            const resolved = resolveExportTarget(entry);
-            if (resolved)
-                return resolved;
-        }
-        return undefined;
-    }
-    if (target && typeof target === "object") {
-        const record = target;
-        for (const condition of EXPORT_CONDITIONS) {
-            if (condition in record) {
-                const resolved = resolveExportTarget(record[condition]);
-                if (resolved)
-                    return resolved;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Classify an import specifier. Known platform modules (extension modules and
- * `node:` builtins) are left for code generation; relative paths and
- * `node_modules` packages are resolved to a source file to bundle; a relative
- * path that does not exist is an error.
- */
-function classifyDependency(fromDir, specifier, externalSpecifiers) {
-    if (specifier.startsWith("node:") || externalSpecifiers.has(specifier)) {
-        return { kind: "external" };
-    }
-    const resolved = isRelativeSpecifier(specifier)
-        ? resolveModule(fromDir, specifier)
-        : resolveNodePackage(fromDir, specifier);
-    if (resolved)
-        return { kind: "file", path: resolved };
-    // A bare specifier that is not a file may still be a platform module the
-    // generator knows about (e.g. when the caller passes no extension registry).
-    return isRelativeSpecifier(specifier) ? { kind: "missing" } : { kind: "external" };
-}
-function hasModifier(node, kind) {
-    const modifiers = node.modifiers;
-    return !!modifiers && modifiers.some((modifier) => modifier.modifierKind === kind);
-}
-function declarationName(node) {
-    switch (node.kind) {
-        case SyntaxKind.FunctionDeclaration:
-        case SyntaxKind.ClassDeclaration:
-        case SyntaxKind.EnumDeclaration:
-        case SyntaxKind.InterfaceDeclaration:
-        case SyntaxKind.TypeAliasDeclaration:
-        case SyntaxKind.ModuleDeclaration:
-            return node.name;
-        case SyntaxKind.VariableDeclaration: {
-            const name = node.name;
-            return name.kind === SyntaxKind.Identifier ? name : undefined;
-        }
-        default:
-            return undefined;
-    }
-}
-/** Load, parse and bind the entry module and every module it imports. */
-function loadGraph(entryPath, diagnostics, externalSpecifiers) {
-    const records = new Map();
-    const order = [];
-    const visiting = new Set();
-    let counter = 0;
-    let failed = false;
-    const load = (path) => {
-        const existing = records.get(path);
-        if (existing)
-            return existing;
-        if (visiting.has(path)) {
-            diagnostics.error(DiagnosticCode.CodegenError, `Circular import detected involving '${path}'`);
-            failed = true;
-            return undefined;
-        }
-        if (!existsSync(path)) {
-            diagnostics.error(DiagnosticCode.CodegenError, `Cannot find module '${path}'`);
-            failed = true;
-            return undefined;
-        }
-        visiting.add(path);
-        const text = readFileSync(path, "utf8");
-        const file = new SourceFile(path, text);
-        const parser = new Parser(file, diagnostics);
-        const sourceFile = parser.parseSourceFile();
-        const bindResult = bind(sourceFile);
-        const record = {
-            path,
-            text,
-            sourceFile,
-            bind: bindResult,
-            prefix: `m${counter++}_`,
-            exports: new Map(),
-            originalNames: new Map(),
-            finalNames: new Map(),
-        };
-        records.set(path, record);
-        for (const statement of sourceFile.statements) {
-            const specifier = moduleSpecifierOf(statement);
-            if (!specifier)
-                continue;
-            const dependency = classifyDependency(dirname(path), specifier, externalSpecifiers);
-            if (dependency.kind === "external")
-                continue;
-            if (dependency.kind === "missing") {
-                diagnostics.error(DiagnosticCode.CodegenError, `Cannot resolve module '${specifier}' from '${path}'`, statement, path);
-                failed = true;
-                continue;
-            }
-            load(dependency.path);
-        }
-        visiting.delete(path);
-        order.push(record);
-        return record;
-    };
-    load(entryPath);
-    if (failed)
-        return undefined;
-    return order;
-}
-function moduleSpecifierOf(statement) {
-    if (statement.kind === SyntaxKind.ImportDeclaration) {
-        return statement.moduleSpecifier.value;
-    }
-    if (statement.kind === SyntaxKind.ExportDeclaration) {
-        const specifier = statement.moduleSpecifier;
-        if (specifier)
-            return specifier.value;
-    }
-    return undefined;
-}
-/** Rewrite a symbol's declaration and every reference to `finalName`. */
-function renameSymbol(symbol, finalName) {
-    for (const declaration of symbol.declarations) {
-        const name = declarationName(declaration);
-        if (name)
-            name.text = finalName;
-    }
-    for (const reference of symbol.references)
-        reference.text = finalName;
-}
-/** Rewrite just the references of a symbol (used for imported names). */
-function renameReferences(symbol, finalName) {
-    for (const reference of symbol.references)
-        reference.text = finalName;
-}
-function moduleScope(record) {
-    return record.bind.scopes.get(record.sourceFile);
-}
-function topLevelSymbols(record) {
-    const scope = moduleScope(record);
-    if (!scope)
-        return [];
-    return [...scope.symbols.values()];
-}
-/**
- * Merge every module's statements into a single file. Dependencies come first
- * (post-order over the import graph), the entry module last.
+ * The implementation lives under `bundler/` split by concern:
+ *   resolve.ts  specifier/path/package resolution
+ *   graph.ts    import-graph loading (parse + bind)
+ *   symbols.ts  top-level symbol renaming
+ *   merge.ts    the bundling passes themselves
+ *
+ * This file remains the public entry point for the driver and tests.
  */
-export function bundleModules(entryPath, diagnostics, externalSpecifiers = new Set()) {
-    const records = loadGraph(entryPath, diagnostics, externalSpecifiers);
-    if (!records)
-        return undefined;
-    const byPath = new Map(records.map((record) => [record.path, record]));
-    const dependencyOf = (record, specifier) => {
-        const resolution = classifyDependency(dirname(record.path), specifier, externalSpecifiers);
-        return resolution.kind === "file" ? byPath.get(resolution.path) : undefined;
-    };
-    // Phase 1: record every top-level binding and pick a unique final name.
-    for (const record of records) {
-        for (const symbol of topLevelSymbols(record)) {
-            record.originalNames.set(symbol.id, symbol.name);
-            if (symbol.kind === SymbolKind.Import)
-                continue;
-            record.finalNames.set(symbol.id, record.prefix + symbol.name);
-        }
-    }
-    // Phase 2: collect each module's exported names.
-    for (const record of records) {
-        const scope = moduleScope(record);
-        if (!scope)
-            continue;
-        const symbolByName = scope.symbols;
-        for (const statement of record.sourceFile.statements) {
-            if (statement.kind === SyntaxKind.ExportDeclaration) {
-                const declaration = statement;
-                if (declaration.exportClause && declaration.exportClause.kind === SyntaxKind.NamedExports) {
-                    for (const specifier of declaration.exportClause.elements) {
-                        const localName = specifier.propertyName?.text ?? specifier.name.text;
-                        const exportedName = specifier.name.text;
-                        if (declaration.moduleSpecifier) {
-                            const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
-                            const target = dependency?.exports.get(localName);
-                            if (target)
-                                record.exports.set(exportedName, target);
-                        }
-                        else {
-                            const symbol = symbolByName.get(localName);
-                            if (symbol) {
-                                const finalName = record.finalNames.get(symbol.id) ?? symbol.name;
-                                record.exports.set(exportedName, finalName);
-                            }
-                        }
-                    }
-                }
-                else if (!declaration.exportClause && declaration.moduleSpecifier) {
-                    // `export * from "..."`: copy every re-exported name.
-                    const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
-                    if (dependency)
-                        for (const [name, value] of dependency.exports)
-                            record.exports.set(name, value);
-                }
-                continue;
-            }
-            if (statement.kind === SyntaxKind.ExportAssignment) {
-                record.exports.set("default", `${record.prefix}default`);
-                continue;
-            }
-            if (hasModifier(statement, ModifierKind.Default)) {
-                const name = declarationName(statement) ?? declarationName(statement.declaration ?? statement);
-                if (name) {
-                    const symbol = symbolByName.get(name.text);
-                    if (symbol)
-                        record.exports.set("default", record.finalNames.get(symbol.id) ?? symbol.name);
-                }
-                continue;
-            }
-            if (hasModifier(statement, ModifierKind.Export)) {
-                const names = exportedNames(statement);
-                for (const name of names) {
-                    const symbol = symbolByName.get(name);
-                    if (symbol)
-                        record.exports.set(name, record.finalNames.get(symbol.id) ?? symbol.name);
-                }
-            }
-        }
-    }
-    // Phase 3: rewrite imported names and record re-exports. Namespace imports
-    // are lowered to a synthetic object literal holding every export, built
-    // from the dependency's (already renamed) final names.
-    const namespaceStatements = new Map();
-    for (const record of records) {
-        const scope = moduleScope(record);
-        if (!scope)
-            continue;
-        for (const statement of record.sourceFile.statements) {
-            if (statement.kind !== SyntaxKind.ImportDeclaration)
-                continue;
-            const declaration = statement;
-            const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
-            const clause = declaration.importClause;
-            if (!clause || !dependency)
-                continue;
-            if (clause.name) {
-                const target = dependency.exports.get("default") ?? dependency.exports.get("default");
-                const local = scope.symbols.get(clause.name.text);
-                if (target && local)
-                    renameReferences(local, target);
-            }
-            const bindings = clause.namedBindings;
-            if (bindings && bindings.kind === SyntaxKind.NamedImports) {
-                for (const specifier of bindings.elements) {
-                    const importedName = specifier.propertyName?.text ?? specifier.name.text;
-                    const target = dependency.exports.get(importedName);
-                    const local = scope.symbols.get(specifier.name.text);
-                    if (target && local)
-                        renameReferences(local, target);
-                }
-            }
-            else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
-                const local = scope.symbols.get(bindings.name.text);
-                const finalName = `${record.prefix}${bindings.name.text}`;
-                if (local)
-                    renameReferences(local, finalName);
-                namespaceStatements.set(statement, namespaceImportToStatement(statement, finalName, dependency));
-            }
-        }
-    }
-    // Phase 4: concatenate statements, dropping imports and pure export wrappers.
-    const merged = [];
-    const first = records[records.length - 1];
-    for (const record of records) {
-        for (const statement of record.sourceFile.statements) {
-            if (statement.kind === SyntaxKind.ImportDeclaration) {
-                // External (extension / built-in) imports stay in place for codegen.
-                const declaration = statement;
-                const resolution = classifyDependency(dirname(record.path), declaration.moduleSpecifier.value, externalSpecifiers);
-                if (resolution.kind === "external") {
-                    merged.push(statement);
-                }
-                else {
-                    const synthetic = namespaceStatements.get(statement);
-                    if (synthetic)
-                        merged.push(synthetic);
-                }
-                continue;
-            }
-            if (statement.kind === SyntaxKind.ExportDeclaration) {
-                const declaration = statement;
-                const inner = declaration.declaration;
-                if (inner)
-                    merged.push(inner);
-                continue;
-            }
-            if (statement.kind === SyntaxKind.ExportAssignment) {
-                const assignment = statement;
-                merged.push(exportAssignmentToStatement(record, assignment));
-                continue;
-            }
-            merged.push(statement);
-        }
-    }
-    // Phase 5: rename every top-level binding (declaration + references) to its
-    // unique final name, now that import references have been rewritten.
-    for (const record of records) {
-        for (const symbol of topLevelSymbols(record)) {
-            if (symbol.kind === SymbolKind.Import)
-                continue;
-            const finalName = record.finalNames.get(symbol.id);
-            if (finalName)
-                renameSymbol(symbol, finalName);
-        }
-    }
-    const sourceFile = {
-        kind: SyntaxKind.SourceFile,
-        statements: merged,
-        fileName: first.path,
-        text: records.map((record) => record.text).join("\n"),
-        start: 0,
-        end: 0,
-    };
-    return { sourceFile, text: sourceFile.text, moduleCount: records.length };
-}
-function exportedNames(statement) {
-    const names = [];
-    if (statement.kind === SyntaxKind.VariableStatement) {
-        for (const declaration of statement.declarationList.declarations) {
-            collectBindingIdentifiers(declaration.name, names);
-        }
-    }
-    else {
-        const name = declarationName(statement);
-        if (name)
-            names.push(name.text);
-    }
-    return names;
-}
-function collectBindingIdentifiers(name, out) {
-    if (name.kind === SyntaxKind.Identifier) {
-        out.push(name.text);
-        return;
-    }
-    const elements = name.kind === SyntaxKind.ArrayBindingPattern ? name.elements : name.elements;
-    for (const element of elements) {
-        if (element)
-            collectBindingIdentifiers(element.name, out);
-    }
-}
-/** Lower `import * as ns from "./mod"` to `const m0_ns = { ...exports }`. */
-function namespaceImportToStatement(statement, finalName, dependency) {
-    const properties = [];
-    for (const [exportedName, target] of dependency.exports) {
-        properties.push({
-            kind: SyntaxKind.PropertyAssignment,
-            name: { kind: SyntaxKind.Identifier, text: exportedName, start: statement.start, end: statement.start },
-            initializer: { kind: SyntaxKind.Identifier, text: target, start: statement.start, end: statement.start },
-            start: statement.start,
-            end: statement.start,
-        });
-    }
-    const initializer = {
-        kind: SyntaxKind.ObjectLiteralExpression,
-        properties,
-        start: statement.start,
-        end: statement.end,
-    };
-    const declaration = {
-        kind: SyntaxKind.VariableDeclaration,
-        name: { kind: SyntaxKind.Identifier, text: finalName, start: statement.start, end: statement.start },
-        exclamation: false,
-        initializer,
-        start: statement.start,
-        end: statement.end,
-    };
-    const list = {
-        kind: SyntaxKind.VariableDeclarationList,
-        declarationKind: "const",
-        declarations: [declaration],
-        start: statement.start,
-        end: statement.end,
-    };
-    return {
-        kind: SyntaxKind.VariableStatement,
-        declarationList: list,
-        modifiers: [],
-        start: statement.start,
-        end: statement.end,
-    };
-}
-/** Turn `export default expr` into a synthetic `const` declaration. */
-function exportAssignmentToStatement(record, assignment) {
-    const name = {
-        kind: SyntaxKind.Identifier,
-        text: `${record.prefix}default`,
-        start: assignment.start,
-        end: assignment.start,
-    };
-    record.exports.set("default", name.text);
-    const declaration = {
-        kind: SyntaxKind.VariableDeclaration,
-        name,
-        exclamation: false,
-        initializer: assignment.expression,
-        start: assignment.start,
-        end: assignment.end,
-    };
-    const list = {
-        kind: SyntaxKind.VariableDeclarationList,
-        declarationKind: "const",
-        declarations: [declaration],
-        start: assignment.start,
-        end: assignment.end,
-    };
-    const statement = {
-        kind: SyntaxKind.VariableStatement,
-        declarationList: list,
-        modifiers: [],
-        start: assignment.start,
-        end: assignment.end,
-    };
-    return statement;
-}
+export { bundleModules } from "./bundler/merge.js";
 //# sourceMappingURL=modules.js.map