almostnode 0.2.3 → 0.2.5

package/dist/index.mjs

@@ -39,7 +39,8 @@ let __tla = (async () => {
       __publicField(this, "eventListeners", /* @__PURE__ */ new Map());
       this.root = {
         type: "directory",
-        children: /* @__PURE__ */ new Map()
+        children: /* @__PURE__ */ new Map(),
+        mtime: Date.now()
       };
     }
     on(event, listener) {
@@ -152,7 +153,8 @@ let __tla = (async () => {
       const content = typeof data === "string" ? this.encoder.encode(data) : data;
       parent.children.set(basename2, {
         type: "file",
-        content
+        content,
+        mtime: Date.now()
       });
       if (emitEvent) {
         this.notifyWatchers(normalized, existed ? "change" : "rename");
@@ -213,7 +215,8 @@ let __tla = (async () => {
         if (!child) {
           child = {
             type: "directory",
-            children: /* @__PURE__ */ new Map()
+            children: /* @__PURE__ */ new Map(),
+            mtime: Date.now()
           };
           current.children.set(segment, child);
         } else if (child.type !== "directory") {
@@ -232,8 +235,8 @@ let __tla = (async () => {
       if (!node) {
         throw createNodeError("ENOENT", "stat", path2);
       }
-      const now = Date.now();
       const size = node.type === "file" ? ((_a2 = node.content) == null ? void 0 : _a2.length) || 0 : 0;
+      const mtime = node.mtime;
       return {
         isFile: () => node.type === "file",
         isDirectory: () => node.type === "directory",
@@ -244,14 +247,14 @@ let __tla = (async () => {
         isSocket: () => false,
         size,
         mode: node.type === "directory" ? 493 : 420,
-        mtime: new Date(now),
-        atime: new Date(now),
-        ctime: new Date(now),
-        birthtime: new Date(now),
-        mtimeMs: now,
-        atimeMs: now,
-        ctimeMs: now,
-        birthtimeMs: now,
+        mtime: new Date(mtime),
+        atime: new Date(mtime),
+        ctime: new Date(mtime),
+        birthtime: new Date(mtime),
+        mtimeMs: mtime,
+        atimeMs: mtime,
+        ctimeMs: mtime,
+        birthtimeMs: mtime,
         nlink: 1,
         uid: 1e3,
         gid: 1e3,
@@ -305,7 +308,8 @@ let __tla = (async () => {
       }
       parent.children.set(basename2, {
         type: "directory",
-        children: /* @__PURE__ */ new Map()
+        children: /* @__PURE__ */ new Map(),
+        mtime: Date.now()
       });
     }
     readdirSync(path2) {
@@ -589,6 +593,14 @@ let __tla = (async () => {
       };
     }
   };
+  function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      hash = (hash << 5) - hash + str.charCodeAt(i);
+      hash |= 0;
+    }
+    return hash.toString(36);
+  }
   class Dirent {
     constructor(name, isDirectory, isFile) {
       __publicField(this, "name");
@@ -9188,7 +9200,23 @@ let __tla = (async () => {
     "@sentry/node": sentryShim,
     "@sentry/core": sentryShim
   };
-  function createRequire(vfs, fsShim, process, currentDir, moduleCache, options) {
+  function createRequire(vfs, fsShim, process, currentDir, moduleCache, options, processedCodeCache) {
+    const resolutionCache = /* @__PURE__ */ new Map();
+    const packageJsonCache = /* @__PURE__ */ new Map();
+    const getParsedPackageJson = (pkgPath) => {
+      if (packageJsonCache.has(pkgPath)) {
+        return packageJsonCache.get(pkgPath);
+      }
+      try {
+        const content = vfs.readFileSync(pkgPath, "utf8");
+        const parsed = JSON.parse(content);
+        packageJsonCache.set(pkgPath, parsed);
+        return parsed;
+      } catch {
+        packageJsonCache.set(pkgPath, null);
+        return null;
+      }
+    };
     const resolveModule = (id, fromDir) => {
       if (id.startsWith("node:")) {
         id = id.slice(5);
@@ -9196,15 +9224,25 @@ let __tla = (async () => {
       if (builtinModules[id] || id === "fs" || id === "process" || id === "url" || id === "querystring" || id === "util") {
         return id;
       }
+      const cacheKey = `${fromDir}|${id}`;
+      const cached = resolutionCache.get(cacheKey);
+      if (cached !== void 0) {
+        if (cached === null) {
+          throw new Error(`Cannot find module '${id}'`);
+        }
+        return cached;
+      }
       if (id.startsWith("./") || id.startsWith("../") || id.startsWith("/")) {
         const resolved = id.startsWith("/") ? id : resolve$2(fromDir, id);
         if (vfs.existsSync(resolved)) {
           const stats = vfs.statSync(resolved);
           if (stats.isFile()) {
+            resolutionCache.set(cacheKey, resolved);
             return resolved;
           }
           const indexPath = join(resolved, "index.js");
           if (vfs.existsSync(indexPath)) {
+            resolutionCache.set(cacheKey, indexPath);
             return indexPath;
           }
         }
@@ -9215,9 +9253,11 @@ let __tla = (async () => {
         for (const ext of extensions) {
           const withExt = resolved + ext;
           if (vfs.existsSync(withExt)) {
+            resolutionCache.set(cacheKey, withExt);
             return withExt;
           }
         }
+        resolutionCache.set(cacheKey, null);
         throw new Error(`Cannot find module '${id}' from '${fromDir}'`);
       }
       const tryResolveFile = (basePath) => {
@@ -9252,9 +9292,8 @@ let __tla = (async () => {
         const pkgName = parts[0].startsWith("@") && parts.length > 1 ? `${parts[0]}/${parts[1]}` : parts[0];
         const pkgRoot = join(nodeModulesDir, pkgName);
         const pkgPath = join(pkgRoot, "package.json");
-        if (vfs.existsSync(pkgPath)) {
-          const pkgContent = vfs.readFileSync(pkgPath, "utf8");
-          const pkg = JSON.parse(pkgContent);
+        const pkg = getParsedPackageJson(pkgPath);
+        if (pkg) {
           if (pkg.exports) {
             try {
               const resolved2 = resolve$3(pkg, moduleId, {
@@ -9282,11 +9321,18 @@ let __tla = (async () => {
       while (searchDir !== "/") {
         const nodeModulesDir = join(searchDir, "node_modules");
         const resolved = tryResolveFromNodeModules(nodeModulesDir, id);
-        if (resolved) return resolved;
+        if (resolved) {
+          resolutionCache.set(cacheKey, resolved);
+          return resolved;
+        }
         searchDir = dirname(searchDir);
       }
       const rootResolved = tryResolveFromNodeModules("/node_modules", id);
-      if (rootResolved) return rootResolved;
+      if (rootResolved) {
+        resolutionCache.set(cacheKey, rootResolved);
+        return rootResolved;
+      }
+      resolutionCache.set(cacheKey, null);
       throw new Error(`Cannot find module '${id}'`);
     };
     const loadModule = (resolvedPath) => {
@@ -9308,19 +9354,25 @@ let __tla = (async () => {
         module.loaded = true;
         return module;
       }
-      let code = vfs.readFileSync(resolvedPath, "utf8");
+      const rawCode = vfs.readFileSync(resolvedPath, "utf8");
       const dirname$1 = dirname(resolvedPath);
-      const isCjsFile = resolvedPath.endsWith(".cjs");
-      const isAlreadyBundledCjs = code.startsWith('"use strict";\nvar __') || code.startsWith("'use strict';\nvar __");
-      const hasEsmImport = /\bimport\s+[\w{*'"]/m.test(code);
-      const hasEsmExport = /\bexport\s+(?:default|const|let|var|function|class|{|\*)/m.test(code);
-      if (!isCjsFile && !isAlreadyBundledCjs) {
-        if (resolvedPath.endsWith(".mjs") || resolvedPath.includes("/esm/") || hasEsmImport || hasEsmExport) {
-          code = transformEsmToCjs(code, resolvedPath);
-        }
-      }
-      code = transformDynamicImports(code);
-      const moduleRequire = createRequire(vfs, fsShim, process, dirname$1, moduleCache, options);
+      const codeCacheKey = `${resolvedPath}|${simpleHash(rawCode)}`;
+      let code = processedCodeCache == null ? void 0 : processedCodeCache.get(codeCacheKey);
+      if (!code) {
+        code = rawCode;
+        const isCjsFile = resolvedPath.endsWith(".cjs");
+        const isAlreadyBundledCjs = code.startsWith('"use strict";\nvar __') || code.startsWith("'use strict';\nvar __");
+        const hasEsmImport = /\bimport\s+[\w{*'"]/m.test(code);
+        const hasEsmExport = /\bexport\s+(?:default|const|let|var|function|class|{|\*)/m.test(code);
+        if (!isCjsFile && !isAlreadyBundledCjs) {
+          if (resolvedPath.endsWith(".mjs") || resolvedPath.includes("/esm/") || hasEsmImport || hasEsmExport) {
+            code = transformEsmToCjs(code, resolvedPath);
+          }
+        }
+        code = transformDynamicImports(code);
+        processedCodeCache == null ? void 0 : processedCodeCache.set(codeCacheKey, code);
+      }
+      const moduleRequire = createRequire(vfs, fsShim, process, dirname$1, moduleCache, options, processedCodeCache);
       moduleRequire.cache = moduleCache;
       const consoleWrapper = createConsoleWrapper(options.onConsole);
       try {
@@ -9492,6 +9544,7 @@ ${code}
       __publicField(this, "process");
       __publicField(this, "moduleCache", {});
       __publicField(this, "options");
+      __publicField(this, "processedCodeCache", /* @__PURE__ */ new Map());
       __publicField(this, "executeSync", this.execute);
       __publicField(this, "runFileSync", this.runFile);
       this.vfs = vfs2;
@@ -9576,7 +9629,7 @@ ${code}
     execute(code, filename = "/index.js") {
       const dirname$1 = dirname(filename);
       this.vfs.writeFileSync(filename, code);
-      const require = createRequire(this.vfs, this.fsShim, this.process, dirname$1, this.moduleCache, this.options);
+      const require = createRequire(this.vfs, this.fsShim, this.process, dirname$1, this.moduleCache, this.options, this.processedCodeCache);
       const module = {
         id: filename,
         filename,
@@ -9658,7 +9711,7 @@ ${code}
       __publicField(this, "deleteListener", null);
       this.vfs = vfs2;
       this.options = options2;
-      this.worker = new Worker(new URL("/assets/runtime-worker-D9x_Ddwz.js", import.meta.url), {
+      this.worker = new Worker(new URL("/assets/runtime-worker-B8_LZkBX.js", import.meta.url), {
         type: "module"
       });
       this.workerApi = wrap(this.worker);
@@ -11626,6 +11679,7 @@ console.log('[HMR] React Refresh initialized');
       __publicField(this, "watcherCleanup", null);
       __publicField(this, "options");
       __publicField(this, "hmrTargetWindow", null);
+      __publicField(this, "transformCache", /* @__PURE__ */ new Map());
       this.options = {
         jsx: true,
         jsxFactory: "React.createElement",
@@ -11742,7 +11796,28 @@ console.log('[HMR] React Refresh initialized');
     async transformAndServe(filePath, urlPath) {
       try {
         const content = this.vfs.readFileSync(filePath, "utf8");
+        const hash = simpleHash(content);
+        const cached = this.transformCache.get(filePath);
+        if (cached && cached.hash === hash) {
+          const buffer22 = BufferPolyfill.from(cached.code);
+          return {
+            statusCode: 200,
+            statusMessage: "OK",
+            headers: {
+              "Content-Type": "application/javascript; charset=utf-8",
+              "Content-Length": String(buffer22.length),
+              "Cache-Control": "no-cache",
+              "X-Transformed": "true",
+              "X-Cache": "hit"
+            },
+            body: buffer22
+          };
+        }
         const transformed = await this.transformCode(content, urlPath);
+        this.transformCache.set(filePath, {
+          code: transformed,
+          hash
+        });
         const buffer2 = BufferPolyfill.from(transformed);
         return {
           statusCode: 200,
@@ -12493,6 +12568,7 @@ export default function Head({ children }) {
       __publicField(this, "watcherCleanup", null);
       __publicField(this, "hmrTargetWindow", null);
       __publicField(this, "options");
+      __publicField(this, "transformCache", /* @__PURE__ */ new Map());
       this.options = options2;
       this.pagesDir = options2.pagesDir || "/pages";
       this.appDir = options2.appDir || "/app";
@@ -12557,6 +12633,9 @@ export default function Head({ children }) {
       if (pathname.startsWith("/_next/pages/")) {
         return this.servePageComponent(pathname);
       }
+      if (pathname.startsWith("/_next/app/")) {
+        return this.serveAppComponent(pathname);
+      }
       if (pathname.startsWith("/_next/static/")) {
         return this.serveStaticAsset(pathname);
       }
@@ -12621,6 +12700,22 @@ export default function Head({ children }) {
       }
       return this.transformAndServe(pageFile, pageFile);
     }
+    async serveAppComponent(pathname) {
+      const filePath = pathname.replace("/_next/app", "").replace(/\.js$/, "");
+      const extensions = [
+        ".tsx",
+        ".jsx",
+        ".ts",
+        ".js"
+      ];
+      for (const ext of extensions) {
+        const fullPath = filePath + ext;
+        if (this.exists(fullPath)) {
+          return this.transformAndServe(fullPath, fullPath);
+        }
+      }
+      return this.notFound(pathname);
+    }
     async handleApiRoute(method, pathname, headers, body) {
       const apiFile = this.resolveApiFile(pathname);
       if (!apiFile) {
@@ -13177,11 +13272,9 @@ export default function Head({ children }) {
           globalCssLinks.push(`<link rel="stylesheet" href="${virtualPrefix}${cssPath}">`);
         }
       }
-      const pageModulePath = virtualPrefix + route.page;
-      const layoutImports = route.layouts.map((layout, i) => `import Layout${i} from '${virtualPrefix}${layout}';`).join("\n    ");
-      let nestedJsx = "React.createElement(Page)";
+      virtualPrefix + route.page;
+      route.layouts.map((layout, i) => `import Layout${i} from '${virtualPrefix}${layout}';`).join("\n    ");
       for (let i = route.layouts.length - 1; i >= 0; i--) {
-        nestedJsx = `React.createElement(Layout${i}, null, ${nestedJsx})`;
       }
       const envScript = this.generateEnvScript();
       return `<!DOCTYPE html>
@@ -13225,17 +13318,117 @@ export default function Head({ children }) {
   <script type="module">
     import React from 'react';
     import ReactDOM from 'react-dom/client';
-    import Page from '${pageModulePath}';
-    ${layoutImports}
 
-    function App() {
-      return ${nestedJsx};
+    const virtualBase = '${virtualPrefix}';
+
+    // Convert URL path to app router page module path
+    function getAppPageModulePath(pathname) {
+      let route = pathname;
+      if (route.startsWith(virtualBase)) {
+        route = route.slice(virtualBase.length);
+      }
+      route = route.replace(/^\\/+/, '/') || '/';
+      // App Router: / -> /app/page, /about -> /app/about/page
+      const pagePath = route === '/' ? '/app/page' : '/app' + route + '/page';
+      return virtualBase + '/_next/app' + pagePath + '.js';
+    }
+
+    // Get layout paths for a route
+    function getLayoutPaths(pathname) {
+      let route = pathname;
+      if (route.startsWith(virtualBase)) {
+        route = route.slice(virtualBase.length);
+      }
+      route = route.replace(/^\\/+/, '/') || '/';
+
+      // Build layout paths from root to current route
+      const layouts = [virtualBase + '/_next/app/app/layout.js'];
+      if (route !== '/') {
+        const segments = route.split('/').filter(Boolean);
+        let currentPath = '/app';
+        for (const segment of segments) {
+          currentPath += '/' + segment;
+          layouts.push(virtualBase + '/_next/app' + currentPath + '/layout.js');
+        }
+      }
+      return layouts;
     }
 
+    // Dynamic page loader
+    async function loadPage(pathname) {
+      const modulePath = getAppPageModulePath(pathname);
+      try {
+        const module = await import(/* @vite-ignore */ modulePath);
+        return module.default;
+      } catch (e) {
+        console.error('[Navigation] Failed to load page:', modulePath, e);
+        return null;
+      }
+    }
+
+    // Load layouts (with caching)
+    const layoutCache = new Map();
+    async function loadLayouts(pathname) {
+      const layoutPaths = getLayoutPaths(pathname);
+      const layouts = [];
+      for (const path of layoutPaths) {
+        if (layoutCache.has(path)) {
+          layouts.push(layoutCache.get(path));
+        } else {
+          try {
+            const module = await import(/* @vite-ignore */ path);
+            layoutCache.set(path, module.default);
+            layouts.push(module.default);
+          } catch (e) {
+            // Layout might not exist for this segment, skip
+          }
+        }
+      }
+      return layouts;
+    }
+
+    // Router component
+    function Router() {
+      const [Page, setPage] = React.useState(null);
+      const [layouts, setLayouts] = React.useState([]);
+      const [path, setPath] = React.useState(window.location.pathname);
+
+      React.useEffect(() => {
+        Promise.all([loadPage(path), loadLayouts(path)]).then(([P, L]) => {
+          if (P) setPage(() => P);
+          setLayouts(L);
+        });
+      }, []);
+
+      React.useEffect(() => {
+        const handleNavigation = async () => {
+          const newPath = window.location.pathname;
+          if (newPath !== path) {
+            setPath(newPath);
+            const [P, L] = await Promise.all([loadPage(newPath), loadLayouts(newPath)]);
+            if (P) setPage(() => P);
+            setLayouts(L);
+          }
+        };
+        window.addEventListener('popstate', handleNavigation);
+        return () => window.removeEventListener('popstate', handleNavigation);
+      }, [path]);
+
+      if (!Page) return null;
+
+      // Build nested layout structure
+      let content = React.createElement(Page);
+      for (let i = layouts.length - 1; i >= 0; i--) {
+        content = React.createElement(layouts[i], null, content);
+      }
+      return content;
+    }
+
+    // Mark that we've initialized (for testing no-reload)
+    window.__NEXT_INITIALIZED__ = Date.now();
+
     ReactDOM.createRoot(document.getElementById('__next')).render(
-      React.createElement(React.StrictMode, null,
-        React.createElement(App)
-      )
+      React.createElement(React.StrictMode, null, React.createElement(Router))
     );
   <\/script>
 </body>
@@ -13490,7 +13683,28 @@ export default function Head({ children }) {
     async transformAndServe(filePath, urlPath) {
       try {
         const content = this.vfs.readFileSync(filePath, "utf8");
+        const hash = simpleHash(content);
+        const cached = this.transformCache.get(filePath);
+        if (cached && cached.hash === hash) {
+          const buffer22 = BufferPolyfill.from(cached.code);
+          return {
+            statusCode: 200,
+            statusMessage: "OK",
+            headers: {
+              "Content-Type": "application/javascript; charset=utf-8",
+              "Content-Length": String(buffer22.length),
+              "Cache-Control": "no-cache",
+              "X-Transformed": "true",
+              "X-Cache": "hit"
+            },
+            body: buffer22
+          };
+        }
         const transformed = await this.transformCode(content, urlPath);
+        this.transformCache.set(filePath, {
+          code: transformed,
+          hash
+        });
         const buffer2 = BufferPolyfill.from(transformed);
         return {
           statusCode: 200,