@astrojs/cloudflare 7.6.4 → 7.7.1

package/README.md

@@ -161,6 +161,15 @@ The following example automatically generates `_routes.json` while including and
   });
 ```
 
+### `imageService`
+
+`imageService: "passthrough" | "cloudflare"`
+
+Determines which image service is used by the adapter. The adapter will default to `passthrough` mode when an incompatible image service is configured. Otherwise, it will use the globally configured image service:
+
+- **`cloudflare`:** Uses the [Cloudflare Image Resizing](https://developers.cloudflare.com/images/image-resizing/) service.
+- **`passthrough`:** Uses the existing [`noop`](https://docs.astro.build/en/guides/images/#configure-no-op-passthrough-service) service.
+
 ### `wasmModuleImports`
 
 `wasmModuleImports: boolean`

package/dist/entrypoints/image-service.d.ts

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

package/dist/entrypoints/image-service.js

@@ -0,0 +1,34 @@
+import { baseService } from 'astro/assets';
+import { isESMImportedImage, isRemoteAllowed, joinPaths } from '../utils/assets.js';
+const service = {
+    ...baseService,
+    getURL: (options, imageConfig) => {
+        const resizingParams = [];
+        if (options.width)
+            resizingParams.push(`width=${options.width}`);
+        if (options.height)
+            resizingParams.push(`height=${options.height}`);
+        if (options.quality)
+            resizingParams.push(`quality=${options.quality}`);
+        if (options.fit)
+            resizingParams.push(`fit=${options.fit}`);
+        if (options.format)
+            resizingParams.push(`format=${options.format}`);
+        let imageSource = '';
+        if (isESMImportedImage(options.src)) {
+            imageSource = options.src.src;
+        }
+        else if (isRemoteAllowed(options.src, imageConfig)) {
+            imageSource = options.src;
+        }
+        else {
+            // If it's not an imported image, nor is it allowed using the current domains or remote patterns, we'll just return the original URL
+            return options.src;
+        }
+        const imageEndpoint = joinPaths(
+        // @ts-expect-error - Property 'env' does not exist on type 'ImportMeta'.ts(2339)
+        import.meta.env.BASE_URL, '/cdn-cgi/image', resizingParams.join(','), imageSource);
+        return imageEndpoint;
+    },
+};
+export default service;

package/dist/entrypoints/server.advanced.js

@@ -14,31 +14,25 @@ export function createExports(manifest) {
         if (manifest.assets.has(pathname)) {
             return env.ASSETS.fetch(request);
         }
-        let routeData = app.match(request, { matchNotFound: true });
-        if (routeData) {
-            Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
-            const locals = {
-                runtime: {
-                    waitUntil: (promise) => {
-                        context.waitUntil(promise);
-                    },
-                    env: env,
-                    cf: request.cf,
-                    caches: caches,
+        let routeData = app.match(request);
+        Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
+        const locals = {
+            runtime: {
+                waitUntil: (promise) => {
+                    context.waitUntil(promise);
                 },
-            };
-            let response = await app.render(request, routeData, locals);
-            if (app.setCookieHeaders) {
-                for (const setCookieHeader of app.setCookieHeaders(response)) {
-                    response.headers.append('Set-Cookie', setCookieHeader);
-                }
+                env: env,
+                cf: request.cf,
+                caches: caches,
+            },
+        };
+        let response = await app.render(request, routeData, locals);
+        if (app.setCookieHeaders) {
+            for (const setCookieHeader of app.setCookieHeaders(response)) {
+                response.headers.append('Set-Cookie', setCookieHeader);
             }
-            return response;
         }
-        return new Response(null, {
-            status: 404,
-            statusText: 'Not found',
-        });
+        return response;
     };
     return { default: { fetch } };
 }

package/dist/entrypoints/server.directory.js

@@ -16,31 +16,25 @@ export function createExports(manifest) {
         if (manifest.assets.has(pathname)) {
             return env.ASSETS.fetch(request);
         }
-        let routeData = app.match(request, { matchNotFound: true });
-        if (routeData) {
-            Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
-            const locals = {
-                runtime: {
-                    waitUntil: (promise) => {
-                        context.waitUntil(promise);
-                    },
-                    env: context.env,
-                    cf: request.cf,
-                    caches: caches,
+        let routeData = app.match(request);
+        Reflect.set(request, Symbol.for('astro.clientAddress'), request.headers.get('cf-connecting-ip'));
+        const locals = {
+            runtime: {
+                waitUntil: (promise) => {
+                    context.waitUntil(promise);
                 },
-            };
-            let response = await app.render(request, routeData, locals);
-            if (app.setCookieHeaders) {
-                for (const setCookieHeader of app.setCookieHeaders(response)) {
-                    response.headers.append('Set-Cookie', setCookieHeader);
-                }
+                env: context.env,
+                cf: request.cf,
+                caches: caches,
+            },
+        };
+        let response = await app.render(request, routeData, locals);
+        if (app.setCookieHeaders) {
+            for (const setCookieHeader of app.setCookieHeaders(response)) {
+                response.headers.append('Set-Cookie', setCookieHeader);
             }
-            return response;
         }
-        return new Response(null, {
-            status: 404,
-            statusText: 'Not found',
-        });
+        return response;
     };
     return { onRequest, manifest };
 }

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export type { DirectoryRuntime } from './entrypoints/server.directory.js';
 type Options = {
     mode?: 'directory' | 'advanced';
     functionPerRoute?: boolean;
+    imageService?: 'passthrough' | 'cloudflare';
     /** Configure automatic `routes.json` generation */
     routes?: {
         /** Strategy for generating `include` and `exclude` patterns

package/dist/index.js

@@ -1,5 +1,4 @@
 import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
-import { passthroughImageService } from 'astro/config';
 import { AstroError } from 'astro/errors';
 import esbuild from 'esbuild';
 import { Miniflare } from 'miniflare';
@@ -11,6 +10,7 @@ import glob from 'tiny-glob';
 import { getAdapter } from './getAdapter.js';
 import { deduplicatePatterns } from './utils/deduplicatePatterns.js';
 import { getCFObject } from './utils/getCFObject.js';
+import { prepareImageConfig } from './utils/image-config.js';
 import { getD1Bindings, getDOBindings, getEnvVars, getKVBindings, getR2Bindings, } from './utils/parser.js';
 import { prependForwardSlash } from './utils/prependForwardSlash.js';
 import { rewriteWasmImportPath } from './utils/rewriteWasmImportPath.js';
@@ -48,13 +48,7 @@ export default function createIntegration(args) {
     return {
         name: '@astrojs/cloudflare',
         hooks: {
-            'astro:config:setup': ({ config, updateConfig, logger }) => {
-                let imageConfigOverwrite = false;
-                if (config.image.service.entrypoint === 'astro/assets/services/sharp' ||
-                    config.image.service.entrypoint === 'astro/assets/services/squoosh') {
-                    logger.warn(`The current configuration does not support image optimization. To allow your project to build with the original, unoptimized images, the image service has been automatically switched to the 'noop' option. See https://docs.astro.build/en/reference/configuration-reference/#imageservice`);
-                    imageConfigOverwrite = true;
-                }
+            'astro:config:setup': ({ command, config, updateConfig, logger }) => {
                 updateConfig({
                     build: {
                         client: new URL(`.${config.base}`, config.outDir),
@@ -71,9 +65,7 @@ export default function createIntegration(args) {
                             }),
                         ],
                     },
-                    image: imageConfigOverwrite
-                        ? { ...config.image, service: passthroughImageService() }
-                        : config.image,
+                    image: prepareImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
                 });
             },
             'astro:config:done': ({ setAdapter, config, logger }) => {
@@ -398,11 +390,14 @@ export default function createIntegration(args) {
                     /**
                      * These route types are candiates for being part of the `_routes.json` `include` array.
                      */
+                    let notFoundIsSSR = false;
                     const potentialFunctionRouteTypes = ['endpoint', 'page'];
                     const functionEndpoints = routes
                         // Certain route types, when their prerender option is set to false, run on the server as function invocations
                         .filter((route) => potentialFunctionRouteTypes.includes(route.type) && !route.prerender)
                         .map((route) => {
+                        if (route.component === 'src/pages/404.astro' && route.prerender === false)
+                            notFoundIsSSR = true;
                         const includePattern = '/' +
                             route.segments
                                 .flat()
@@ -507,7 +502,11 @@ export default function createIntegration(args) {
                     const excludeStrategyLength = excludeStrategy
                         ? excludeStrategy.include.length + excludeStrategy.exclude.length
                         : Infinity;
-                    const winningStrategy = includeStrategyLength <= excludeStrategyLength ? includeStrategy : excludeStrategy;
+                    const winningStrategy = notFoundIsSSR
+                        ? excludeStrategy
+                        : includeStrategyLength <= excludeStrategyLength
+                            ? includeStrategy
+                            : excludeStrategy;
                     await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
                         version: 1,
                         ...winningStrategy,

package/dist/utils/assets.d.ts

@@ -0,0 +1,14 @@
+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;
+export declare function matchPathname(url: URL, pathname?: string, allowWildcard?: boolean): boolean;
+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

@@ -0,0 +1,95 @@
+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;
+    }
+    else if (!allowWildcard || !hostname.startsWith('*')) {
+        return hostname === url.hostname;
+    }
+    else if (hostname.startsWith('**.')) {
+        const slicedHostname = hostname.slice(2); // ** length
+        return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
+    }
+    else if (hostname.startsWith('*.')) {
+        const slicedHostname = hostname.slice(1); // * length
+        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;
+}
+export function matchProtocol(url, protocol) {
+    return !protocol || protocol === url.protocol.slice(0, -1);
+}
+export function matchPathname(url, pathname, allowWildcard) {
+    if (!pathname) {
+        return true;
+    }
+    else if (!allowWildcard || !pathname.endsWith('*')) {
+        return pathname === url.pathname;
+    }
+    else if (pathname.endsWith('/**')) {
+        const slicedPathname = pathname.slice(0, -2); // ** length
+        return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
+    }
+    else 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;
+}
+export 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)));
+}
+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);
+        }
+        else if (i === paths.length - 1) {
+            return removeLeadingForwardSlash(path);
+        }
+        else {
+            return trimSlashes(path);
+        }
+    })
+        .join('/');
+}

