@astrojs/cloudflare 10.1.0 → 10.2.1

package/dist/index.js

@@ -1,15 +1,23 @@
 import { createReadStream } from 'node:fs';
-import { appendFile, rename, stat } from 'node:fs/promises';
+import { appendFile, rename, stat, unlink } from 'node:fs/promises';
 import { createInterface } from 'node:readline/promises';
 import { appendForwardSlash, prependForwardSlash, removeLeadingForwardSlash, } from '@astrojs/internal-helpers/path';
 import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
 import { AstroError } from 'astro/errors';
+import { walk } from 'estree-walker';
+import MagicString from 'magic-string';
 import { getPlatformProxy } from 'wrangler';
 import { createRoutesFile, getParts } from './utils/generate-routes-json.js';
 import { setImageConfig } from './utils/image-config.js';
+import { mutateDynamicPageImportsInPlace, mutatePageMapInPlace } from './utils/index.js';
+import { NonServerChunkDetector } from './utils/non-server-chunk-detector.js';
 import { wasmModuleLoader } from './utils/wasm-module-loader.js';
 export default function createIntegration(args) {
     let _config;
+    // Initialize the unused chunk analyzer as a shared state between hooks.
+    // The analyzer is used on earlier hooks to collect information about used hooks on a Vite plugin
+    // and then later after the full build to clean up unused chunks, so it has to be shared between them.
+    const chunkAnalyzer = new NonServerChunkDetector();
     return {
         name: '@astrojs/cloudflare',
         hooks: {
@@ -27,6 +35,51 @@ export default function createIntegration(args) {
                             wasmModuleLoader({
                                 disabled: !args?.wasmModuleImports,
                             }),
+                            chunkAnalyzer.getPlugin(),
+                            {
+                                name: 'dynamic-imports-analyzer',
+                                enforce: 'post',
+                                generateBundle(_, bundle) {
+                                    let astrojsSSRVirtualEntryAST;
+                                    const prerenderImports = [];
+                                    let entryChunk;
+                                    // Find all pages (ignore the ssr entrypoint) which are prerendered based on the dynamic imports of the prerender chunk
+                                    for (const chunk of Object.values(bundle)) {
+                                        if (chunk.type !== 'chunk')
+                                            continue;
+                                        if (chunk.name === '_@astrojs-ssr-virtual-entry') {
+                                            astrojsSSRVirtualEntryAST = this.parse(chunk.code);
+                                            entryChunk = chunk;
+                                            continue;
+                                        }
+                                        const isPrerendered = chunk.dynamicImports.some((entry) => entry.includes('prerender'));
+                                        if (isPrerendered) {
+                                            prerenderImports.push(chunk.fileName);
+                                        }
+                                    }
+                                    if (!astrojsSSRVirtualEntryAST)
+                                        return;
+                                    if (!entryChunk)
+                                        return;
+                                    const s = new MagicString(entryChunk.code);
+                                    const constsToRemove = [];
+                                    walk(astrojsSSRVirtualEntryAST, {
+                                        leave(node) {
+                                            // We are only looking for VariableDeclarations, since both (dynamic imports and pageMap) are declared as constants in the code
+                                            if (node.type !== 'VariableDeclaration')
+                                                return;
+                                            if (!node.declarations[0] ||
+                                                node.declarations[0].type !== 'VariableDeclarator')
+                                                return;
+                                            // This function will remove the dynamic imports from the entrypoint
+                                            mutateDynamicPageImportsInPlace(node, prerenderImports, constsToRemove, s);
+                                            // This function will remove the pageMap entries which are invalid now
+                                            mutatePageMapInPlace(node, constsToRemove, s);
+                                        },
+                                    });
+                                    entryChunk.code = s.toString();
+                                },
+                            },
                         ],
                     },
                     image: setImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
@@ -217,6 +270,13 @@ export default function createIntegration(args) {
                         logger.error('Failed to write _redirects file');
                     }
                 }
+                // Get chunks from the bundle that are not needed on the server and delete them
+                // Those modules are build only for prerendering routes.
+                const chunksToDelete = chunkAnalyzer.getNonServerChunks();
+                for (const chunk of chunksToDelete) {
+                    // Chunks are located on `./_worker.js` directory inside of the output directory
+                    await unlink(new URL(`./_worker.js/${chunk}`, _config.outDir));
+                }
             },
         },
     };

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+import type { Node } from 'estree-walker';
+import type MagicString from 'magic-string';
+export declare function mutatePageMapInPlace(node: Extract<Node, {
+    type: 'VariableDeclaration';
+}>, constsToRemove: string[], s: MagicString): void;
+export declare function mutateDynamicPageImportsInPlace(node: Extract<Node, {
+    type: 'VariableDeclaration';
+}>, prerenderImports: string[], constsToRemove: string[], s: MagicString): void;

