@astrojs/cloudflare 0.0.0-cf-10-20240320162001 → 0.0.0-cf-10-solid-20240329084913

package/dist/entrypoints/image-service.js

@@ -1,5 +1,6 @@
+import { joinPaths } from '@astrojs/internal-helpers/path';
 import { baseService } from 'astro/assets';
-import { isESMImportedImage, isRemoteAllowed, joinPaths } from '../utils/assets.js';
+import { isESMImportedImage, isRemoteAllowed } from '../utils/assets.js';
 const service = {
     ...baseService,
     getURL: (options, imageConfig) => {

package/dist/entrypoints/server.advanced.d.ts

@@ -1,4 +1,4 @@
-import type { CacheStorage as CFCacheStorage, Request as CFRequest, ExecutionContext } from '@cloudflare/workers-types';
+import type { CacheStorage as CLOUDFLARE_CACHESTORAGE, Request as CLOUDFLARE_REQUEST, ExecutionContext } from '@cloudflare/workers-types';
 import type { SSRManifest } from 'astro';
 type Env = {
     ASSETS: {
@@ -6,17 +6,17 @@ type Env = {
     };
     ASTRO_STUDIO_APP_TOKEN?: string;
 };
-export interface AdvancedRuntime<T extends object = object> {
+export interface Runtime<T extends object = object> {
     runtime: {
         waitUntil: (promise: Promise<any>) => void;
         env: Env & T;
-        cf: CFRequest['cf'];
-        caches: CFCacheStorage;
+        cf: CLOUDFLARE_REQUEST['cf'];
+        caches: CLOUDFLARE_CACHESTORAGE;
     };
 }
 export declare function createExports(manifest: SSRManifest): {
     default: {
-        fetch: (request: Request & CFRequest, env: Env, context: ExecutionContext) => Promise<Response>;
+        fetch: (request: Request & CLOUDFLARE_REQUEST, env: Env, context: ExecutionContext) => Promise<Response>;
     };
 };
 export {};

package/dist/entrypoints/server.advanced.js

@@ -8,6 +8,13 @@ export function createExports(manifest) {
             return env.ASSETS.fetch(request.url.replace(/\.html$/, ''));
         }
         const routeData = app.match(request);
+        if (!routeData) {
+            // https://developers.cloudflare.com/pages/functions/api-reference/#envassetsfetch
+            const asset = await env.ASSETS.fetch(request.url.replace(/index.html$/, '').replace(/\.html$/, ''));
+            if (asset.status !== 404) {
+                return asset;
+            }
+        }
         Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
         process.env.ASTRO_STUDIO_APP_TOKEN ??= (() => {
             if (typeof env.ASTRO_STUDIO_APP_TOKEN === 'string') {

package/dist/index.d.ts

@@ -1,15 +1,48 @@
 import type { AstroIntegration } from 'astro';
-export type { AdvancedRuntime } from './entrypoints/server.advanced.js';
+export type { Runtime } from './entrypoints/server.advanced.js';
 export type Options = {
+    /** Options for handling images. */
     imageService?: 'passthrough' | 'cloudflare' | 'compile';
-    wasmModuleImports?: boolean;
+    /** Configuration for `_routes.json` generation. A _routes.json file controls when your Function is invoked. This file will include three different properties:
+     *
+     * - version: Defines the version of the schema. Currently there is only one version of the schema (version 1), however, we may add more in the future and aim to be backwards compatible.
+     * - include: Defines routes that will be invoked by Functions. Accepts wildcard behavior.
+     * - exclude: Defines routes that will not be invoked by Functions. Accepts wildcard behavior. `exclude` always take priority over `include`.
+     *
+     * Wildcards match any number of path segments (slashes). For example, `/users/*` will match everything after the `/users/` path.
+     *
+     */
+    routes?: {
+        /** Extend `_routes.json` */
+        extend: {
+            /** Paths which should be routed to the SSR function */
+            include?: {
+                /** Generally this is in pathname format, but does support wildcards, e.g. `/users`, `/products/*` */
+                pattern: string;
+            }[];
+            /** Paths which should be routed as static assets */
+            exclude?: {
+                /** Generally this is in pathname format, but does support wildcards, e.g. `/static`, `/assets/*`, `/images/avatar.jpg` */
+                pattern: string;
+            }[];
+        };
+    };
+    /**
+     * Proxy configuration for the platform.
+     */
     platformProxy?: {
+        /** Toggle the proxy. Default `undefined`, which equals to `false`. */
         enabled?: boolean;
+        /** Path to the configuration file. Default `wrangler.toml`. */
         configPath?: string;
+        /** Enable experimental support for JSON configuration. Default `false`. */
         experimentalJsonConfig?: boolean;
+        /** Configuration persistence settings. Default '.wrangler/state/v3' */
         persist?: boolean | {
             path: string;
         };
     };
+    /** Enable WebAssembly support */
+    wasmModuleImports?: boolean;
 };
 export default function createIntegration(args?: Options): AstroIntegration;

package/dist/index.js

@@ -1,12 +1,11 @@
 import { createReadStream } from 'node:fs';
 import { appendFile, rename, stat } from 'node:fs/promises';
 import { createInterface } from 'node:readline/promises';
-import { inspect } from 'node:util';
+import { appendForwardSlash, prependForwardSlash, removeLeadingForwardSlash, } from '@astrojs/internal-helpers/path';
 import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
 import { AstroError } from 'astro/errors';
 import { getPlatformProxy } from 'wrangler';
-import { removeLeadingForwardSlash } from './utils/assets.js';
-import createRoutesFile, { getParts } from './utils/generate-routes.js';
+import { createRoutesFile, getParts } from './utils/generate-routes-json.js';
 import { setImageConfig } from './utils/image-config.js';
 import { wasmModuleLoader } from './utils/wasm-module-loader.js';
 export default function createIntegration(args) {
@@ -14,36 +13,24 @@ export default function createIntegration(args) {
     return {
         name: '@astrojs/cloudflare',
         hooks: {
-            'astro:config:setup': ({ command, config, updateConfig, logger, addDevToolbarApp, injectRoute, }) => {
+            'astro:config:setup': ({ command, config, updateConfig, logger }) => {
                 updateConfig({
                     build: {
-                        client: new URL(`.${config.base}/`, config.outDir),
+                        client: new URL(`.${prependForwardSlash(appendForwardSlash(config.base))}`, config.outDir),
                         server: new URL('./_worker.js/', config.outDir),
                         serverEntry: 'index.js',
+                        redirects: false,
                     },
                     vite: {
                         // load .wasm files as WebAssembly modules
                         plugins: [
                             wasmModuleLoader({
                                 disabled: !args?.wasmModuleImports,
-                                isHybrid: config.output === 'hybrid',
                             }),
                         ],
                     },
                     image: setImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
                 });
-                // MARK: Dev Toolbar App
-                if (command === 'dev') {
-                    addDevToolbarApp('@astrojs/cloudflare/dev-toolbar-app');
-                    injectRoute({
-                        pattern: '/_dev-toolbar-app/cloudflare/tabs',
-                        entrypoint: '@astrojs/cloudflare/dev-toolbar-app/tabs.astro',
-                    });
-                    injectRoute({
-                        pattern: '/_dev-toolbar-app/cloudflare/home',
-                        entrypoint: '@astrojs/cloudflare/dev-toolbar-app/test.astro',
-                    });
-                }
             },
             'astro:config:done': ({ setAdapter, config }) => {
                 _config = config;
@@ -71,24 +58,21 @@ export default function createIntegration(args) {
                     },
                 });
             },
-            'astro:server:setup': async ({ server, logger }) => {
+            'astro:server:setup': async ({ server }) => {
                 if (args?.platformProxy?.enabled === true) {
-                    const platform = await getPlatformProxy({
+                    const platformProxy = await getPlatformProxy({
                         configPath: args.platformProxy.configPath ?? 'wrangler.toml',
                         experimentalJsonConfig: args.platformProxy.experimentalJsonConfig ?? false,
                         persist: args.platformProxy.persist ?? true,
                     });
-                    const tmpString = inspect(platform.env.D1);
-                    console.log(tmpString);
-                    console.log(platform.env.KV);
                     const clientLocalsSymbol = Symbol.for('astro.locals');
                     server.middlewares.use(async function middleware(req, res, next) {
                         Reflect.set(req, clientLocalsSymbol, {
                             runtime: {
-                                env: platform.env,
-                                cf: platform.cf,
-                                caches: platform.caches,
-                                ctx: platform.ctx,
+                                env: platformProxy.env,
+                                cf: platformProxy.cf,
+                                caches: platformProxy.caches,
+                                ctx: platformProxy.ctx,
                             },
                         });
                         next();
@@ -113,26 +97,41 @@ export default function createIntegration(args) {
                             vite.resolve.alias[alias.find] = alias.replacement;
                         }
                     }
+                    vite.resolve.conditions ||= [];
+                    vite.resolve.conditions.push('workerd', 'worker');
                     vite.ssr ||= {};
-                    vite.ssr.noExternal = true;
-                    vite.ssr.external = _config?.vite?.ssr?.external ?? [];
                     vite.ssr.target = 'webworker';
+                    vite.ssr.noExternal = true;
+                    vite.ssr.external = _config.vite.ssr?.external ?? [];
                     vite.build ||= {};
                     vite.build.rollupOptions ||= {};
                     vite.build.rollupOptions.output ||= {};
-                    // @ts-ignore
-                    vite.build.rollupOptions.output.banner ||= 'globalThis.process ??= {};';
-                    vite.build.rollupOptions.external = _config?.vite?.build?.rollupOptions?.external ?? [];
+                    // @ts-expect-error
+                    vite.build.rollupOptions.output.banner ||=
+                        'globalThis.process ??= {}; globalThis.process.env ??= {};';
+                    vite.build.rollupOptions.external = _config.vite.build?.rollupOptions?.external ?? [];
+                    // Cloudflare env is only available per request. This isn't feasible for code that access env vars
+                    // in a global way, so we shim their access as `process.env.*`. This is not the recommended way for users to access environment variables. But we'll add this for compatibility for chosen variables. Mainly to support `@astrojs/db`
+                    vite.define = {
+                        'process.env': 'process.env',
+                        ...vite.define,
+                    };
+                }
+                if (target === 'client') {
+                    vite.resolve ||= {};
+                    vite.resolve.conditions ||= [];
+                    vite.resolve.conditions = vite.resolve.conditions.filter((c) => c !== 'workerd' && c !== 'worker');
                 }
             },
-            'astro:build:done': async ({ routes, pages, dir }) => {
+            'astro:build:done': async ({ pages, routes, dir, logger }) => {
+                const PLATFORM_FILES = ['_headers', '_redirects', '_routes.json'];
                 if (_config.base !== '/') {
-                    for (const file of ['_headers', '_redirects', '_routes.json']) {
+                    for (const file of PLATFORM_FILES) {
                         try {
                             await rename(new URL(file, _config.build.client), new URL(file, _config.outDir));
                         }
                         catch (e) {
-                            /*  */
+                            logger.error(`There was an error moving ${file} to the root of the output directory.`);
                         }
                     }
                 }
@@ -180,7 +179,7 @@ export default function createIntegration(args) {
                     routesExists = false;
                 }
                 if (!routesExists) {
-                    await createRoutesFile(_config, routes, pages, redirects);
+                    await createRoutesFile(_config, logger, routes, pages, redirects, args?.routes?.extend?.include, args?.routes?.extend?.exclude);
                 }
                 const redirectRoutes = [];
                 for (const route of routes) {
@@ -197,7 +196,7 @@ export default function createIntegration(args) {
                         await appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
                     }
                     catch (error) {
-                        // TODO
+                        logger.error('Failed to write _redirects file');
                     }
                 }
             },

package/dist/utils/assets.d.ts

@@ -1,6 +1,5 @@
 import type { AstroConfig, ImageMetadata, RemotePattern } from 'astro';
 export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
-export declare function isRemotePath(src: string): boolean;
 export declare function matchHostname(url: URL, hostname?: string, allowWildcard?: boolean): boolean;
 export declare function matchPort(url: URL, port?: string): boolean;
 export declare function matchProtocol(url: URL, protocol?: string): boolean;
@@ -8,7 +7,3 @@ export declare function matchPathname(url: URL, pathname?: string, allowWildcard
 export declare function matchPattern(url: URL, remotePattern: RemotePattern): boolean;
 export declare function isRemoteAllowed(src: string, { domains, remotePatterns, }: Partial<Pick<AstroConfig['image'], 'domains' | 'remotePatterns'>>): boolean;
 export declare function isString(path: unknown): path is string;
-export declare function removeTrailingForwardSlash(path: string): string;
-export declare function removeLeadingForwardSlash(path: string): string;
-export declare function trimSlashes(path: string): string;
-export declare function joinPaths(...paths: (string | undefined)[]): string;

package/dist/utils/assets.js

@@ -1,9 +1,7 @@
+import { isRemotePath } from '@astrojs/internal-helpers/path';
 export function isESMImportedImage(src) {
     return typeof src === 'object';
 }
-export function isRemotePath(src) {
-    return /^(http|ftp|https|ws):?\/\//.test(src) || src.startsWith('data:');
-}
 export function matchHostname(url, hostname, allowWildcard) {
     if (!hostname) {
         return true;
@@ -68,26 +66,3 @@ export function isRemoteAllowed(src, { domains = [], remotePatterns = [], }) {
 export function isString(path) {
     return typeof path === 'string' || path instanceof String;
 }
-export function removeTrailingForwardSlash(path) {
-    return path.endsWith('/') ? path.slice(0, path.length - 1) : path;
-}
-export function removeLeadingForwardSlash(path) {
-    return path.startsWith('/') ? path.substring(1) : path;
-}
-export function trimSlashes(path) {
-    return path.replace(/^\/|\/$/g, '');
-}
-export function joinPaths(...paths) {
-    return paths
-        .filter(isString)
-        .map((path, i) => {
-        if (i === 0) {
-            return removeTrailingForwardSlash(path);
-        }
-        if (i === paths.length - 1) {
-            return removeLeadingForwardSlash(path);
-        }
-        return trimSlashes(path);
-    })
-        .join('/');
-}

package/dist/utils/generate-routes-json.d.ts

@@ -0,0 +1,9 @@
+import type { AstroConfig, AstroIntegrationLogger, RouteData, RoutePart } from 'astro';
+export declare function getParts(part: string): RoutePart[];
+export declare function createRoutesFile(_config: AstroConfig, logger: AstroIntegrationLogger, routes: RouteData[], pages: {
+    pathname: string;
+}[], redirects: RouteData['segments'][], includeExtends: {
+    pattern: string;
+}[] | undefined, excludeExtends: {
+    pattern: string;
+}[] | undefined): Promise<void>;

package/dist/utils/generate-routes-json.js

@@ -0,0 +1,205 @@
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { posix } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { prependForwardSlash, removeLeadingForwardSlash, removeTrailingForwardSlash, } from '@astrojs/internal-helpers/path';
+import glob from 'tiny-glob';
+// Copied from https://github.com/withastro/astro/blob/3776ecf0aa9e08a992d3ae76e90682fd04093721/packages/astro/src/core/routing/manifest/create.ts#L45-L70
+// We're not sure how to improve this regex yet
+const ROUTE_DYNAMIC_SPLIT = /\[(.+?\(.+?\)|.+?)\]/;
+const ROUTE_SPREAD = /^\.{3}.+$/;
+export function getParts(part) {
+    const result = [];
+    part.split(ROUTE_DYNAMIC_SPLIT).map((str, i) => {
+        if (!str)
+            return;
+        const dynamic = i % 2 === 1;
+        const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
+        if (!content || (dynamic && !/^(?:\.\.\.)?[\w$]+$/.test(content))) {
+            throw new Error('Parameter name must match /^[a-zA-Z0-9_$]+$/');
+        }
+        result.push({
+            content,
+            dynamic,
+            spread: dynamic && ROUTE_SPREAD.test(content),
+        });
+    });
+    return result;
+}
+async function writeRoutesFileToOutDir(_config, logger, include, exclude) {
+    try {
+        await writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
+            version: 1,
+            include: include,
+            exclude: exclude,
+        }, null, 2), 'utf-8');
+    }
+    catch (error) {
+        logger.error("There was an error writing the '_routes.json' file to the output directory.");
+    }
+}
+function segmentsToCfSyntax(segments, _config) {
+    const pathSegments = [];
+    if (removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)).length > 0) {
+        pathSegments.push(removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base)));
+    }
+    for (const segment of segments.flat()) {
+        if (segment.dynamic)
+            pathSegments.push('*');
+        else
+            pathSegments.push(segment.content);
+    }
+    return pathSegments;
+}
+class TrieNode {
+    children = new Map();
+    isEndOfPath = false;
+    hasWildcardChild = false;
+}
+class PathTrie {
+    root;
+    constructor() {
+        this.root = new TrieNode();
+    }
+    insert(path) {
+        let node = this.root;
+        for (const segment of path) {
+            if (segment === '*') {
+                node.hasWildcardChild = true;
+                break;
+            }
+            if (!node.children.has(segment)) {
+                node.children.set(segment, new TrieNode());
+            }
+            // biome-ignore lint/style/noNonNullAssertion: The `if` condition above ensures that the segment exists inside the map
+            node = node.children.get(segment);
+        }
+        node.isEndOfPath = true;
+    }
+    /**
+     * Depth-first search (dfs), traverses the "graph"  segment by segment until the end or wildcard (*).
+     * It makes sure that all necessary paths are returned, but not paths with an existing wildcard prefix.
+     * e.g. if we have a path like /foo/* and /foo/bar, we only want to return /foo/*
+     */
+    dfs(node, path, allPaths) {
+        if (node.hasWildcardChild) {
+            allPaths.push([...path, '*']);
+            return;
+        }
+        if (node.isEndOfPath) {
+            allPaths.push([...path]);
+        }
+        for (const [segment, childNode] of node.children) {
+            this.dfs(childNode, [...path, segment], allPaths);
+        }
+    }
+    getAllPaths() {
+        const allPaths = [];
+        this.dfs(this.root, [], allPaths);
+        return allPaths;
+    }
+}
+export async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
+    const includePaths = [];
+    const excludePaths = [];
+    let hasPrerendered404 = false;
+    for (const route of routes) {
+        const convertedPath = segmentsToCfSyntax(route.segments, _config);
+        if (route.pathname === '/404' && route.prerender === true)
+            hasPrerendered404 = true;
+        switch (route.type) {
+            case 'page':
+                if (route.prerender === false)
+                    includePaths.push(convertedPath);
+                break;
+            case 'endpoint':
+                if (route.prerender === false)
+                    includePaths.push(convertedPath);
+                else
+                    excludePaths.push(convertedPath);
+                break;
+            case 'redirect':
+                excludePaths.push(convertedPath);
+                break;
+            default:
+                /**
+                 * We don't know the type, so we are conservative!
+                 * Invoking the function on these is a safe-bet because
+                 * the function will fallback to static asset fetching
+                 */
+                includePaths.push(convertedPath);
+                break;
+        }
+    }
+    for (const page of pages) {
+        const pageSegments = removeLeadingForwardSlash(page.pathname)
+            .split(posix.sep)
+            .filter(Boolean)
+            .map((s) => {
+            return getParts(s);
+        });
+        excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
+    }
+    if (existsSync(fileURLToPath(_config.publicDir))) {
+        const staticFiles = await glob(`${fileURLToPath(_config.publicDir)}/**/*`, {
+            cwd: fileURLToPath(_config.publicDir),
+            filesOnly: true,
+            dot: true,
+        });
+        for (const staticFile of staticFiles) {
+            if (['_headers', '_redirects', '_routes.json'].includes(staticFile))
+                continue;
+            const staticPath = staticFile;
+            const segments = removeLeadingForwardSlash(staticPath)
+                .split(posix.sep)
+                .filter(Boolean)
+                .map((s) => {
+                return getParts(s);
+            });
+            excludePaths.push(segmentsToCfSyntax(segments, _config));
+        }
+    }
+    /**
+     * All files in the `_config.build.assets` path, e.g. `_astro`
+     * are considered static assets and should not be handled by the function
+     * therefore we exclude a wildcard for that, e.g. `/_astro/*`
+     */
+    const assetsPath = segmentsToCfSyntax([
+        [{ content: _config.build.assets, dynamic: false, spread: false }],
+        [{ content: '', dynamic: true, spread: false }],
+    ], _config);
+    excludePaths.push(assetsPath);
+    for (const redirect of redirects) {
+        excludePaths.push(segmentsToCfSyntax(redirect, _config));
+    }
+    const includeTrie = new PathTrie();
+    for (const includePath of includePaths) {
+        includeTrie.insert(includePath);
+    }
+    const deduplicatedIncludePaths = includeTrie.getAllPaths();
+    const excludeTrie = new PathTrie();
+    for (const excludePath of excludePaths) {
+        excludeTrie.insert(excludePath);
+    }
+    const deduplicatedExcludePaths = excludeTrie.getAllPaths();
+    /**
+     * Cloudflare allows no more than 100 include/exclude rules combined
+     * https://developers.cloudflare.com/pages/functions/routing/#limits
+     */
+    const CLOUDFLARE_COMBINED_LIMIT = 100;
+    if (!hasPrerendered404 ||
+        deduplicatedIncludePaths.length + (includeExtends?.length ?? 0) > CLOUDFLARE_COMBINED_LIMIT ||
+        deduplicatedExcludePaths.length + (excludeExtends?.length ?? 0) > CLOUDFLARE_COMBINED_LIMIT) {
+        await writeRoutesFileToOutDir(_config, logger, ['/*'].concat(includeExtends?.map((entry) => entry.pattern) ?? []), deduplicatedExcludePaths
+            .map((path) => `${prependForwardSlash(path.join('/'))}`)
+            .concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
+            .slice(0, 99));
+    }
+    else {
+        await writeRoutesFileToOutDir(_config, logger, deduplicatedIncludePaths
+            .map((path) => `${prependForwardSlash(path.join('/'))}`)
+            .concat(includeExtends?.map((entry) => entry.pattern) ?? []), deduplicatedExcludePaths
+            .map((path) => `${prependForwardSlash(path.join('/'))}`)
+            .concat(excludeExtends?.map((entry) => entry.pattern) ?? []));
+    }
+}

package/dist/utils/wasm-module-loader.d.ts

@@ -8,7 +8,6 @@ import type { AstroConfig } from 'astro';
  * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
  * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
  */
-export declare function wasmModuleLoader({ disabled, isHybrid, }: {
+export declare function wasmModuleLoader({ disabled, }: {
     disabled: boolean;
-    isHybrid: boolean;
 }): NonNullable<AstroConfig['vite']['plugins']>[number];

package/dist/utils/wasm-module-loader.js

@@ -9,7 +9,7 @@ import * as path from 'node:path';
  * @param assetsDirectory - the folder name for the assets directory in the build directory. Usually '_astro'
  * @returns Vite plugin to load WASM tagged with '?module' as a WASM modules
  */
-export function wasmModuleLoader({ disabled, isHybrid, }) {
+export function wasmModuleLoader({ disabled, }) {
     const postfix = '.wasm?module';
     let isDev = false;
     return {
@@ -24,6 +24,7 @@ export function wasmModuleLoader({ disabled, isHybrid, }) {
                 assetsInclude: ['**/*.wasm?module'],
                 build: {
                     rollupOptions: {
+                        // mark the wasm files as external so that they are not bundled and instead are loaded from the files
                         external: [/^__WASM_ASSET__.+\.wasm$/i, /^__WASM_ASSET__.+\.wasm.mjs$/i],
                     },
                 },
@@ -71,9 +72,10 @@ export function wasmModuleLoader({ disabled, isHybrid, }) {
                 return;
             if (!/__WASM_ASSET__/g.test(code))
                 return;
+            const isPrerendered = Object.keys(chunk.modules).some((moduleId) => this.getModuleInfo(moduleId)?.meta?.astro?.pageOptions?.prerender === true);
             let final = code;
             // SSR
-            if (isHybrid && chunk.exports.includes('prerender') && code.includes('prerender = false;')) {
+            if (!isPrerendered) {
                 final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
                     const fileName = this.getFileName(assetId).replace(/\.mjs$/, '');
                     const relativePath = path
@@ -82,28 +84,8 @@ export function wasmModuleLoader({ disabled, isHybrid, }) {
                     return `./${relativePath}`;
                 });
             }
-            // SSR
-            if (!isHybrid && !chunk.exports.includes('prerender')) {
-                final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
-                    const fileName = this.getFileName(assetId);
-                    const relativePath = path
-                        .relative(path.dirname(chunk.fileName), fileName)
-                        .replaceAll('\\', '/'); // fix windows paths for import
-                    return `./${relativePath}`;
-                });
-            }
-            // SSG
-            if (isHybrid && !chunk.exports.includes('prerender')) {
-                final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
-                    const fileName = this.getFileName(assetId);
-                    const relativePath = path
-                        .relative(path.dirname(chunk.fileName), fileName)
-                        .replaceAll('\\', '/'); // fix windows paths for import
-                    return `./${relativePath}`;
-                });
-            }
             // SSG
-            if (!isHybrid && chunk.exports.includes('prerender') && code.includes('prerender = true;')) {
+            if (isPrerendered) {
                 final = code.replaceAll(/__WASM_ASSET__([A-Za-z\d]+).wasm.mjs/g, (s, assetId) => {
                     const fileName = this.getFileName(assetId);
                     const relativePath = path

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "0.0.0-cf-10-20240320162001",
+  "version": "0.0.0-cf-10-solid-20240329084913",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -23,9 +23,6 @@
     "./entrypoints/server.directory.js": "./dist/entrypoints/server.directory.js",
     "./image-service": "./dist/entrypoints/image-service.js",
     "./image-endpoint": "./dist/entrypoints/image-endpoint.js",
-    "./dev-toolbar-app": "./dist/entrypoints/dev-toolbar-app.js",
-    "./dev-toolbar-app/tabs.astro": "./dist/dev-toolbar-app/tabs.astro",
-    "./dev-toolbar-app/test.astro": "./dist/dev-toolbar-app/test.astro",
     "./package.json": "./package.json"
   },
   "files": [
@@ -33,31 +30,30 @@
   ],
   "dependencies": {
     "@astrojs/underscore-redirects": "^0.3.3",
-    "@cloudflare/workers-types": "^4.20240314.0",
-    "dotenv": "^16.4.5",
-    "miniflare": "^3.20240314.0",
+    "@astrojs/internal-helpers": "0.3.0",
+    "@cloudflare/workers-types": "^4.20240320.1",
+    "miniflare": "^3.20240320.0",
+    "esbuild": "^0.19.5",
     "tiny-glob": "^0.2.9",
-    "wrangler": "^3.35.0"
+    "wrangler": "^3.36.0"
   },
   "peerDependencies": {
     "astro": "^4.2.0"
   },
   "devDependencies": {
-    "astro": "^4.5.7",
-    "cheerio": "1.0.0-rc.12",
     "execa": "^8.0.1",
     "fast-glob": "^3.3.2",
     "strip-ansi": "^7.1.0",
-    "rimraf": "^5.0.5",
-    "copyfiles": "^2.4.1",
-    "@astrojs/test-utils": "0.0.1",
-    "astro-scripts": "0.0.14"
+    "astro": "^4.5.8",
+    "cheerio": "1.0.0-rc.12",
+    "astro-scripts": "0.0.14",
+    "@astrojs/test-utils": "0.0.1"
   },
   "publishConfig": {
     "provenance": true
   },
   "scripts": {
-    "build": "tsc && copyfiles -u 1 src/dev-toolbar-app/*.astro dist/",
+    "build": "tsc",
     "test": "astro-scripts test \"test/**/*.test.js\""
   }
 }

package/dist/dev-toolbar-app/tabs.astro

@@ -1,20 +0,0 @@
----
-export const partial = true;
----
-
-<div>
-	<button onclick="fetchHome(this)">Env</button>
-	<button>D1</button>
-</div>
-
-<script is:inline>
-	var fetchHome = function (element) {
-		console.log(element.getRootNode());
-		fetch('/_dev-toolbar-app/cloudflare/home')
-			.then((res) => res.text())
-			.then((html) => {
-				const el = document.createRange().createContextualFragment(html);
-				element.getRootNode().querySelector('#target').replaceChildren(el);
-			});
-	};
-</script>

package/dist/dev-toolbar-app/test.astro

@@ -1,15 +0,0 @@
----
-export const partial = true;
-
-const { env } = Astro.locals.runtime;
----
-
-<pre onclick="me(this)">
-  {JSON.stringify(env, null, 2)}
-</pre>
-
-<script is:inline>
-	var me = function (element) {
-		console.log('me');
-	};
-</script>

package/dist/entrypoints/dev-toolbar-app.d.ts

@@ -1,3 +0,0 @@
-import type { DevToolbarApp } from 'astro';
-declare const plugin: DevToolbarApp;
-export default plugin;

package/dist/entrypoints/dev-toolbar-app.js

@@ -1,36 +0,0 @@
-const plugin = {
-    id: 'cloudflare-app',
-    name: 'Cloudflare DevToolbarApp',
-    icon: '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24"><path fill="currentColor" d="M10.715 14.32H5.442l-.64-1.203L13.673 0l1.397.579-1.752 9.112h5.24l.648 1.192L10.719 24l-1.412-.54ZM4.091 5.448a.579.579 0 1 1 0-1.157.579.579 0 0 1 0 1.157m1.543 0a.579.579 0 1 1 0-1.157.579.579 0 0 1 0 1.157m1.544 0a.579.579 0 1 1 0-1.157.579.579 0 0 1 0 1.157m8.657-2.7h5.424l.772.771v16.975l-.772.772h-7.392l.374-.579h6.779l.432-.432V3.758l-.432-.432h-4.676l-.552 2.85h-.59l.529-2.877.108-.552ZM2.74 21.265l-.772-.772V3.518l.772-.771h7.677l-.386.579H2.98l-.432.432v16.496l.432.432h5.586l-.092.579zm1.157-1.93h3.28l-.116.58h-3.55l-.192-.193v-3.473l.578 1.158zm13.117 0 .579.58H14.7l.385-.58z"/></svg>',
-    init(canvas, eventTarget) {
-        const page = `
-			<script>
-				var loadTabs = function (element) {
-					console.log(this);
-					console.log(element);
-					fetch('/_dev-toolbar-app/cloudflare/tabs')
-						.then((res) => res.text())
-						.then((html) => {
-							const el = document.createRange().createContextualFragment(html);
-							element.getRootNode().querySelector('#tabs').replaceChildren(el);
-						});
-				};
-			</script>
-			<div id="tabs"></div>
-			<div id="target"></div>
-		`;
-        const pageEl = document.createRange().createContextualFragment(page);
-        const cfWindow = document.createElement('astro-dev-toolbar-window');
-        cfWindow.append(pageEl);
-        canvas.appendChild(cfWindow);
-        eventTarget.addEventListener('app-toggled', (event) => {
-            // @ts-ignore
-            if (event.detail.state === true) {
-                console.log('The app is now enabled!');
-                // @ts-ignore
-                loadTabs(cfWindow);
-            }
-        });
-    },
-};
-export default plugin;

package/dist/utils/generate-routes.d.ts

@@ -1,21 +0,0 @@
-import type { AstroConfig, RouteData, RoutePart } from 'astro';
-/**
- * create _routes.json automatically
- * two approaches:
- * include everything and exclude static
- * if 404 is not prerendered, we need to include everything
- * include only ssr paths
- * we want to use as much wildcards as possible
- * assetsURL should be excluded via wildcard
- * _workers.js dir should not be in the routes anyway (cause it is the server bundle)
- * we would work based on routes (endpoint / page)
- * static files should be based on src rather than dist
- * static files should not include cloudflare special files
- * we need forwardslash
- * we need to add the base path
- * redirects from _redirects should be excluded
- */
-export declare const getParts: (part: string) => RoutePart[];
-export default function (_config: AstroConfig, routes: RouteData[], pages: {
-    pathname: string;
-}[], redirects: RoutePart[][][]): Promise<void>;

package/dist/utils/generate-routes.js

@@ -1,199 +0,0 @@
-import { existsSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { posix } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import glob from 'tiny-glob';
-import { removeLeadingForwardSlash, removeTrailingForwardSlash } from './assets.js';
-/**
- * create _routes.json automatically
- * two approaches:
- * include everything and exclude static
- * if 404 is not prerendered, we need to include everything
- * include only ssr paths
- * we want to use as much wildcards as possible
- * assetsURL should be excluded via wildcard
- * _workers.js dir should not be in the routes anyway (cause it is the server bundle)
- * we would work based on routes (endpoint / page)
- * static files should be based on src rather than dist
- * static files should not include cloudflare special files
- * we need forwardslash
- * we need to add the base path
- * redirects from _redirects should be excluded
- */
-export const getParts = (part) => {
-    const result = [];
-    part.split(/\[(.+?\(.+?\)|.+?)\]/).map((str, i) => {
-        if (!str)
-            return;
-        const dynamic = i % 2 === 1;
-        const [, content] = dynamic ? /([^(]+)$/.exec(str) || [null, null] : [null, str];
-        if (!content || (dynamic && !/^(?:\.\.\.)?[\w$]+$/.test(content))) {
-            throw new Error('Parameter name must match /^[a-zA-Z0-9_$]+$/');
-        }
-        result.push({
-            content,
-            dynamic,
-            spread: dynamic && /^\.{3}.+$/.test(content),
-        });
-    });
-    return result;
-};
-const segmentsToCfSyntax = (segments, _config) => {
-    if (segments.length === 0)
-        return ['', ''];
-    const pathSegments = [removeLeadingForwardSlash(removeTrailingForwardSlash(_config.base))];
-    for (const segment of segments.flat()) {
-        if (segment.dynamic)
-            pathSegments.push('*');
-        else
-            pathSegments.push(segment.content);
-    }
-    return pathSegments;
-};
-const deduplicateInPlace = (element, index, paths) => {
-    const regexp = new RegExp(`${element.join('/').replace(/(\*\/)*\*$/g, '[*\\w\\/]+')}$`, 'gm');
-    for (let i = index + 1; i < paths.length; i++) {
-        if (regexp.test(paths[i].join('/'))) {
-            paths.splice(i, 1);
-            i--;
-        }
-    }
-};
-const sort = (first, second) => {
-    // more segements should be sorted first
-    if (second.length > first.length)
-        return -1;
-    if (first.length > second.length)
-        return 1;
-    // equal amount of segments, sort by specifity
-    for (let i = 0; i < first.length; i++) {
-        // if segment is equal, continue with next segment
-        if (first[i] === second[i])
-            continue;
-        // wildcard segments should be sorted last
-        if (first[i] === '*' && second[i] !== '*')
-            return -1;
-        if (first[i] !== '*' && second[i] === '*')
-            return 1;
-    }
-    return 0;
-};
-export default async function (_config, routes, pages, redirects) {
-    const includePaths = [];
-    const excludePaths = [];
-    let hasPrerendered404 = false;
-    for (const route of routes) {
-        const convertedPath = segmentsToCfSyntax(route.segments, _config);
-        if (route.pathname === '/404' && route.prerender === true)
-            hasPrerendered404 = true;
-        if (route.type === 'page')
-            if (route.prerender === false)
-                includePaths.push(convertedPath);
-        if (route.type === 'endpoint')
-            if (route.prerender === false)
-                includePaths.push(convertedPath);
-            else
-                excludePaths.push(convertedPath);
-        if (route.type === 'redirect')
-            excludePaths.push(convertedPath);
-    }
-    for (const page of pages) {
-        const pageSegments = removeLeadingForwardSlash(page.pathname)
-            .split(posix.sep)
-            .filter(Boolean)
-            .map((s) => {
-            return getParts(s);
-        });
-        excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
-    }
-    if (existsSync(fileURLToPath(_config.publicDir))) {
-        const staticFiles = await glob(`${fileURLToPath(_config.publicDir)}/**/*`, {
-            cwd: fileURLToPath(_config.publicDir),
-            filesOnly: true,
-            dot: true,
-        });
-        for (const staticFile of staticFiles) {
-            if (['_headers', '_redirects', '_routes.json'].includes(staticFile))
-                continue;
-            const staticPath = staticFile;
-            const segments = removeLeadingForwardSlash(staticPath)
-                .split(posix.sep)
-                .filter(Boolean)
-                .map((s) => {
-                return getParts(s);
-            });
-            excludePaths.push(segmentsToCfSyntax(segments, _config));
-        }
-    }
-    const assetsPath = segmentsToCfSyntax([
-        [{ content: _config.build.assets, dynamic: false, spread: false }],
-        [{ content: '', dynamic: true, spread: false }],
-    ], _config);
-    excludePaths.push(assetsPath);
-    const pagefindPath = segmentsToCfSyntax([
-        [{ content: 'pagefind', dynamic: false, spread: false }],
-        [{ content: '', dynamic: true, spread: false }],
-    ], _config);
-    excludePaths.push(pagefindPath);
-    for (const redirect of redirects) {
-        excludePaths.push(segmentsToCfSyntax(redirect, _config));
-    }
-    includePaths.sort(sort);
-    excludePaths.sort(sort);
-    console.log(includePaths);
-    console.log('---');
-    console.log(excludePaths);
-    for (const [index, element] of includePaths.entries()) {
-        deduplicateInPlace(element, index, includePaths);
-    }
-    for (const [index, element] of excludePaths.entries()) {
-        console.log(element);
-        deduplicateInPlace(element, index, excludePaths);
-    }
-    console.log('------');
-    console.log(includePaths);
-    console.log('---');
-    console.log(excludePaths);
-    console.log('------');
-    console.log('INCLUDE', includePaths.length);
-    console.log('---');
-    console.log('EXCLUDE', excludePaths.length);
-    if (!hasPrerendered404 ||
-        includePaths.length > 100 ||
-        includePaths.length > excludePaths.length) {
-        try {
-            await writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                version: 1,
-                include: ['/*'],
-                exclude: excludePaths.map((path) => path.join('/')).slice(0, 99),
-            }, null, 2), 'utf-8');
-        }
-        catch (error) {
-            // TODO
-        }
-    }
-    else if (includePaths.length < excludePaths.length) {
-        try {
-            await writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                version: 1,
-                include: includePaths.map((path) => path.join('/')),
-                exclude: [],
-            }, null, 2), 'utf-8');
-        }
-        catch (error) {
-            // TODO
-        }
-    }
-    else {
-        try {
-            await writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                version: 1,
-                include: ['/*'],
-                exclude: excludePaths.map((path) => path.join('/')).slice(0, 99),
-            }, null, 2), 'utf-8');
-        }
-        catch (error) {
-            // TODO
-        }
-    }
-}

package/dist/utils/index.d.ts

@@ -1,2 +0,0 @@
-export declare const isNode: boolean;
-export declare function getProcessEnvProxy(): {};

package/dist/utils/index.js

@@ -1,10 +0,0 @@
-export const isNode = typeof process === 'object' && Object.prototype.toString.call(process) === '[object process]';
-export function getProcessEnvProxy() {
-    return new Proxy({}, {
-        get: (target, prop) => {
-            console.warn(
-            // NOTE: \0 prevents Vite replacement
-            `Unable to access \`import.meta\0.env.${prop.toString()}\` on initialization as the Cloudflare platform only provides the environment variables per request. Please move the environment variable access inside a function that's only called after a request has been received.`);
-        },
-    });
-}