browser-metro 1.0.5

package/dist/hmr-runtime.js

@@ -0,0 +1,231 @@
+import { buildBundlePreamble } from "./utils.js";
+/**
+ * HMR-capable bundle runtime template.
+ *
+ * Called at emit time as an IIFE with:
+ *   modules       - the module map object
+ *   reverseDeps   - JSON reverse dependency map
+ *   entryId       - entry file path string
+ *   reactRefreshEnabled - boolean
+ */
+export const HMR_RUNTIME_TEMPLATE = `(function(modules, reverseDeps, entryId, reactRefreshEnabled) {
+  var cache = {};
+  var hotState = {};
+
+  function initHot(id) {
+    if (hotState[id]) return hotState[id];
+    var state = {
+      acceptCallbacks: [],
+      disposeCallbacks: [],
+      data: {},
+      declined: false,
+      accepted: false
+    };
+    hotState[id] = state;
+    return state;
+  }
+
+  function createHotAPI(id) {
+    var state = initHot(id);
+    return {
+      accept: function(cb) {
+        state.accepted = true;
+        if (cb) state.acceptCallbacks.push(cb);
+      },
+      dispose: function(cb) {
+        if (cb) state.disposeCallbacks.push(cb);
+      },
+      decline: function() {
+        state.declined = true;
+      },
+      get data() {
+        return state.data;
+      }
+    };
+  }
+
+  function require(id) {
+    if (cache[id]) return cache[id].exports;
+    if (!modules[id]) throw new Error('Module not found: ' + id);
+    var module = cache[id] = { exports: {}, hot: createHotAPI(id) };
+    modules[id].call(module.exports, module, module.exports, require);
+    return module.exports;
+  }
+
+  // Walk reverse deps to find nearest module.hot.accept() boundary
+  function findAcceptBoundary(changedId) {
+    var visited = {};
+    var queue = [changedId];
+    var boundaries = [];
+
+    while (queue.length > 0) {
+      var current = queue.shift();
+      if (visited[current]) continue;
+      visited[current] = true;
+
+      var state = hotState[current];
+      if (state && state.declined) {
+        return null;
+      }
+      if (state && state.accepted) {
+        boundaries.push(current);
+        continue;
+      }
+      // Walk upward through reverse deps
+      var parents = reverseDeps[current];
+      if (!parents || parents.length === 0) {
+        return null;
+      }
+      for (var i = 0; i < parents.length; i++) {
+        queue.push(parents[i]);
+      }
+    }
+
+    return boundaries.length > 0 ? boundaries : null;
+  }
+
+  function applyUpdate(updatedModules, removedModules, newReverseDeps) {
+    // Merge updated reverse deps so boundary walk sees new modules
+    if (newReverseDeps) {
+      for (var key in newReverseDeps) {
+        reverseDeps[key] = newReverseDeps[key];
+      }
+    }
+
+    // Phase 1: Check boundaries FIRST, before any state mutation.
+    // The dispose phase used to reset accepted=false here, which wiped
+    // out the accept registrations before the boundary walk could see them.
+    var needsReload = false;
+    var modulesToReExecute = new Set();
+
+    for (var uid in updatedModules) {
+      var boundaries = findAcceptBoundary(uid);
+      if (!boundaries) {
+        needsReload = true;
+        break;
+      }
+      for (var b = 0; b < boundaries.length; b++) {
+        modulesToReExecute.add(boundaries[b]);
+      }
+      modulesToReExecute.add(uid);
+    }
+
+    if (needsReload) {
+      console.warn('[HMR] No accept boundary found, requesting full reload');
+      window.parent.postMessage({ type: 'hmr-full-reload' }, '*');
+      return;
+    }
+
+    // Phase 2: Run dispose callbacks and reset state for modules about to be re-executed
+    modulesToReExecute.forEach(function(id) {
+      var state = hotState[id];
+      if (state) {
+        var newData = {};
+        for (var i = 0; i < state.disposeCallbacks.length; i++) {
+          state.disposeCallbacks[i](newData);
+        }
+        state.data = newData;
+        state.disposeCallbacks = [];
+        state.acceptCallbacks = [];
+        state.accepted = false;
+      }
+    });
+
+    // Phase 3: Update module factories
+    for (var mid in updatedModules) {
+      modules[mid] = new Function('module', 'exports', 'require', updatedModules[mid]);
+    }
+
+    // Phase 4: Remove deleted modules
+    for (var r = 0; r < removedModules.length; r++) {
+      var rmId = removedModules[r];
+      delete modules[rmId];
+      delete cache[rmId];
+      delete hotState[rmId];
+    }
+
+    // Phase 5: Re-execute modules. Clear ALL caches first so that nested
+    // require() calls during re-execution pick up the new factories rather
+    // than stale cached exports (e.g. entry requiring a dependency that
+    // hasn't been re-executed yet in this loop).
+    modulesToReExecute.forEach(function(execId) {
+      delete cache[execId];
+    });
+    modulesToReExecute.forEach(function(execId) {
+      try {
+        require(execId);
+      } catch(err) {
+        console.error('[HMR] Error re-executing module ' + execId + ':', err);
+        window.parent.postMessage({ type: 'hmr-full-reload' }, '*');
+      }
+    });
+
+    // Phase 6: React Refresh -- tell React to re-render with new component definitions
+    if (reactRefreshEnabled && window.__REACT_REFRESH_RUNTIME__) {
+      try {
+        window.__REACT_REFRESH_RUNTIME__.performReactRefresh();
+      } catch(err) {
+        console.error('[HMR] React Refresh error:', err);
+      }
+    }
+
+    console.log('[HMR] Updated ' + Object.keys(updatedModules).length + ' module(s)');
+  }
+
+  // Expose HMR API globally
+  window.__BUNDLER_HMR__ = {
+    applyUpdate: applyUpdate,
+    modules: modules,
+    cache: cache,
+    hotState: hotState
+  };
+
+  // Listen for HMR updates from parent window
+  window.addEventListener('message', function(e) {
+    var data = e.data;
+    if (data && data.type === 'hmr-update') {
+      applyUpdate(data.updatedModules || {}, data.removedModules || [], data.reverseDepsMap);
+    }
+  });
+
+  // Initialize React Refresh runtime BEFORE executing the entry module,
+  // so $RefreshReg$ and $RefreshSig$ are available when component modules load.
+  if (reactRefreshEnabled) {
+    try {
+      var RefreshRuntime = require('react-refresh/runtime');
+      RefreshRuntime.injectIntoGlobalHook(window);
+      window.__REACT_REFRESH_RUNTIME__ = RefreshRuntime;
+      window.$RefreshReg$ = function() {};
+      window.$RefreshSig$ = function() { return function(type) { return type; }; };
+    } catch(e) {
+      console.warn('[HMR] React Refresh runtime not available:', e.message || e);
+    }
+  }
+
+  // Execute entry module
+  require(entryId);
+})`;
+/**
+ * Emit an HMR-capable bundle string.
+ */
+export function emitHmrBundle(moduleMap, entryFile, reverseDepsMap, reactRefresh, env, routerShim) {
+    const moduleEntries = Object.keys(moduleMap)
+        .map((id) => {
+        return (JSON.stringify(id) +
+            ": function(module, exports, require) {\n" +
+            moduleMap[id] +
+            "\n}");
+    })
+        .join(",\n\n");
+    return (buildBundlePreamble(env, routerShim) +
+        HMR_RUNTIME_TEMPLATE +
+        "({\n" +
+        moduleEntries +
+        "\n}, " +
+        JSON.stringify(reverseDepsMap) +
+        ", " +
+        JSON.stringify(entryFile) +
+        ", " +
+        String(reactRefresh) +
+        ");\n");
+}