package/dist/utils/image-config.d.ts

@@ -0,0 +1,12 @@
+import type { AstroConfig, AstroIntegrationLogger } from 'astro';
+export declare function prepareImageConfig(service: string, config: AstroConfig['image'], command: 'dev' | 'build' | 'preview', logger: AstroIntegrationLogger): {
+    service: import("astro").ImageServiceConfig<Record<string, any>>;
+    domains: string[];
+    remotePatterns: {
+        protocol?: string | undefined;
+        hostname?: string | undefined;
+        port?: string | undefined;
+        pathname?: string | undefined;
+    }[];
+    endpoint?: string | undefined;
+};

package/dist/utils/image-config.js

@@ -0,0 +1,21 @@
+import { passthroughImageService, sharpImageService } from 'astro/config';
+export function prepareImageConfig(service, config, command, logger) {
+    switch (service) {
+        case 'passthrough':
+            return { ...config, service: passthroughImageService() };
+        case 'cloudflare':
+            return {
+                ...config,
+                service: command === 'dev'
+                    ? sharpImageService()
+                    : { entrypoint: '@astrojs/cloudflare/image-service' },
+            };
+        default:
+            if (config.service.entrypoint === 'astro/assets/services/sharp' ||
+                config.service.entrypoint === 'astro/assets/services/squoosh') {
+                logger.warn(`The current configuration does not support image optimization. To allow your project to build with the original, unoptimized images, the image service has been automatically switched to the 'noop' option. See https://docs.astro.build/en/reference/configuration-reference/#imageservice`);
+                return { ...config, service: passthroughImageService() };
+            }
+            return { ...config };
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "//comment": "test changeset-bot",
   "name": "@astrojs/cloudflare",
   "description": "Deploy your site to Cloudflare Workers/Pages",
-  "version": "7.6.4",
+  "version": "7.7.1",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "withastro",
@@ -22,6 +22,7 @@
     ".": "./dist/index.js",
     "./entrypoints/server.advanced.js": "./dist/entrypoints/server.advanced.js",
     "./entrypoints/server.directory.js": "./dist/entrypoints/server.directory.js",
+    "./image-service": "./dist/entrypoints/image-service.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -29,28 +30,28 @@
   ],
   "dependencies": {
     "@astrojs/underscore-redirects": "^0.3.3",
-    "@cloudflare/workers-types": "^4.20230821.0",
-    "miniflare": "3.20231010.0",
+    "@cloudflare/workers-types": "^4.20231025.0",
+    "miniflare": "3.20231025.1",
     "@iarna/toml": "^2.2.5",
     "dotenv": "^16.3.1",
-    "esbuild": "^0.19.2",
+    "esbuild": "^0.19.5",
     "find-up": "^6.3.0",
     "tiny-glob": "^0.2.9",
-    "vite": "^4.4.9"
+    "vite": "^4.5.0"
   },
   "peerDependencies": {
-    "astro": "^3.3.0"
+    "astro": "^3.4.3"
   },
   "devDependencies": {
     "execa": "^8.0.1",
     "fast-glob": "^3.3.1",
     "@types/iarna__toml": "^2.0.2",
     "strip-ansi": "^7.1.0",
-    "astro": "^3.2.3",
-    "chai": "^4.3.7",
+    "astro": "^3.4.3",
+    "chai": "^4.3.10",
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",
-    "wrangler": "^3.11.0",
+    "wrangler": "^3.15.0",
     "@astrojs/test-utils": "0.0.1"
   },
   "publishConfig": {