@webtypen/webframez-react 0.0.41 → 0.0.42

package/bin/webframez-react.mjs

@@ -519,6 +519,84 @@ async function watchRouteTargets(targets, passthroughArgsClean) {
   });
 }
 
+function getManifestChunkAssetsByName(distRootDir) {
+  const chunksDir = path.join(distRootDir, "chunks");
+  const assetsByName = new Map();
+  if (!fileExists(chunksDir)) {
+    return assetsByName;
+  }
+
+  for (const fileName of fs.readdirSync(chunksDir)) {
+    const match = fileName.match(/^(.*)-[a-f0-9]+\.js$/i);
+    if (match && match[1]) {
+      assetsByName.set(match[1], path.join("chunks", fileName));
+    }
+  }
+
+  return assetsByName;
+}
+
+function normalizeRouteManifestChunkFiles(distRootDir) {
+  const manifestPath = path.join(distRootDir, "react-client-manifest.json");
+  if (!fileExists(manifestPath)) {
+    return;
+  }
+
+  const assetsByName = getManifestChunkAssetsByName(distRootDir);
+  if (assetsByName.size === 0) {
+    return;
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  let changed = false;
+  for (const value of Object.values(manifest)) {
+    if (!value || typeof value !== "object" || !Array.isArray(value.chunks)) {
+      continue;
+    }
+
+    const nextChunks = value.chunks.map((chunk, index, chunks) => {
+      if (index % 2 === 1 && typeof chunks[index - 1] === "string") {
+        return assetsByName.get(chunks[index - 1]) || chunk;
+      }
+
+      return chunk;
+    });
+
+    if (nextChunks.some((chunk, index) => chunk !== value.chunks[index])) {
+      value.chunks = nextChunks;
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+}
+
+function collectMissingManifestChunks(distRootDir) {
+  const manifestPath = path.join(distRootDir, "react-client-manifest.json");
+  if (!fileExists(manifestPath)) {
+    return [];
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+  const missing = [];
+  for (const value of Object.values(manifest)) {
+    if (!value || typeof value !== "object" || !Array.isArray(value.chunks)) {
+      continue;
+    }
+
+    for (let index = 1; index < value.chunks.length; index += 2) {
+      const chunk = value.chunks[index];
+      if (typeof chunk === "string" && chunk.includes(".") && !fileExists(path.join(distRootDir, chunk))) {
+        missing.push(chunk);
+      }
+    }
+  }
+
+  return Array.from(new Set(missing));
+}
+
 async function validateRouteBuild(target) {
   const requiredFiles = [
     path.join(target.distRootDir, "client.js"),
@@ -532,6 +610,13 @@ async function validateRouteBuild(target) {
       `Route ${target.path} build is incomplete. Missing: ${missing.join(", ")}`,
     );
   }
+
+  const missingChunks = collectMissingManifestChunks(target.distRootDir);
+  if (missingChunks.length > 0) {
+    throw new Error(
+      `Route ${target.path} client manifest references missing chunks: ${missingChunks.join(", ")}`,
+    );
+  }
 }
 
 async function main() {
@@ -631,6 +716,7 @@ async function main() {
         return;
       }
 
+      normalizeRouteManifestChunkFiles(target.distRootDir);
       await validateRouteBuild(target);
     }
 

package/defaults/webpack.client.cjs

@@ -34,6 +34,53 @@ const frameworkCacheVersion = frameworkCacheFiles
 fs.mkdirSync(distDir, { recursive: true });
 fs.mkdirSync(pagesDir, { recursive: true });
 
+function getEmittedChunkAssetsByName() {
+  const chunksDir = path.join(distDir, "chunks");
+  const assetsByName = new Map();
+  if (!fs.existsSync(chunksDir)) {
+    return assetsByName;
+  }
+
+  for (const fileName of fs.readdirSync(chunksDir)) {
+    const match = fileName.match(/^(.*)-[a-f0-9]+\.js$/i);
+    if (match && match[1]) {
+      assetsByName.set(match[1], "chunks/" + fileName);
+    }
+  }
+
+  return assetsByName;
+}
+
+function normalizeManifestChunkFiles(manifest) {
+  const assetsByName = getEmittedChunkAssetsByName();
+  if (assetsByName.size === 0) {
+    return false;
+  }
+
+  let changed = false;
+  for (const value of Object.values(manifest)) {
+    if (!value || typeof value !== "object" || !Array.isArray(value.chunks)) {
+      continue;
+    }
+
+    const nextChunks = value.chunks.map((chunk, index, chunks) => {
+      if (index % 2 === 1 && typeof chunks[index - 1] === "string") {
+        return assetsByName.get(chunks[index - 1]) || chunk;
+      }
+
+      return chunk;
+    });
+
+    if (nextChunks.some((chunk, index) => chunk !== value.chunks[index])) {
+      value.chunks = nextChunks;
+      changed = true;
+    }
+  }
+
+  return changed;
+}
+
+
 class ClientManifestExportAliasesPlugin {
   apply(compiler) {
     compiler.hooks.done.tap("ClientManifestExportAliasesPlugin", () => {
@@ -152,6 +199,10 @@ class ClientManifestExportAliasesPlugin {
         }
       }
 
+      if (normalizeManifestChunkFiles(manifest)) {
+        changed = true;
+      }
+
       if (changed) {
         fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
       }

package/dist/build-plugin.cjs

@@ -41,6 +41,47 @@ function fileExists(filePath) {
 function readJson(filePath) {
   return JSON.parse(import_node_fs.default.readFileSync(filePath, "utf-8"));
 }
+function getEmittedChunkAssetsByName(distRootDir) {
+  const chunksDir = import_node_path.default.join(distRootDir, "chunks");
+  const assetsByName = /* @__PURE__ */ new Map();
+  if (!fileExists(chunksDir)) {
+    return assetsByName;
+  }
+  for (const fileName of import_node_fs.default.readdirSync(chunksDir)) {
+    const match = fileName.match(/^(.*)-[a-f0-9]+\.js$/i);
+    if (match?.[1]) {
+      assetsByName.set(match[1], import_node_path.default.join("chunks", fileName));
+    }
+  }
+  return assetsByName;
+}
+function normalizeManifestChunkFiles(distRootDir, manifestPath) {
+  const manifest = readJson(manifestPath);
+  const assetsByName = getEmittedChunkAssetsByName(distRootDir);
+  if (assetsByName.size === 0) {
+    return;
+  }
+  let changed = false;
+  for (const value of Object.values(manifest)) {
+    const entry = value;
+    if (!entry || !Array.isArray(entry.chunks)) {
+      continue;
+    }
+    const nextChunks = entry.chunks.map((chunk, index, chunks) => {
+      if (index % 2 === 1 && typeof chunks[index - 1] === "string") {
+        return assetsByName.get(chunks[index - 1]) || chunk;
+      }
+      return chunk;
+    });
+    if (nextChunks.some((chunk, index) => chunk !== entry.chunks?.[index])) {
+      entry.chunks = nextChunks;
+      changed = true;
+    }
+  }
+  if (changed) {
+    import_node_fs.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+}
 function collectManifestChunks(manifestPath) {
   const manifest = readJson(manifestPath);
   const chunks = /* @__PURE__ */ new Set();
@@ -65,7 +106,9 @@ function validateRouteDist(distRootDir) {
       throw new Error(`webframez-react build output missing: ${filePath}`);
     }
   }
-  for (const chunk of collectManifestChunks(import_node_path.default.join(distRootDir, "react-client-manifest.json"))) {
+  const clientManifestPath = import_node_path.default.join(distRootDir, "react-client-manifest.json");
+  normalizeManifestChunkFiles(distRootDir, clientManifestPath);
+  for (const chunk of collectManifestChunks(clientManifestPath)) {
     const chunkPath = import_node_path.default.join(distRootDir, chunk);
     if (!fileExists(chunkPath)) {
       throw new Error(`webframez-react manifest references missing chunk: ${chunkPath}`);

package/dist/build-plugin.js

@@ -7,6 +7,47 @@ function fileExists(filePath) {
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, "utf-8"));
 }
+function getEmittedChunkAssetsByName(distRootDir) {
+  const chunksDir = path.join(distRootDir, "chunks");
+  const assetsByName = /* @__PURE__ */ new Map();
+  if (!fileExists(chunksDir)) {
+    return assetsByName;
+  }
+  for (const fileName of fs.readdirSync(chunksDir)) {
+    const match = fileName.match(/^(.*)-[a-f0-9]+\.js$/i);
+    if (match?.[1]) {
+      assetsByName.set(match[1], path.join("chunks", fileName));
+    }
+  }
+  return assetsByName;
+}
+function normalizeManifestChunkFiles(distRootDir, manifestPath) {
+  const manifest = readJson(manifestPath);
+  const assetsByName = getEmittedChunkAssetsByName(distRootDir);
+  if (assetsByName.size === 0) {
+    return;
+  }
+  let changed = false;
+  for (const value of Object.values(manifest)) {
+    const entry = value;
+    if (!entry || !Array.isArray(entry.chunks)) {
+      continue;
+    }
+    const nextChunks = entry.chunks.map((chunk, index, chunks) => {
+      if (index % 2 === 1 && typeof chunks[index - 1] === "string") {
+        return assetsByName.get(chunks[index - 1]) || chunk;
+      }
+      return chunk;
+    });
+    if (nextChunks.some((chunk, index) => chunk !== entry.chunks?.[index])) {
+      entry.chunks = nextChunks;
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+}
 function collectManifestChunks(manifestPath) {
   const manifest = readJson(manifestPath);
   const chunks = /* @__PURE__ */ new Set();
@@ -31,7 +72,9 @@ function validateRouteDist(distRootDir) {
       throw new Error(`webframez-react build output missing: ${filePath}`);
     }
   }
-  for (const chunk of collectManifestChunks(path.join(distRootDir, "react-client-manifest.json"))) {
+  const clientManifestPath = path.join(distRootDir, "react-client-manifest.json");
+  normalizeManifestChunkFiles(distRootDir, clientManifestPath);
+  for (const chunk of collectManifestChunks(clientManifestPath)) {
     const chunkPath = path.join(distRootDir, chunk);
     if (!fileExists(chunkPath)) {
       throw new Error(`webframez-react manifest references missing chunk: ${chunkPath}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webtypen/webframez-react",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "TypeScript React RSC addition for @webtypen/webframez-core",
   "homepage": "https://webtypen.de/",
   "author": {