import type * as rolldown from "rolldown"; /** * Drop the chunks no entry reaches, with their source maps, before the bundle * is returned or written. * * Rolldown decides a dynamic chunk is live when the statement holding its * `import()` is included, and a cycle can keep that true on its own: Vite's * `node.js` sets up `createCachedImport(() => import("./build.js"))` at * module level, and `build.js` imports `node.js` back. So a Worker that only * reaches `import("vite")` through deploy-time code tree-shaking removes * still got ~1 MB of chunks (Vite, rolldown, esbuild, postcss, …) that * nothing loads, and every output file is uploaded. * * `dynamicImports` is computed before constant inlining, so it can list an * `import()` the final code no longer contains: only dynamic imports the * importer's code still references are followed. */ export const unreachableChunksPlugin = (): rolldown.Plugin => ({ name: "alchemy:unreachable-chunks", generateBundle(_options, bundle) { const chunks = Object.values(bundle).filter( (file): file is rolldown.OutputChunk => file.type === "chunk", ); const live = new Set(); const queue = chunks.filter((chunk) => chunk.isEntry).map((chunk) => chunk.fileName); while (queue.length > 0) { const fileName = queue.pop()!; if (live.has(fileName)) continue; live.add(fileName); const chunk = bundle[fileName] as rolldown.OutputChunk; for (const dependency of chunk.imports) { if (bundle[dependency]?.type === "chunk") queue.push(dependency); } for (const dependency of chunk.dynamicImports) { if ( bundle[dependency]?.type === "chunk" && chunk.code.includes(dependency.split("/").pop()!) ) { queue.push(dependency); } } } for (const chunk of chunks) { if (live.has(chunk.fileName)) continue; delete bundle[chunk.fileName]; if (chunk.sourcemapFileName !== null) delete bundle[chunk.sourcemapFileName]; } }, });