package/dist/utils/index.js

@@ -0,0 +1,49 @@
+export function mutatePageMapInPlace(node, constsToRemove, s) {
+    const declarator = node.declarations[0];
+    if (declarator.id.type !== 'Identifier')
+        return;
+    if (declarator.id.name !== 'pageMap')
+        return;
+    if (!declarator.init || declarator.init.type !== 'NewExpression')
+        return;
+    if (!declarator.init.arguments[0] || declarator.init.arguments[0].type !== 'ArrayExpression')
+        return;
+    for (const arrayExpression of declarator.init.arguments[0].elements) {
+        if (!arrayExpression || arrayExpression.type !== 'ArrayExpression')
+            continue;
+        if (!arrayExpression.elements[1] || arrayExpression.elements[1].type !== 'Identifier')
+            continue;
+        if (constsToRemove.includes(arrayExpression.elements[1].name)) {
+            console.log(arrayExpression);
+            // @ts-expect-error - @types/estree seem to be wrong
+            if (arrayExpression.start && arrayExpression.end) {
+                // @ts-expect-error - @types/estree seem to be wrong
+                s.remove(arrayExpression.start, arrayExpression.end);
+            }
+        }
+    }
+}
+export function mutateDynamicPageImportsInPlace(node, prerenderImports, constsToRemove, s) {
+    const declarator = node.declarations[0];
+    if (declarator.id.type !== 'Identifier')
+        return;
+    if (!declarator.id.name.startsWith('_page'))
+        return;
+    if (!declarator.init || declarator.init.type !== 'ArrowFunctionExpression')
+        return;
+    if (!declarator.init.body || declarator.init.body.type !== 'ImportExpression')
+        return;
+    if (!declarator.init.body.source || declarator.init.body.source.type !== 'Literal')
+        return;
+    const sourceValue = declarator.init.body.source.value;
+    if (typeof sourceValue !== 'string')
+        return;
+    if (prerenderImports.some((importItem) => sourceValue.includes(importItem))) {
+        // @ts-expect-error - @types/estree seem to be wrong
+        if (node.start && node.end) {
+            constsToRemove.push(declarator.id.name);
+            // @ts-expect-error - @types/estree seem to be wrong
+            s.remove(node.start, node.end);
+        }
+    }
+}

package/dist/utils/non-server-chunk-detector.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from 'vite';
+/**
+ * A Vite bundle analyzer that identifies chunks that are not used for server rendering.
+ *
+ * The chunks injected by Astro for prerendering are flagged as non-server chunks.
+ * Any chunks that is only used by a non-server chunk are also flagged as non-server chunks.
+ * This continues transitively until all non-server chunks are found.
+ */
+export declare class NonServerChunkDetector {
+    private nonServerChunks?;
+    getPlugin(): Plugin;
+    private processBundle;
+    getNonServerChunks(): string[];
+}

package/dist/utils/non-server-chunk-detector.js

