browser-metro 1.0.5

package/dist/incremental-bundler.js

@@ -0,0 +1,646 @@
+import { Resolver } from "./resolver.js";
+import { DependencyGraph } from "./dependency-graph.js";
+import { ModuleCache } from "./module-cache.js";
+import { emitHmrBundle, HMR_RUNTIME_TEMPLATE } from "./hmr-runtime.js";
+import { buildCombinedSourceMap, countNewlines, inlineSourceMap, shiftSourceMapOrigLines, } from "./source-map.js";
+import { findRequires, rewriteRequires, hashString, buildBundlePreamble } from "./utils.js";
+export class IncrementalBundler {
+    constructor(fs, config) {
+        this.graph = new DependencyGraph();
+        this.cache = new ModuleCache();
+        this.moduleMap = {};
+        this.sourceMapMap = {};
+        this.entryFile = null;
+        this.packageVersions = {};
+        this.transitiveDepsVersions = {};
+        this.fs = fs;
+        this.config = config;
+        const paths = IncrementalBundler.readTsconfigPaths(fs);
+        this.resolver = new Resolver(fs, { ...config.resolver, ...(paths && { paths }) });
+        this.plugins = config.plugins ?? [];
+    }
+    /** Read tsconfig.json "compilerOptions.paths" from the VirtualFS */
+    static readTsconfigPaths(fs) {
+        const raw = fs.read("/tsconfig.json");
+        if (!raw)
+            return null;
+        try {
+            const tsconfig = JSON.parse(raw);
+            const paths = tsconfig?.compilerOptions?.paths;
+            return paths && typeof paths === "object" ? paths : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Run the full pre-transform -> Sucrase -> post-transform pipeline */
+    runTransform(filename, src) {
+        const originalLines = countNewlines(src);
+        // Pre-transform hooks
+        for (const plugin of this.plugins) {
+            if (plugin.transformSource) {
+                const result = plugin.transformSource({ src, filename });
+                if (result)
+                    src = result.src;
+            }
+        }
+        const preTransformAddedLines = countNewlines(src) - originalLines;
+        // Core transform (Sucrase)
+        const transformResult = this.config.transformer.transform({ src, filename });
+        let code = transformResult.code;
+        let sourceMap = transformResult.sourceMap;
+        // Post-transform hooks -- track line additions for source map offset
+        const linesBeforePost = countNewlines(code);
+        for (const plugin of this.plugins) {
+            if (plugin.transformOutput) {
+                const result = plugin.transformOutput({ code, filename });
+                if (result)
+                    code = result.code;
+            }
+        }
+        // Adjust source map for plugin modifications
+        if (sourceMap) {
+            // Post-transform: shift generated lines for prepended output lines
+            const postAddedLines = countNewlines(code) - linesBeforePost;
+            if (postAddedLines > 0) {
+                sourceMap = {
+                    ...sourceMap,
+                    mappings: ";".repeat(postAddedLines) + sourceMap.mappings,
+                };
+            }
+            // Pre-transform: shift origLine back so mappings point to original source
+            if (preTransformAddedLines > 0) {
+                sourceMap = shiftSourceMapOrigLines(sourceMap, -preTransformAddedLines);
+            }
+        }
+        return { code, sourceMap };
+    }
+    /** Build a resolve callback that consults plugins then falls back to default resolution */
+    makeResolveTarget(fromFile) {
+        return (target) => {
+            // Let plugins resolve first
+            for (const plugin of this.plugins) {
+                if (plugin.resolveRequest) {
+                    const result = plugin.resolveRequest({ fromFile }, target);
+                    if (result !== null)
+                        return result;
+                }
+            }
+            // Default resolution: skip npm packages, resolve local paths
+            if (this.resolver.isNpmPackage(target))
+                return null;
+            const resolved = this.resolver.resolvePath(fromFile, target);
+            const actual = this.resolver.resolveFile(resolved);
+            return actual ?? null;
+        };
+    }
+    /** Collect module aliases from all plugins */
+    getModuleAliases() {
+        const aliases = {};
+        for (const plugin of this.plugins) {
+            if (plugin.moduleAliases) {
+                Object.assign(aliases, plugin.moduleAliases());
+            }
+        }
+        return aliases;
+    }
+    /** Collect module shims from all plugins */
+    getShimModules() {
+        const shims = {};
+        for (const plugin of this.plugins) {
+            if (plugin.shimModules) {
+                Object.assign(shims, plugin.shimModules());
+            }
+        }
+        return shims;
+    }
+    /** Scan npm packages in the module map for require calls not yet fetched */
+    findTransitiveNpmDeps(skipNames) {
+        const newDeps = new Set();
+        for (const [name, code] of Object.entries(this.moduleMap)) {
+            if (!this.resolver.isNpmPackage(name))
+                continue;
+            for (const dep of findRequires(code)) {
+                if (this.resolver.isNpmPackage(dep) && !(dep in this.moduleMap) && !skipNames.has(dep)) {
+                    newDeps.add(dep);
+                }
+            }
+        }
+        return newDeps;
+    }
+    /** Transform a single file using the configured transformer */
+    transformFile(filename, src) {
+        return this.runTransform(filename, src).code;
+    }
+    /** Read dependency versions from the project's package.json */
+    getPackageVersions() {
+        const raw = this.fs.read("/package.json");
+        if (!raw)
+            return {};
+        try {
+            const pkg = JSON.parse(raw);
+            return pkg.dependencies || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Resolve an npm specifier to a versioned form.
+     *  Priority: user's package.json > transitive dep versions from manifests > bare name */
+    resolveNpmSpecifier(specifier, versions) {
+        let baseName;
+        if (specifier.startsWith("@")) {
+            const parts = specifier.split("/");
+            baseName = parts[0] + "/" + parts[1];
+        }
+        else {
+            baseName = specifier.split("/")[0];
+        }
+        const version = versions[baseName] || this.transitiveDepsVersions[baseName];
+        if (!version)
+            return specifier;
+        const subpath = specifier.slice(baseName.length);
+        return baseName + "@" + version + subpath;
+    }
+    /** Fetch a pre-bundled npm package from the package server */
+    async fetchPackage(specifier) {
+        const url = this.config.server.packageServerUrl + "/pkg/" + specifier;
+        const res = await fetch(url);
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error("Failed to fetch package '" + specifier + "' (HTTP " + res.status + ")" + (body ? ": " + body.slice(0, 200) : ""));
+        }
+        const code = await res.text();
+        let externals = {};
+        const externalsHeader = res.headers.get("X-Externals");
+        if (externalsHeader) {
+            try {
+                externals = JSON.parse(externalsHeader);
+            }
+            catch { }
+        }
+        return { code, externals };
+    }
+    /**
+     * Process a single local file: transform, rewrite requires, extract deps,
+     * update cache and graph. Returns the list of npm deps found.
+     */
+    processFile(filePath) {
+        // Asset files get a stub module that exports the filename (or a real URL for external assets)
+        if (this.resolver.isAssetFile(filePath)) {
+            if (this.fs.isExternalAsset(filePath) && this.config.assetPublicPath) {
+                const assetUrl = this.config.assetPublicPath + filePath;
+                this.moduleMap[filePath] = "module.exports = { uri: " + JSON.stringify(assetUrl) + " };";
+            }
+            else {
+                this.moduleMap[filePath] = "module.exports = " + JSON.stringify(filePath) + ";";
+            }
+            return { localDeps: [], npmDeps: [] };
+        }
+        const source = this.fs.read(filePath);
+        if (!source) {
+            throw new Error("File not found: " + filePath);
+        }
+        const sourceHash = hashString(source);
+        // Check cache validity
+        if (this.cache.isValid(filePath, sourceHash)) {
+            const cached = this.cache.getModule(filePath);
+            this.moduleMap[filePath] = cached.rewrittenCode;
+            if (cached.sourceMap)
+                this.sourceMapMap[filePath] = cached.sourceMap;
+            return {
+                localDeps: cached.resolvedLocalDeps,
+                npmDeps: cached.npmDeps,
+            };
+        }
+        // Transform
+        const { code: transformed, sourceMap } = this.runTransform(filePath, source);
+        if (sourceMap)
+            this.sourceMapMap[filePath] = sourceMap;
+        // Rewrite requires
+        const rewritten = rewriteRequires(transformed, filePath, this.makeResolveTarget(filePath));
+        // Extract deps from rewritten code (has absolute paths for local deps)
+        const rawDeps = findRequires(transformed);
+        const allDeps = findRequires(rewritten);
+        const localDeps = [];
+        const npmDeps = [];
+        for (const dep of allDeps) {
+            if (this.resolver.isNpmPackage(dep)) {
+                npmDeps.push(dep);
+            }
+            else {
+                localDeps.push(dep);
+            }
+        }
+        // Update cache
+        this.cache.setModule(filePath, {
+            sourceHash,
+            transformedCode: transformed,
+            rewrittenCode: rewritten,
+            rawDeps,
+            resolvedLocalDeps: localDeps,
+            npmDeps,
+            sourceMap,
+        });
+        // Update graph
+        this.graph.setModule(filePath, localDeps, npmDeps);
+        // Update module map
+        this.moduleMap[filePath] = rewritten;
+        return { localDeps, npmDeps };
+    }
+    /**
+     * Walk the dependency tree starting from a file, processing all reachable modules.
+     *
+     * Returns all files that were visited and processed, so callers can include
+     * them in HMR updatedModules. Without this, only the direct dependency would
+     * be sent to the iframe — transitive deps (e.g. hooks/index.ts → hooks/useAuth.ts)
+     * would be missing from the HMR payload, causing "Module not found" at runtime.
+     *
+     * Files that don't exist yet on the VFS are silently skipped. During AI streaming,
+     * a barrel file (e.g. seeds/index.ts) may reference a sibling (e.g. seeds/users.ts)
+     * that hasn't been created yet. Without this guard, processFile() would throw
+     * "File not found" and crash the entire rebuild. The missing file will be picked
+     * up on a subsequent rebuild once it's created.
+     */
+    walkDeps(startFile, npmPackagesNeeded) {
+        const visited = new Set();
+        const queue = [startFile];
+        while (queue.length > 0) {
+            const filePath = queue.shift();
+            if (visited.has(filePath))
+                continue;
+            if (!this.fs.exists(filePath))
+                continue;
+            visited.add(filePath);
+            const { localDeps, npmDeps } = this.processFile(filePath);
+            for (const dep of npmDeps) {
+                npmPackagesNeeded.add(dep);
+            }
+            for (const dep of localDeps) {
+                if (!visited.has(dep)) {
+                    queue.push(dep);
+                }
+            }
+        }
+        return [...visited];
+    }
+    /** Fetch all npm packages that aren't already cached */
+    async fetchNpmPackages(npmPackagesNeeded) {
+        const versions = this.packageVersions;
+        const toFetch = [];
+        for (const name of npmPackagesNeeded) {
+            const specifier = this.resolveNpmSpecifier(name, versions);
+            if (!this.cache.hasNpmPackage(specifier)) {
+                toFetch.push({ name, specifier });
+            }
+            else {
+                // Use cached version
+                this.moduleMap[name] = this.cache.getNpmPackage(specifier);
+            }
+        }
+        if (toFetch.length > 0) {
+            const results = await Promise.all(toFetch.map(({ specifier }) => this.fetchPackage(specifier)));
+            for (let i = 0; i < toFetch.length; i++) {
+                const { name, specifier } = toFetch[i];
+                const { code, externals } = results[i];
+                this.cache.setNpmPackage(specifier, code);
+                this.moduleMap[name] = code;
+                // Merge externals into transitive versions (don't overwrite existing entries)
+                for (const [dep, ver] of Object.entries(externals)) {
+                    if (!this.transitiveDepsVersions[dep]) {
+                        this.transitiveDepsVersions[dep] = ver;
+                    }
+                }
+            }
+        }
+    }
+    /** Emit the bundle using HMR runtime or standard IIFE */
+    emitBundle() {
+        const hmrEnabled = this.config.hmr?.enabled ?? false;
+        const reactRefresh = this.config.hmr?.reactRefresh ?? false;
+        let bundle;
+        let headerStr;
+        if (hmrEnabled) {
+            bundle = emitHmrBundle(this.moduleMap, this.entryFile, this.graph.getReverseDepsMap(), reactRefresh, this.config.env, this.config.routerShim);
+            headerStr =
+                buildBundlePreamble(this.config.env, this.config.routerShim) +
+                    HMR_RUNTIME_TEMPLATE +
+                    "({\n";
+        }
+        else {
+            // Fallback to standard IIFE (same as Bundler.emitBundle)
+            const preamble = buildBundlePreamble(this.config.env, this.config.routerShim);
+            const runtimeStr = "(function(modules) {\n" +
+                "  var cache = {};\n" +
+                "  function require(id) {\n" +
+                "    if (cache[id]) return cache[id].exports;\n" +
+                "    if (!modules[id]) throw new Error('Module not found: ' + id);\n" +
+                "    var module = cache[id] = { exports: {} };\n" +
+                "    modules[id].call(module.exports, module, module.exports, require);\n" +
+                "    return module.exports;\n" +
+                "  }\n" +
+                "  require(" +
+                JSON.stringify(this.entryFile) +
+                ");\n" +
+                "})({\n";
+            headerStr = preamble + runtimeStr;
+            const moduleEntries = Object.keys(this.moduleMap)
+                .map((id) => {
+                return (JSON.stringify(id) +
+                    ": function(module, exports, require) {\n" +
+                    this.moduleMap[id] +
+                    "\n}");
+            })
+                .join(",\n\n");
+            bundle = headerStr + moduleEntries + "\n});\n";
+        }
+        // Build and append combined source map
+        const inputs = this.buildSourceMapInputs(countNewlines(headerStr));
+        if (inputs.length > 0) {
+            bundle += inlineSourceMap(buildCombinedSourceMap(inputs)) + "\n";
+        }
+        return bundle;
+    }
+    /** Compute source map inputs with correct line offsets for each module */
+    buildSourceMapInputs(headerLineCount) {
+        let lineOffset = headerLineCount;
+        const inputs = [];
+        const ids = Object.keys(this.moduleMap);
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            if (i > 0)
+                lineOffset += 2; // ",\n\n"
+            lineOffset += 1; // wrapper function line
+            if (this.sourceMapMap[id]) {
+                const sourceContent = this.fs.read(id);
+                if (sourceContent) {
+                    inputs.push({
+                        sourceFile: id,
+                        sourceContent,
+                        map: this.sourceMapMap[id],
+                        generatedLineOffset: lineOffset,
+                    });
+                }
+            }
+            lineOffset += countNewlines(this.moduleMap[id]);
+            lineOffset += 1; // "\n}"
+        }
+        return inputs;
+    }
+    /** Initial full build */
+    async build(entryFile) {
+        const startTime = performance.now();
+        this.entryFile = entryFile;
+        this.moduleMap = {};
+        this.sourceMapMap = {};
+        this.packageVersions = this.getPackageVersions();
+        const npmPackagesNeeded = new Set();
+        this.walkDeps(entryFile, npmPackagesNeeded);
+        // Process module aliases: swap sources for targets in the fetch list
+        const aliases = this.getModuleAliases();
+        for (const [from, to] of Object.entries(aliases)) {
+            npmPackagesNeeded.delete(from);
+            npmPackagesNeeded.add(to);
+        }
+        // Collect shims: these replace npm packages with inline code
+        const shims = this.getShimModules();
+        for (const name of Object.keys(shims)) {
+            npmPackagesNeeded.delete(name);
+        }
+        // React Refresh runtime must be in the module map for the HMR runtime to require() it
+        if (this.config.hmr?.reactRefresh) {
+            npmPackagesNeeded.add("react-refresh/runtime");
+        }
+        await this.fetchNpmPackages(npmPackagesNeeded);
+        // Resolve transitive npm deps (subpath requires like react-dom/client)
+        const skipNames = new Set([...Object.keys(aliases), ...Object.keys(shims)]);
+        let newDeps = this.findTransitiveNpmDeps(skipNames);
+        while (newDeps.size > 0) {
+            await this.fetchNpmPackages(newDeps);
+            newDeps = this.findTransitiveNpmDeps(skipNames);
+        }
+        // Inject alias shim modules
+        for (const [from, to] of Object.entries(aliases)) {
+            this.moduleMap[from] = 'module.exports = require("' + to + '");';
+        }
+        // Inject inline shim modules
+        for (const [name, code] of Object.entries(shims)) {
+            this.moduleMap[name] = code;
+        }
+        const bundle = this.emitBundle();
+        const buildTime = performance.now() - startTime;
+        return {
+            bundle,
+            hmrUpdate: null,
+            type: "full",
+            rebuiltModules: Object.keys(this.moduleMap).filter((id) => !this.resolver.isNpmPackage(id)),
+            removedModules: [],
+            buildTime,
+        };
+    }
+    /** Incremental rebuild based on file changes */
+    async rebuild(changes) {
+        const startTime = performance.now();
+        if (!this.entryFile) {
+            throw new Error("Must call build() before rebuild()");
+        }
+        // Check if we need a full rebuild
+        const packageJsonChange = changes.find((c) => c.path === "/package.json");
+        if (packageJsonChange && packageJsonChange.type !== "delete") {
+            const newVersions = this.getPackageVersions();
+            const oldVersions = this.packageVersions;
+            const depsChanged = JSON.stringify(newVersions) !== JSON.stringify(oldVersions);
+            if (depsChanged) {
+                // Full rebuild: invalidate all npm caches and transitive version map
+                this.cache.invalidateNpmPackages();
+                this.transitiveDepsVersions = {};
+                this.packageVersions = newVersions;
+                return this.build(this.entryFile);
+            }
+        }
+        // Check if entry file was deleted
+        const entryDeleted = changes.some((c) => c.path === this.entryFile && c.type === "delete");
+        if (entryDeleted) {
+            return this.build(this.entryFile);
+        }
+        // Incremental rebuild
+        const rebuiltModules = [];
+        const removedModules = [];
+        const filesToReprocess = new Set();
+        const npmPackagesNeeded = new Set();
+        // Collect all npm packages already in the module map
+        for (const id of Object.keys(this.moduleMap)) {
+            if (this.resolver.isNpmPackage(id)) {
+                npmPackagesNeeded.add(id);
+            }
+        }
+        // Snapshot which npm packages exist before this rebuild so we can detect
+        // newly-introduced ones. New packages must be injected into HMR updatedModules
+        // so the running iframe's `modules` closure has them before re-execution —
+        // otherwise require('new-package') throws "Module not found".
+        const preRebuildNpmIds = new Set(npmPackagesNeeded);
+        // Phase 1: Classify changes and collect files to reprocess
+        for (const change of changes) {
+            if (change.path === "/package.json")
+                continue;
+            if (change.type === "delete") {
+                // Remove from graph, cache, and module map
+                const dependents = this.graph.getDependents(change.path);
+                this.graph.removeModule(change.path);
+                this.cache.invalidateModule(change.path);
+                delete this.moduleMap[change.path];
+                delete this.sourceMapMap[change.path];
+                removedModules.push(change.path);
+                // Dependents need reprocessing (their require target is gone)
+                for (const dep of dependents) {
+                    filesToReprocess.add(dep);
+                }
+            }
+            else {
+                // Create or update: only reprocess the changed file itself.
+                // Dependents don't need re-transformation -- the HMR runtime
+                // handles re-execution by walking accept boundaries.
+                this.cache.invalidateModule(change.path);
+                filesToReprocess.add(change.path);
+            }
+        }
+        // Phase 2: Reprocess each affected file
+        for (const filePath of filesToReprocess) {
+            if (!this.fs.exists(filePath))
+                continue;
+            const { localDeps, npmDeps } = this.processFile(filePath);
+            rebuiltModules.push(filePath);
+            for (const dep of npmDeps) {
+                npmPackagesNeeded.add(dep);
+            }
+            // Walk any new local deps that aren't yet in the graph.
+            // Include ALL transitive deps in rebuiltModules so they appear in the
+            // HMR updatedModules payload. Previously only the direct dep was pushed,
+            // so transitive deps (e.g. barrel re-exports) were missing from HMR.
+            for (const dep of localDeps) {
+                if (!this.graph.hasModule(dep) && this.fs.exists(dep)) {
+                    const walked = this.walkDeps(dep, npmPackagesNeeded);
+                    for (const w of walked) {
+                        rebuiltModules.push(w);
+                    }
+                }
+            }
+        }
+        // Process module aliases for incremental rebuilds
+        const aliases = this.getModuleAliases();
+        for (const [from, to] of Object.entries(aliases)) {
+            npmPackagesNeeded.delete(from);
+            npmPackagesNeeded.add(to);
+        }
+        // Collect shims
+        const shims = this.getShimModules();
+        for (const name of Object.keys(shims)) {
+            npmPackagesNeeded.delete(name);
+        }
+        // Ensure react-refresh/runtime stays in the module map
+        if (this.config.hmr?.reactRefresh) {
+            npmPackagesNeeded.add("react-refresh/runtime");
+        }
+        // Phase 3: Fetch any new npm packages + transitive deps
+        await this.fetchNpmPackages(npmPackagesNeeded);
+        const skipNames = new Set([...Object.keys(aliases), ...Object.keys(shims)]);
+        let newDeps = this.findTransitiveNpmDeps(skipNames);
+        while (newDeps.size > 0) {
+            await this.fetchNpmPackages(newDeps);
+            newDeps = this.findTransitiveNpmDeps(skipNames);
+        }
+        // Inject alias shim modules
+        for (const [from, to] of Object.entries(aliases)) {
+            this.moduleMap[from] = 'module.exports = require("' + to + '");';
+        }
+        // Inject inline shim modules
+        for (const [name, code] of Object.entries(shims)) {
+            this.moduleMap[name] = code;
+        }
+        // Phase 4: Orphan cleanup
+        const orphans = this.graph.findOrphans(this.entryFile);
+        for (const orphan of orphans) {
+            this.graph.removeModule(orphan);
+            this.cache.invalidateModule(orphan);
+            delete this.moduleMap[orphan];
+            delete this.sourceMapMap[orphan];
+            removedModules.push(orphan);
+        }
+        // Phase 5: Emit result
+        const bundle = this.emitBundle();
+        const buildTime = performance.now() - startTime;
+        // Build HMR update
+        let hmrUpdate = null;
+        const hmrEnabled = this.config.hmr?.enabled ?? false;
+        if (hmrEnabled && rebuiltModules.length > 0) {
+            const entryChanged = rebuiltModules.includes(this.entryFile);
+            if (entryChanged) {
+                hmrUpdate = {
+                    updatedModules: {},
+                    removedModules,
+                    requiresReload: true,
+                    reloadReason: "Entry file changed",
+                };
+            }
+            else {
+                const updatedModules = {};
+                // new Function('module','exports','require', code) wraps with:
+                //   function anonymous(module,exports,require\n) {\n<code>\n}
+                // That's 2 extra lines before code starts
+                const NEW_FUNCTION_LINES = 2;
+                for (const id of rebuiltModules) {
+                    if (this.moduleMap[id] !== undefined) {
+                        let code = this.moduleMap[id];
+                        // Append per-module inline source map for HMR
+                        const sm = this.sourceMapMap[id];
+                        if (sm) {
+                            const sourceContent = this.fs.read(id);
+                            if (sourceContent) {
+                                code +=
+                                    "\n" +
+                                        inlineSourceMap({
+                                            version: 3,
+                                            sources: [id],
+                                            sourcesContent: [sourceContent],
+                                            names: sm.names || [],
+                                            mappings: ";".repeat(NEW_FUNCTION_LINES) + sm.mappings,
+                                        });
+                            }
+                        }
+                        code += "\n//# sourceURL=" + id;
+                        updatedModules[id] = code;
+                    }
+                }
+                // Inject npm packages that are new since the last bundle the iframe loaded.
+                // The HMR runtime's Phase 3 (module factory replacement) will add them to
+                // `modules` before re-executing changed files, preventing "Module not found"
+                // when a newly-generated component imports a package for the first time.
+                for (const [id, code] of Object.entries(this.moduleMap)) {
+                    if (this.resolver.isNpmPackage(id) && !preRebuildNpmIds.has(id)) {
+                        updatedModules[id] = code;
+                    }
+                }
+                hmrUpdate = {
+                    updatedModules,
+                    removedModules,
+                    requiresReload: false,
+                    reverseDepsMap: this.graph.getReverseDepsMap(),
+                };
+            }
+        }
+        return {
+            bundle,
+            hmrUpdate,
+            type: "incremental",
+            rebuiltModules,
+            removedModules,
+            buildTime,
+        };
+    }
+    /** Update the virtual filesystem */
+    updateFS(fs) {
+        this.fs = fs;
+        const paths = IncrementalBundler.readTsconfigPaths(fs);
+        this.resolver = new Resolver(fs, { ...this.config.resolver, ...(paths && { paths }) });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { Bundler } from "./bundler.js";
+export { IncrementalBundler } from "./incremental-bundler.js";
+export { VirtualFS } from "./fs.js";
+export { Resolver } from "./resolver.js";
+export { DependencyGraph } from "./dependency-graph.js";
+export { ModuleCache } from "./module-cache.js";
+export { typescriptTransformer } from "./transforms/typescript.js";
+export { reactRefreshTransformer, createReactRefreshTransformer, } from "./transforms/react-refresh.js";
+export type { RawSourceMap } from "./source-map.js";
+export { createDataBxPathPlugin } from "./plugins/data-bx-path.js";
+export type { FileEntry, FileMap, ModuleMap, TransformResult, TransformParams, Transformer, ResolverConfig, BundlerPlugin, BundlerConfig, FileChange, ContentChange, HmrUpdate, IncrementalBuildResult, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Bundler } from "./bundler.js";
+export { IncrementalBundler } from "./incremental-bundler.js";
+export { VirtualFS } from "./fs.js";
+export { Resolver } from "./resolver.js";
+export { DependencyGraph } from "./dependency-graph.js";
+export { ModuleCache } from "./module-cache.js";
+export { typescriptTransformer } from "./transforms/typescript.js";
+export { reactRefreshTransformer, createReactRefreshTransformer, } from "./transforms/react-refresh.js";
+export { createDataBxPathPlugin } from "./plugins/data-bx-path.js";

package/dist/module-cache.d.ts

@@ -0,0 +1,22 @@
+import type { RawSourceMap } from "./source-map.js";
+export interface CachedModule {
+    sourceHash: string;
+    transformedCode: string;
+    rewrittenCode: string;
+    rawDeps: string[];
+    resolvedLocalDeps: string[];
+    npmDeps: string[];
+    sourceMap?: RawSourceMap;
+}
+export declare class ModuleCache {
+    private modules;
+    private npmPackages;
+    getModule(id: string): CachedModule | undefined;
+    setModule(id: string, data: CachedModule): void;
+    invalidateModule(id: string): void;
+    isValid(id: string, currentSourceHash: string): boolean;
+    getNpmPackage(specifier: string): string | undefined;
+    setNpmPackage(specifier: string, code: string): void;
+    hasNpmPackage(specifier: string): boolean;
+    invalidateNpmPackages(): void;
+}