@astrojs/cloudflare 12.2.1 → 12.2.2

package/dist/index.js

@@ -1,248 +1,264 @@
-import { createReadStream } from 'node:fs';
-import { appendFile, rename, stat } 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 { defaultClientConditions } from 'vite';
-import { getPlatformProxy } from 'wrangler';
-import { cloudflareModuleLoader, } from './utils/cloudflare-module-loader.js';
-import { createGetEnv } from './utils/env.js';
-import { createRoutesFile, getParts } from './utils/generate-routes-json.js';
-import { setImageConfig } from './utils/image-config.js';
+import { createReadStream } from "node:fs";
+import { appendFile, rename, stat } 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 { defaultClientConditions } from "vite";
+import { getPlatformProxy } from "wrangler";
+import {
+  cloudflareModuleLoader
+} from "./utils/cloudflare-module-loader.js";
+import { createGetEnv } from "./utils/env.js";
+import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
+import { setImageConfig } from "./utils/image-config.js";
 function wrapWithSlashes(path) {
-    return prependForwardSlash(appendForwardSlash(path));
+  return prependForwardSlash(appendForwardSlash(path));
 }
 function setProcessEnv(config, env) {
-    const getEnv = createGetEnv(env);
-    if (config.env?.schema) {
-        for (const key of Object.keys(config.env.schema)) {
-            const value = getEnv(key);
-            if (value !== undefined) {
-                process.env[key] = value;
-            }
-        }
+  const getEnv = createGetEnv(env);
+  if (config.env?.schema) {
+    for (const key of Object.keys(config.env.schema)) {
+      const value = getEnv(key);
+      if (value !== void 0) {
+        process.env[key] = value;
+      }
     }
+  }
 }
-export default function createIntegration(args) {
-    let _config;
-    let finalBuildOutput;
-    const cloudflareModulePlugin = cloudflareModuleLoader(args?.cloudflareModules ?? true);
-    let _routes;
-    return {
-        name: '@astrojs/cloudflare',
-        hooks: {
-            'astro:config:setup': ({ command, config, updateConfig, logger, addWatchFile, addMiddleware, }) => {
-                updateConfig({
-                    build: {
-                        client: new URL(`.${wrapWithSlashes(config.base)}`, config.outDir),
-                        server: new URL('./_worker.js/', config.outDir),
-                        serverEntry: 'index.js',
-                        redirects: false,
-                    },
-                    vite: {
-                        plugins: [
-                            // https://developers.cloudflare.com/pages/functions/module-support/
-                            // Allows imports of '.wasm', '.bin', and '.txt' file types
-                            cloudflareModulePlugin,
-                            {
-                                name: 'vite:cf-imports',
-                                enforce: 'pre',
-                                resolveId(source) {
-                                    if (source.startsWith('cloudflare:')) {
-                                        return { id: source, external: true };
-                                    }
-                                    return null;
-                                },
-                            },
-                        ],
-                    },
-                    image: setImageConfig(args?.imageService ?? 'compile', config.image, command, logger),
-                });
-                if (args?.platformProxy?.configPath) {
-                    addWatchFile(new URL(args.platformProxy.configPath, config.root));
-                }
-                else {
-                    addWatchFile(new URL('./wrangler.toml', config.root));
-                    addWatchFile(new URL('./wrangler.json', config.root));
-                    addWatchFile(new URL('./wrangler.jsonc', config.root));
-                }
-                addMiddleware({
-                    entrypoint: '@astrojs/cloudflare/entrypoints/middleware.js',
-                    order: 'pre',
-                });
-            },
-            'astro:routes:resolved': ({ routes }) => {
-                _routes = routes;
-            },
-            'astro:config:done': ({ setAdapter, config, buildOutput, logger }) => {
-                if (buildOutput === 'static') {
-                    logger.warn('[@astrojs/cloudflare] This adapter is intended to be used with server rendered pages, which this project does not contain any of. As such, this adapter is unnecessary.');
-                }
-                _config = config;
-                finalBuildOutput = buildOutput;
-                setAdapter({
-                    name: '@astrojs/cloudflare',
-                    serverEntrypoint: '@astrojs/cloudflare/entrypoints/server.js',
-                    exports: ['default'],
-                    adapterFeatures: {
-                        edgeMiddleware: false,
-                        buildOutput: 'server',
-                    },
-                    supportedAstroFeatures: {
-                        serverOutput: 'stable',
-                        hybridOutput: 'stable',
-                        staticOutput: 'unsupported',
-                        i18nDomains: 'experimental',
-                        sharpImageService: {
-                            support: 'limited',
-                            message: 'Cloudflare does not support sharp. You can use the `compile` image service to compile images at build time. It will not work for any on-demand rendered images.',
-                        },
-                        envGetSecret: 'stable',
-                    },
-                });
-            },
-            'astro:server:setup': async ({ server }) => {
-                if ((args?.platformProxy?.enabled ?? true) === true) {
-                    const platformProxy = await getPlatformProxy(args?.platformProxy);
-                    setProcessEnv(_config, platformProxy.env);
-                    const clientLocalsSymbol = Symbol.for('astro.locals');
-                    server.middlewares.use(async function middleware(req, res, next) {
-                        Reflect.set(req, clientLocalsSymbol, {
-                            runtime: {
-                                env: platformProxy.env,
-                                cf: platformProxy.cf,
-                                caches: platformProxy.caches,
-                                ctx: {
-                                    waitUntil: (promise) => platformProxy.ctx.waitUntil(promise),
-                                    // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
-                                    passThroughOnException: () => {
-                                        throw new AstroError('`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions.');
-                                    },
-                                },
-                            },
-                        });
-                        next();
-                    });
-                }
-            },
-            'astro:build:setup': ({ vite, target }) => {
-                if (target === 'server') {
-                    vite.resolve ||= {};
-                    vite.resolve.alias ||= {};
-                    const aliases = [
-                        {
-                            find: 'react-dom/server',
-                            replacement: 'react-dom/server.browser',
-                        },
-                    ];
-                    if (Array.isArray(vite.resolve.alias)) {
-                        vite.resolve.alias = [...vite.resolve.alias, ...aliases];
-                    }
-                    else {
-                        for (const alias of aliases) {
-                            vite.resolve.alias[alias.find] = alias.replacement;
-                        }
-                    }
-                    // Support `workerd` and `worker` conditions for the ssr environment
-                    // (previously supported in esbuild instead: https://github.com/withastro/astro/pull/7092)
-                    vite.ssr ||= {};
-                    vite.ssr.resolve ||= {};
-                    vite.ssr.resolve.conditions ||= [...defaultClientConditions];
-                    vite.ssr.resolve.conditions.push('workerd', 'worker');
-                    vite.ssr.target = 'webworker';
-                    vite.ssr.noExternal = true;
-                    vite.build ||= {};
-                    vite.build.rollupOptions ||= {};
-                    vite.build.rollupOptions.output ||= {};
-                    // @ts-expect-error
-                    vite.build.rollupOptions.output.banner ||=
-                        'globalThis.process ??= {}; globalThis.process.env ??= {};';
-                    // 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,
-                    };
+function createIntegration(args) {
+  let _config;
+  let finalBuildOutput;
+  const cloudflareModulePlugin = cloudflareModuleLoader(
+    args?.cloudflareModules ?? true
+  );
+  let _routes;
+  return {
+    name: "@astrojs/cloudflare",
+    hooks: {
+      "astro:config:setup": ({
+        command,
+        config,
+        updateConfig,
+        logger,
+        addWatchFile,
+        addMiddleware
+      }) => {
+        updateConfig({
+          build: {
+            client: new URL(`.${wrapWithSlashes(config.base)}`, config.outDir),
+            server: new URL("./_worker.js/", config.outDir),
+            serverEntry: "index.js",
+            redirects: false
+          },
+          vite: {
+            plugins: [
+              // https://developers.cloudflare.com/pages/functions/module-support/
+              // Allows imports of '.wasm', '.bin', and '.txt' file types
+              cloudflareModulePlugin,
+              {
+                name: "vite:cf-imports",
+                enforce: "pre",
+                resolveId(source) {
+                  if (source.startsWith("cloudflare:")) {
+                    return { id: source, external: true };
+                  }
+                  return null;
                 }
+              }
+            ]
+          },
+          image: setImageConfig(args?.imageService ?? "compile", config.image, command, logger)
+        });
+        if (args?.platformProxy?.configPath) {
+          addWatchFile(new URL(args.platformProxy.configPath, config.root));
+        } else {
+          addWatchFile(new URL("./wrangler.toml", config.root));
+          addWatchFile(new URL("./wrangler.json", config.root));
+          addWatchFile(new URL("./wrangler.jsonc", config.root));
+        }
+        addMiddleware({
+          entrypoint: "@astrojs/cloudflare/entrypoints/middleware.js",
+          order: "pre"
+        });
+      },
+      "astro:routes:resolved": ({ routes }) => {
+        _routes = routes;
+      },
+      "astro:config:done": ({ setAdapter, config, buildOutput, logger }) => {
+        if (buildOutput === "static") {
+          logger.warn(
+            "[@astrojs/cloudflare] This adapter is intended to be used with server rendered pages, which this project does not contain any of. As such, this adapter is unnecessary."
+          );
+        }
+        _config = config;
+        finalBuildOutput = buildOutput;
+        setAdapter({
+          name: "@astrojs/cloudflare",
+          serverEntrypoint: "@astrojs/cloudflare/entrypoints/server.js",
+          exports: ["default"],
+          adapterFeatures: {
+            edgeMiddleware: false,
+            buildOutput: "server"
+          },
+          supportedAstroFeatures: {
+            serverOutput: "stable",
+            hybridOutput: "stable",
+            staticOutput: "unsupported",
+            i18nDomains: "experimental",
+            sharpImageService: {
+              support: "limited",
+              message: "Cloudflare does not support sharp. You can use the `compile` image service to compile images at build time. It will not work for any on-demand rendered images."
             },
-            'astro:build:done': async ({ pages, dir, logger, assets }) => {
-                await cloudflareModulePlugin.afterBuildCompleted(_config);
-                const PLATFORM_FILES = ['_headers', '_redirects', '_routes.json'];
-                if (_config.base !== '/') {
-                    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.`);
-                        }
-                    }
-                }
-                let redirectsExists = false;
-                try {
-                    const redirectsStat = await stat(new URL('./_redirects', _config.outDir));
-                    if (redirectsStat.isFile()) {
-                        redirectsExists = true;
-                    }
-                }
-                catch (error) {
-                    redirectsExists = false;
-                }
-                const redirects = [];
-                if (redirectsExists) {
-                    const rl = createInterface({
-                        input: createReadStream(new URL('./_redirects', _config.outDir)),
-                        crlfDelay: Number.POSITIVE_INFINITY,
-                    });
-                    for await (const line of rl) {
-                        const parts = line.split(' ');
-                        if (parts.length >= 2) {
-                            const p = removeLeadingForwardSlash(parts[0])
-                                .split('/')
-                                .filter(Boolean)
-                                .map((s) => {
-                                const syntax = s
-                                    .replace(/\/:.*?(?=\/|$)/g, '/*')
-                                    // remove query params as they are not supported by cloudflare
-                                    .replace(/\?.*$/, '');
-                                return getParts(syntax);
-                            });
-                            redirects.push(p);
-                        }
-                    }
-                }
-                let routesExists = false;
-                try {
-                    const routesStat = await stat(new URL('./_routes.json', _config.outDir));
-                    if (routesStat.isFile()) {
-                        routesExists = true;
-                    }
-                }
-                catch (error) {
-                    routesExists = false;
+            envGetSecret: "stable"
+          }
+        });
+      },
+      "astro:server:setup": async ({ server }) => {
+        if ((args?.platformProxy?.enabled ?? true) === true) {
+          const platformProxy = await getPlatformProxy(args?.platformProxy);
+          setProcessEnv(_config, platformProxy.env);
+          const clientLocalsSymbol = Symbol.for("astro.locals");
+          server.middlewares.use(async function middleware(req, _res, next) {
+            Reflect.set(req, clientLocalsSymbol, {
+              runtime: {
+                env: platformProxy.env,
+                cf: platformProxy.cf,
+                caches: platformProxy.caches,
+                ctx: {
+                  waitUntil: (promise) => platformProxy.ctx.waitUntil(promise),
+                  // Currently not available: https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions
+                  passThroughOnException: () => {
+                    throw new AstroError(
+                      "`passThroughOnException` is currently not available in Cloudflare Pages. See https://developers.cloudflare.com/pages/platform/known-issues/#pages-functions."
+                    );
+                  }
                 }
-                if (!routesExists) {
-                    await createRoutesFile(_config, logger, _routes, pages, redirects, args?.routes?.extend?.include, args?.routes?.extend?.exclude);
-                }
-                const trueRedirects = createRedirectsFromAstroRoutes({
-                    config: _config,
-                    routeToDynamicTargetMap: new Map(Array.from(_routes
-                        .filter((route) => route.type === 'redirect')
-                        .map((route) => [route, '']))),
-                    dir,
-                    buildOutput: finalBuildOutput,
-                    assets,
-                });
-                if (!trueRedirects.empty()) {
-                    try {
-                        await appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
-                    }
-                    catch (error) {
-                        logger.error('Failed to write _redirects file');
-                    }
-                }
-            },
-        },
-    };
+              }
+            });
+            next();
+          });
+        }
+      },
+      "astro:build:setup": ({ vite, target }) => {
+        if (target === "server") {
+          vite.resolve ||= {};
+          vite.resolve.alias ||= {};
+          const aliases = [
+            {
+              find: "react-dom/server",
+              replacement: "react-dom/server.browser"
+            }
+          ];
+          if (Array.isArray(vite.resolve.alias)) {
+            vite.resolve.alias = [...vite.resolve.alias, ...aliases];
+          } else {
+            for (const alias of aliases) {
+              vite.resolve.alias[alias.find] = alias.replacement;
+            }
+          }
+          vite.ssr ||= {};
+          vite.ssr.resolve ||= {};
+          vite.ssr.resolve.conditions ||= [...defaultClientConditions];
+          vite.ssr.resolve.conditions.push("workerd", "worker");
+          vite.ssr.target = "webworker";
+          vite.ssr.noExternal = true;
+          vite.build ||= {};
+          vite.build.rollupOptions ||= {};
+          vite.build.rollupOptions.output ||= {};
+          vite.build.rollupOptions.output.banner ||= "globalThis.process ??= {}; globalThis.process.env ??= {};";
+          vite.define = {
+            "process.env": "process.env",
+            ...vite.define
+          };
+        }
+      },
+      "astro:build:done": async ({ pages, dir, logger, assets }) => {
+        await cloudflareModulePlugin.afterBuildCompleted(_config);
+        const PLATFORM_FILES = ["_headers", "_redirects", "_routes.json"];
+        if (_config.base !== "/") {
+          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.`
+              );
+            }
+          }
+        }
+        let redirectsExists = false;
+        try {
+          const redirectsStat = await stat(new URL("./_redirects", _config.outDir));
+          if (redirectsStat.isFile()) {
+            redirectsExists = true;
+          }
+        } catch (_error) {
+          redirectsExists = false;
+        }
+        const redirects = [];
+        if (redirectsExists) {
+          const rl = createInterface({
+            input: createReadStream(new URL("./_redirects", _config.outDir)),
+            crlfDelay: Number.POSITIVE_INFINITY
+          });
+          for await (const line of rl) {
+            const parts = line.split(" ");
+            if (parts.length >= 2) {
+              const p = removeLeadingForwardSlash(parts[0]).split("/").filter(Boolean).map((s) => {
+                const syntax = s.replace(/\/:.*?(?=\/|$)/g, "/*").replace(/\?.*$/, "");
+                return getParts(syntax);
+              });
+              redirects.push(p);
+            }
+          }
+        }
+        let routesExists = false;
+        try {
+          const routesStat = await stat(new URL("./_routes.json", _config.outDir));
+          if (routesStat.isFile()) {
+            routesExists = true;
+          }
+        } catch (_error) {
+          routesExists = false;
+        }
+        if (!routesExists) {
+          await createRoutesFile(
+            _config,
+            logger,
+            _routes,
+            pages,
+            redirects,
+            args?.routes?.extend?.include,
+            args?.routes?.extend?.exclude
+          );
+        }
+        const trueRedirects = createRedirectsFromAstroRoutes({
+          config: _config,
+          routeToDynamicTargetMap: new Map(
+            Array.from(
+              _routes.filter((route) => route.type === "redirect").map((route) => [route, ""])
+            )
+          ),
+          dir,
+          buildOutput: finalBuildOutput,
+          assets
+        });
+        if (!trueRedirects.empty()) {
+          try {
+            await appendFile(new URL("./_redirects", _config.outDir), trueRedirects.print());
+          } catch (_error) {
+            logger.error("Failed to write _redirects file");
+          }
+        }
+      }
+    }
+  };
 }
+export {
+  createIntegration as default
+};

package/dist/utils/assets.js

@@ -1,68 +1,70 @@
-import { isRemotePath } from '@astrojs/internal-helpers/path';
-export function isESMImportedImage(src) {
-    return typeof src === 'object';
+import { isRemotePath } from "@astrojs/internal-helpers/path";
+function isESMImportedImage(src) {
+  return typeof src === "object";
 }
-export function matchHostname(url, hostname, allowWildcard) {
-    if (!hostname) {
-        return true;
-    }
-    if (!allowWildcard || !hostname.startsWith('*')) {
-        return hostname === url.hostname;
-    }
-    if (hostname.startsWith('**.')) {
-        const slicedHostname = hostname.slice(2); // ** length
-        return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
-    }
-    if (hostname.startsWith('*.')) {
-        const slicedHostname = hostname.slice(1); // * length
-        const additionalSubdomains = url.hostname
-            .replace(slicedHostname, '')
-            .split('.')
-            .filter(Boolean);
-        return additionalSubdomains.length === 1;
-    }
-    return false;
+function matchHostname(url, hostname, allowWildcard) {
+  if (!hostname) {
+    return true;
+  }
+  if (!allowWildcard || !hostname.startsWith("*")) {
+    return hostname === url.hostname;
+  }
+  if (hostname.startsWith("**.")) {
+    const slicedHostname = hostname.slice(2);
+    return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
+  }
+  if (hostname.startsWith("*.")) {
+    const slicedHostname = hostname.slice(1);
+    const additionalSubdomains = url.hostname.replace(slicedHostname, "").split(".").filter(Boolean);
+    return additionalSubdomains.length === 1;
+  }
+  return false;
 }
-export function matchPort(url, port) {
-    return !port || port === url.port;
+function matchPort(url, port) {
+  return !port || port === url.port;
 }
-export function matchProtocol(url, protocol) {
-    return !protocol || protocol === url.protocol.slice(0, -1);
+function matchProtocol(url, protocol) {
+  return !protocol || protocol === url.protocol.slice(0, -1);
 }
-export function matchPathname(url, pathname, allowWildcard) {
-    if (!pathname) {
-        return true;
-    }
-    if (!allowWildcard || !pathname.endsWith('*')) {
-        return pathname === url.pathname;
-    }
-    if (pathname.endsWith('/**')) {
-        const slicedPathname = pathname.slice(0, -2); // ** length
-        return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
-    }
-    if (pathname.endsWith('/*')) {
-        const slicedPathname = pathname.slice(0, -1); // * length
-        const additionalPathChunks = url.pathname
-            .replace(slicedPathname, '')
-            .split('/')
-            .filter(Boolean);
-        return additionalPathChunks.length === 1;
-    }
-    return false;
+function matchPathname(url, pathname, allowWildcard) {
+  if (!pathname) {
+    return true;
+  }
+  if (!allowWildcard || !pathname.endsWith("*")) {
+    return pathname === url.pathname;
+  }
+  if (pathname.endsWith("/**")) {
+    const slicedPathname = pathname.slice(0, -2);
+    return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
+  }
+  if (pathname.endsWith("/*")) {
+    const slicedPathname = pathname.slice(0, -1);
+    const additionalPathChunks = url.pathname.replace(slicedPathname, "").split("/").filter(Boolean);
+    return additionalPathChunks.length === 1;
+  }
+  return false;
 }
-export function matchPattern(url, remotePattern) {
-    return (matchProtocol(url, remotePattern.protocol) &&
-        matchHostname(url, remotePattern.hostname, true) &&
-        matchPort(url, remotePattern.port) &&
-        matchPathname(url, remotePattern.pathname, true));
+function matchPattern(url, remotePattern) {
+  return matchProtocol(url, remotePattern.protocol) && matchHostname(url, remotePattern.hostname, true) && matchPort(url, remotePattern.port) && matchPathname(url, remotePattern.pathname, true);
 }
-export function isRemoteAllowed(src, { domains = [], remotePatterns = [], }) {
-    if (!isRemotePath(src))
-        return false;
-    const url = new URL(src);
-    return (domains.some((domain) => matchHostname(url, domain)) ||
-        remotePatterns.some((remotePattern) => matchPattern(url, remotePattern)));
+function isRemoteAllowed(src, {
+  domains = [],
+  remotePatterns = []
+}) {
+  if (!isRemotePath(src)) return false;
+  const url = new URL(src);
+  return domains.some((domain) => matchHostname(url, domain)) || remotePatterns.some((remotePattern) => matchPattern(url, remotePattern));
 }
-export function isString(path) {
-    return typeof path === 'string' || path instanceof String;
+function isString(path) {
+  return typeof path === "string" || path instanceof String;
 }
+export {
+  isESMImportedImage,
+  isRemoteAllowed,
+  isString,
+  matchHostname,
+  matchPathname,
+  matchPattern,
+  matchPort,
+  matchProtocol
+};