@solidjs/vite-plugin 3.0.0-next.38 → 3.0.0-next.39

package/dist/cjs/index.cjs

@@ -1102,29 +1102,50 @@ const HANDLER_ID$1 = 'virtual:solid-server-function-handler';
 // (`vite build` then `vite build --ssr`) does not, so the client build
 // persists its findings for the SSR build to merge (mirroring the plugin's
 // dist/client/.vite/manifest.json convention).
+//
+// The file doubles as the build's statement of which server functions the
+// CLIENT can reach — every reference the client compile emitted, by wire id
+// — for build tooling that needs that set without re-deriving it from
+// compiled output (a static-site prerenderer checking that each reachable
+// function was captured, for example). Paths are root-relative, posix.
 const PERSISTED_MANIFEST_PATH = '.vite/solid-server-functions.json';
+
+/** The persisted manifest's on-disk shape (the array form is the pre-`functions` legacy). */
+
 function readPersistedManifest(root) {
   const file = path.resolve(root, 'dist/client', PERSISTED_MANIFEST_PATH);
   if (!fs.existsSync(file)) return new Set();
   try {
-    const entries = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    const entries = Array.isArray(parsed) ? parsed : parsed.modules;
     return new Set(entries.map(entry => path.resolve(root, entry)).filter(entry => fs.existsSync(entry)));
   } catch {
     return new Set();
   }
 }
-function writePersistedManifest(root, outDir, entries) {
+function writePersistedManifest(root, outDir, entries, functions) {
   const file = path.resolve(root, outDir, PERSISTED_MANIFEST_PATH);
   fs.mkdirSync(path.dirname(file), {
     recursive: true
   });
-  const relative = [...entries].map(entry => path.relative(root, entry).split(path.sep).join('/'));
-  fs.writeFileSync(file, JSON.stringify(relative, null, 2));
+  const relative = entry => path.relative(root, entry).split(path.sep).join('/');
+  const manifest = {
+    modules: [...entries].map(relative),
+    functions: [...functions].map(([id, record]) => ({
+      id,
+      name: record.name,
+      module: relative(record.module)
+    }))
+  };
+  fs.writeFileSync(file, JSON.stringify(manifest, null, 2));
 }
 function createManifest() {
   return {
-    server: new Set(),
-    client: new Set()
+    modules: {
+      server: new Set(),
+      client: new Set()
+    },
+    clientFunctions: new Map()
   };
 }
 function createDeferredPromise() {
@@ -1332,13 +1353,13 @@ function serverFunctions(options = {}, internal = {}) {
   const hashIndex = new Map();
   let hashIndexSize = -1;
   function moduleForFunctionId(functionId) {
-    if (manifest.server.size !== hashIndexSize) {
+    if (manifest.modules.server.size !== hashIndexSize) {
       hashIndex.clear();
-      for (const entry of manifest.server) {
+      for (const entry of manifest.modules.server) {
         const relative = path.relative(root, entry).split(path.sep).join('/');
         hashIndex.set(xxHash32(relative).toString(16), entry);
       }
-      hashIndexSize = manifest.server.size;
+      hashIndexSize = manifest.modules.server.size;
     }
     return hashIndex.get(functionId.split('-')[1]);
   }
@@ -1462,9 +1483,25 @@ function serverFunctions(options = {}, internal = {}) {
       sourceMap: !tsrx || !!internal.tsrxSourceMap
     });
     if (!result.valid) return null;
+
+    // The client compile is the authority on what the browser can dispatch:
+    // record every reference it emitted, by wire id, for the persisted
+    // manifest. A module is re-transformed on change, so its previous ids
+    // are dropped first (a renamed function must not linger as reachable).
+    if (mode === 'client') {
+      for (const [functionId, record] of manifest.clientFunctions) {
+        if (record.module === id) manifest.clientFunctions.delete(functionId);
+      }
+      for (const fn of result.functions) {
+        manifest.clientFunctions.set(fn.id, {
+          name: fn.name,
+          module: id
+        });
+      }
+    }
     const preloader = preload[mode];
     if (preloader) preloader.defer();
-    invalidateModules(currentServer, mergeManifestRecord(manifest.server, new Set([id])), manifestId);
+    invalidateModules(currentServer, mergeManifestRecord(manifest.modules.server, new Set([id])), manifestId);
     return {
       // Appended (not prepended) so the source map for the compiled module
       // stays valid; imports hoist and the endpoint is only read at call time.
@@ -1512,7 +1549,7 @@ function serverFunctions(options = {}, internal = {}) {
         // build discovered so the server manifest registers them even when
         // the SSR module graph never imports them.
         for (const entry of readPersistedManifest(root)) {
-          manifest.server.add(entry);
+          manifest.modules.server.add(entry);
         }
       }
     },
@@ -1527,7 +1564,7 @@ function serverFunctions(options = {}, internal = {}) {
       const consumer = ctx.environment?.config?.consumer;
       const isClient = consumer ? consumer === 'client' : !isSsrBuild;
       if (isBuild && isClient) {
-        writePersistedManifest(root, outDir, manifest.server);
+        writePersistedManifest(root, outDir, manifest.modules.server, manifest.clientFunctions);
       }
     }
   }, {
@@ -1552,10 +1589,10 @@ function serverFunctions(options = {}, internal = {}) {
           // configs resolve before the client build has written the file,
           // but this load runs once the SSR environment builds — after it.
           for (const entry of readPersistedManifest(root)) {
-            manifest.server.add(entry);
+            manifest.modules.server.add(entry);
           }
         }
-        const current = new Debouncer(() => [...manifest[mode]].map(entry => `import ${JSON.stringify(entry)};`).join('\n'));
+        const current = new Debouncer(() => [...manifest.modules[mode]].map(entry => `import ${JSON.stringify(entry)};`).join('\n'));
         preload[mode] = current;
         const result = await current.promise.reference;
         return result;