@@ -0,0 +1,66 @@
+/**
+ * A Vite bundle analyzer that identifies chunks that are not used for server rendering.
+ *
+ * The chunks injected by Astro for prerendering are flagged as non-server chunks.
+ * Any chunks that is only used by a non-server chunk are also flagged as non-server chunks.
+ * This continues transitively until all non-server chunks are found.
+ */
+export class NonServerChunkDetector {
+    nonServerChunks;
+    getPlugin() {
+        return {
+            name: 'non-server-chunk-detector',
+            generateBundle: (_, bundle) => {
+                this.processBundle(bundle);
+            },
+        };
+    }
+    processBundle(bundle) {
+        const chunkNamesToFiles = new Map();
+        const entryChunks = [];
+        const chunkToDependencies = new Map();
+        for (const chunk of Object.values(bundle)) {
+            if (chunk.type !== 'chunk')
+                continue;
+            // Construct a mapping from a chunk name to its file name
+            chunkNamesToFiles.set(chunk.name, chunk.fileName);
+            // Construct a mapping from a chunk file to all the modules it imports
+            chunkToDependencies.set(chunk.fileName, [...chunk.imports, ...chunk.dynamicImports]);
+            if (chunk.isEntry) {
+                // Entry chunks should always be kept around since they are to be imported by the runtime
+                entryChunks.push(chunk.fileName);
+            }
+        }
+        const chunkDecisions = new Map();
+        for (const entry of entryChunks) {
+            // Entry chunks are used on the server
+            chunkDecisions.set(entry, true);
+        }
+        for (const chunk of ['prerender', 'prerender@_@astro']) {
+            // Prerender chunks are not used on the server
+            const fileName = chunkNamesToFiles.get(chunk);
+            if (fileName) {
+                chunkDecisions.set(fileName, false);
+            }
+        }
+        // Start a stack of chunks that are used on the server
+        const chunksToWalk = [...entryChunks];
+        // Iterate over the chunks, traversing the transitive dependencies of the chunks used on the server
+        for (let chunk = chunksToWalk.pop(); chunk; chunk = chunksToWalk.pop()) {
+            for (const dep of chunkToDependencies.get(chunk) ?? []) {
+                // Skip dependencies already flagged, dependencies may be repeated and/or circular
+                if (chunkDecisions.has(dep))
+                    continue;
+                // A dependency of a module used on the server is also used on the server
+                chunkDecisions.set(dep, true);
+                // Add the dependency to the stack so its own dependencies are also flagged
+                chunksToWalk.push(dep);
+            }
+        }
+        // Any chunk not flagged as used on the server is a non-server chunk
+        this.nonServerChunks = Array.from(chunkToDependencies.keys()).filter((chunk) => !chunkDecisions.get(chunk));
+    }
+    getNonServerChunks() {
+        return this.nonServerChunks ?? [];
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "10.1.0",
+  "version": "10.2.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -28,11 +28,13 @@
     "dist"
   ],
   "dependencies": {
-    "@astrojs/underscore-redirects": "^0.3.3",
     "@astrojs/internal-helpers": "0.3.0",
+    "@astrojs/underscore-redirects": "^0.3.3",
     "@cloudflare/workers-types": "^4.20240320.1",
-    "miniflare": "^3.20240320.0",
     "esbuild": "^0.19.5",
+    "estree-walker": "^3.0.3",
+    "magic-string": "^0.30.10",
+    "miniflare": "^3.20240320.0",
     "tiny-glob": "^0.2.9",
     "wrangler": "^3.39.0"
   },
@@ -40,11 +42,13 @@
     "astro": "^4.2.0"
   },
   "devDependencies": {
+    "astro": "^4.5.8",
+    "cheerio": "1.0.0-rc.12",
     "execa": "^8.0.1",
     "fast-glob": "^3.3.2",
+    "rollup": "^4.14.0",
     "strip-ansi": "^7.1.0",
-    "astro": "^4.5.8",
-    "cheerio": "1.0.0-rc.12",
+    "vite": "^5.2.6",
     "@astrojs/test-utils": "0.0.1",
     "astro-scripts": "0.0.14"
   },