package/dist/incremental-bundler.d.ts

@@ -0,0 +1,71 @@
+import { VirtualFS } from "./fs.js";
+import { DependencyGraph } from "./dependency-graph.js";
+import { ModuleCache } from "./module-cache.js";
+import type { BundlerConfig, FileChange, IncrementalBuildResult } from "./types.js";
+export declare class IncrementalBundler {
+    private fs;
+    private resolver;
+    private config;
+    private plugins;
+    readonly graph: DependencyGraph;
+    readonly cache: ModuleCache;
+    private moduleMap;
+    private sourceMapMap;
+    private entryFile;
+    private packageVersions;
+    private transitiveDepsVersions;
+    constructor(fs: VirtualFS, config: BundlerConfig);
+    /** Read tsconfig.json "compilerOptions.paths" from the VirtualFS */
+    private static readTsconfigPaths;
+    /** Run the full pre-transform -> Sucrase -> post-transform pipeline */
+    private runTransform;
+    /** Build a resolve callback that consults plugins then falls back to default resolution */
+    private makeResolveTarget;
+    /** Collect module aliases from all plugins */
+    private getModuleAliases;
+    /** Collect module shims from all plugins */
+    private getShimModules;
+    /** Scan npm packages in the module map for require calls not yet fetched */
+    private findTransitiveNpmDeps;
+    /** Transform a single file using the configured transformer */
+    private transformFile;
+    /** Read dependency versions from the project's package.json */
+    private getPackageVersions;
+    /** Resolve an npm specifier to a versioned form.
+     *  Priority: user's package.json > transitive dep versions from manifests > bare name */
+    private resolveNpmSpecifier;
+    /** Fetch a pre-bundled npm package from the package server */
+    private fetchPackage;
+    /**
+     * Process a single local file: transform, rewrite requires, extract deps,
+     * update cache and graph. Returns the list of npm deps found.
+     */
+    private processFile;
+    /**
+     * 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.
+     */
+    private walkDeps;
+    /** Fetch all npm packages that aren't already cached */
+    private fetchNpmPackages;
+    /** Emit the bundle using HMR runtime or standard IIFE */
+    private emitBundle;
+    /** Compute source map inputs with correct line offsets for each module */
+    private buildSourceMapInputs;
+    /** Initial full build */
+    build(entryFile: string): Promise<IncrementalBuildResult>;
+    /** Incremental rebuild based on file changes */
+    rebuild(changes: FileChange[]): Promise<IncrementalBuildResult>;
+    /** Update the virtual filesystem */
+    updateFS(fs: VirtualFS): void;
+}