@astrojs/cloudflare 9.2.0 → 10.0.0

package/dist/index.js

@@ -1,37 +1,24 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import { dirname, relative, sep } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+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 esbuild from 'esbuild';
-import glob from 'tiny-glob';
-import { getAdapter } from './getAdapter.js';
-import { deduplicatePatterns } from './utils/deduplicatePatterns.js';
-import { prepareImageConfig } from './utils/image-config.js';
-import { getLocalRuntime, getRuntimeConfig } from './utils/local-runtime.js';
-import { prependForwardSlash } from './utils/prependForwardSlash.js';
-import { rewriteWasmImportPath } from './utils/rewriteWasmImportPath.js';
-import { patchSharpBundle } from './utils/sharpBundlePatch.js';
+import { getPlatformProxy } from 'wrangler';
+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) {
     let _config;
-    let _buildConfig;
-    let _localRuntime;
-    let _entryPoints = new Map();
-    const SERVER_BUILD_FOLDER = '/$server_build/';
-    const isModeDirectory = args?.mode === 'directory';
-    const functionPerRoute = args?.functionPerRoute ?? false;
-    const runtimeMode = getRuntimeConfig(args?.runtime);
     return {
         name: '@astrojs/cloudflare',
         hooks: {
             'astro:config:setup': ({ command, config, updateConfig, logger }) => {
                 updateConfig({
                     build: {
-                        client: new URL(`.${config.base}`, config.outDir),
-                        server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
-                        serverEntry: '_worker.mjs',
+                        client: new URL(`.${prependForwardSlash(appendForwardSlash(config.base))}`, config.outDir),
+                        server: new URL('./_worker.js/', config.outDir),
+                        serverEntry: 'index.js',
                         redirects: false,
                     },
                     vite: {
@@ -39,57 +26,59 @@ export default function createIntegration(args) {
                         plugins: [
                             wasmModuleLoader({
                                 disabled: !args?.wasmModuleImports,
-                                assetsDirectory: config.build.assets,
                             }),
                         ],
                     },
-                    image: prepareImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
+                    image: setImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
                 });
             },
             'astro:config:done': ({ setAdapter, config }) => {
-                setAdapter(getAdapter({ isModeDirectory, functionPerRoute }));
                 _config = config;
-                _buildConfig = config.build;
-                if (_config.output === 'static') {
+                if (config.output === 'static') {
                     throw new AstroError('[@astrojs/cloudflare] `output: "server"` or `output: "hybrid"` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.');
                 }
-                if (_config.base === SERVER_BUILD_FOLDER) {
-                    throw new AstroError('[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.');
-                }
+                setAdapter({
+                    name: '@astrojs/cloudflare',
+                    serverEntrypoint: '@astrojs/cloudflare/entrypoints/server.advanced.js',
+                    exports: ['default'],
+                    adapterFeatures: {
+                        functionPerRoute: false,
+                        edgeMiddleware: false,
+                    },
+                    supportedAstroFeatures: {
+                        serverOutput: 'stable',
+                        hybridOutput: 'stable',
+                        staticOutput: 'unsupported',
+                        i18nDomains: 'experimental',
+                        assets: {
+                            supportKind: 'stable',
+                            isSharpCompatible: false,
+                            isSquooshCompatible: false,
+                        },
+                    },
+                });
             },
-            'astro:server:setup': ({ server, logger }) => {
-                if (runtimeMode.mode === 'local') {
+            'astro:server:setup': async ({ server }) => {
+                if (args?.platformProxy?.enabled === true) {
+                    const platformProxy = await getPlatformProxy({
+                        configPath: args.platformProxy.configPath ?? 'wrangler.toml',
+                        experimentalJsonConfig: args.platformProxy.experimentalJsonConfig ?? false,
+                        persist: args.platformProxy.persist ?? true,
+                    });
+                    const clientLocalsSymbol = Symbol.for('astro.locals');
                     server.middlewares.use(async function middleware(req, res, next) {
-                        _localRuntime = getLocalRuntime(_config, runtimeMode, logger);
-                        const bindings = await _localRuntime.getBindings();
-                        const secrets = await _localRuntime.getSecrets();
-                        const caches = await _localRuntime.getCaches();
-                        const cf = await _localRuntime.getCF();
-                        const clientLocalsSymbol = Symbol.for('astro.locals');
                         Reflect.set(req, clientLocalsSymbol, {
                             runtime: {
-                                env: {
-                                    CF_PAGES_URL: `http://${req.headers.host}`,
-                                    ...bindings,
-                                    ...secrets,
-                                },
-                                cf: cf,
-                                caches: caches,
-                                waitUntil: (_promise) => {
-                                    return;
-                                },
+                                env: platformProxy.env,
+                                cf: platformProxy.cf,
+                                caches: platformProxy.caches,
+                                ctx: platformProxy.ctx,
                             },
                         });
                         next();
                     });
                 }
             },
-            'astro:server:done': async ({ logger }) => {
-                if (_localRuntime) {
-                    logger.info('Cleaning up the local Cloudflare runtime.');
-                    await _localRuntime.dispose();
-                }
-            },
             'astro:build:setup': ({ vite, target }) => {
                 if (target === 'server') {
                     vite.resolve ||= {};
@@ -99,6 +88,14 @@ export default function createIntegration(args) {
                             find: 'react-dom/server',
                             replacement: 'react-dom/server.browser',
                         },
+                        {
+                            find: 'solid-js/web',
+                            replacement: 'solid-js/web/dist/server',
+                        },
+                        {
+                            find: 'solid-js',
+                            replacement: 'solid-js/dist/server',
+                        },
                     ];
                     if (Array.isArray(vite.resolve.alias)) {
                         vite.resolve.alias = [...vite.resolve.alias, ...aliases];
@@ -110,345 +107,97 @@ export default function createIntegration(args) {
                     }
                     vite.ssr ||= {};
                     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-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.*`. We will populate `process.env` later
-                    // in its fetch handler.
+                    // 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,
                     };
                 }
             },
-            'astro:build:ssr': ({ entryPoints }) => {
-                _entryPoints = entryPoints;
-            },
-            'astro:build:done': async ({ pages, routes, dir }) => {
-                const functionsUrl = new URL('functions/', _config.root);
-                const assetsUrl = new URL(_buildConfig.assets, _buildConfig.client);
-                if (isModeDirectory) {
-                    await fs.promises.mkdir(functionsUrl, { recursive: true });
-                }
-                if (isModeDirectory && functionPerRoute) {
-                    const entryPointsURL = [..._entryPoints.values()];
-                    const entryPaths = entryPointsURL.map((entry) => fileURLToPath(entry));
-                    const outputUrl = new URL('$astro', _buildConfig.server);
-                    const outputDir = fileURLToPath(outputUrl);
-                    //
-                    // Sadly, when wasmModuleImports is enabled, this needs to build esbuild for each depth of routes/entrypoints
-                    // independently so that relative import paths to the assets are the correct depth of '../' traversals
-                    // This is inefficient, so wasmModuleImports is opt-in. This could potentially be improved in the future by
-                    // taking advantage of the esbuild "onEnd" hook to rewrite import code per entry point relative to where the final
-                    // destination of the entrypoint is
-                    const entryPathsGroupedByDepth = !args.wasmModuleImports
-                        ? [entryPaths]
-                        : entryPaths
-                            .reduce((sum, thisPath) => {
-                            const depthFromRoot = thisPath.split(sep).length;
-                            sum.set(depthFromRoot, (sum.get(depthFromRoot) || []).concat(thisPath));
-                            return sum;
-                        }, new Map())
-                            .values();
-                    for (const pathsGroup of entryPathsGroupedByDepth) {
-                        // for some reason this exports to "entry.pages" on windows instead of "pages" on unix environments.
-                        // This deduces the name of the "pages" build directory
-                        const pagesDirname = relative(fileURLToPath(_buildConfig.server), pathsGroup[0]).split(sep)[0];
-                        const absolutePagesDirname = fileURLToPath(new URL(pagesDirname, _buildConfig.server));
-                        const urlWithinFunctions = new URL(relative(absolutePagesDirname, pathsGroup[0]), functionsUrl);
-                        const esbuildPlugins = [];
-                        if (args?.imageService === 'compile') {
-                            esbuildPlugins.push(patchSharpBundle());
-                        }
-                        const relativePathToAssets = relative(dirname(fileURLToPath(urlWithinFunctions)), fileURLToPath(assetsUrl));
-                        if (args?.wasmModuleImports) {
-                            esbuildPlugins.push(rewriteWasmImportPath({ relativePathToAssets }));
-                        }
-                        await esbuild.build({
-                            target: 'es2022',
-                            platform: 'browser',
-                            conditions: ['workerd', 'worker', 'browser'],
-                            external: [
-                                'node:assert',
-                                'node:async_hooks',
-                                'node:buffer',
-                                'node:crypto',
-                                'node:diagnostics_channel',
-                                'node:events',
-                                'node:path',
-                                'node:process',
-                                'node:stream',
-                                'node:string_decoder',
-                                'node:util',
-                                'cloudflare:*',
-                            ],
-                            entryPoints: pathsGroup,
-                            outbase: absolutePagesDirname,
-                            outdir: outputDir,
-                            allowOverwrite: true,
-                            format: 'esm',
-                            bundle: true,
-                            minify: _config.vite?.build?.minify !== false,
-                            banner: {
-                                js: `globalThis.process = {
-									argv: [],
-									env: {},
-								};`,
-                            },
-                            logOverride: {
-                                'ignored-bare-import': 'silent',
-                            },
-                            plugins: esbuildPlugins,
-                        });
-                    }
-                    const outputFiles = await glob('**/*', {
-                        cwd: outputDir,
-                        filesOnly: true,
-                    });
-                    // move the files into the functions folder
-                    // & make sure the file names match Cloudflare syntax for routing
-                    for (const outputFile of outputFiles) {
-                        const path = outputFile.split(sep);
-                        const finalSegments = path.map((segment) => segment
-                            .replace(/(\_)(\w+)(\_)/g, (_, __, prop) => {
-                            return `[${prop}]`;
-                        })
-                            .replace(/(\_\-\-\-)(\w+)(\_)/g, (_, __, prop) => {
-                            return `[[${prop}]]`;
-                        }));
-                        finalSegments[finalSegments.length - 1] = finalSegments[finalSegments.length - 1]
-                            .replace('entry.', '')
-                            .replace(/(.*)\.(\w+)\.(\w+)$/g, (_, fileName, __, newExt) => {
-                            return `${fileName}.${newExt}`;
-                        });
-                        const finalDirPath = finalSegments.slice(0, -1).join(sep);
-                        const finalPath = finalSegments.join(sep);
-                        const newDirUrl = new URL(finalDirPath, functionsUrl);
-                        await fs.promises.mkdir(newDirUrl, { recursive: true });
-                        const oldFileUrl = new URL(`$astro/${outputFile}`, outputUrl);
-                        const newFileUrl = new URL(finalPath, functionsUrl);
-                        await fs.promises.rename(oldFileUrl, newFileUrl);
-                    }
-                }
-                else {
-                    const entryPath = fileURLToPath(new URL(_buildConfig.serverEntry, _buildConfig.server));
-                    const entryUrl = new URL(_buildConfig.serverEntry, _config.outDir);
-                    const buildPath = fileURLToPath(entryUrl);
-                    // A URL for the final build path after renaming
-                    const finalBuildUrl = pathToFileURL(buildPath.replace(/\.mjs$/, '.js'));
-                    const esbuildPlugins = [];
-                    if (args?.imageService === 'compile') {
-                        esbuildPlugins.push(patchSharpBundle());
-                    }
-                    if (args?.wasmModuleImports) {
-                        esbuildPlugins.push(rewriteWasmImportPath({
-                            relativePathToAssets: isModeDirectory
-                                ? relative(fileURLToPath(functionsUrl), fileURLToPath(assetsUrl))
-                                : relative(fileURLToPath(_buildConfig.client), fileURLToPath(assetsUrl)),
-                        }));
-                    }
-                    await esbuild.build({
-                        target: 'es2022',
-                        platform: 'browser',
-                        conditions: ['workerd', 'worker', 'browser'],
-                        external: [
-                            'node:assert',
-                            'node:async_hooks',
-                            'node:buffer',
-                            'node:crypto',
-                            'node:diagnostics_channel',
-                            'node:events',
-                            'node:path',
-                            'node:process',
-                            'node:stream',
-                            'node:string_decoder',
-                            'node:util',
-                            'cloudflare:*',
-                        ],
-                        entryPoints: [entryPath],
-                        outfile: buildPath,
-                        allowOverwrite: true,
-                        format: 'esm',
-                        bundle: true,
-                        minify: _config.vite?.build?.minify !== false,
-                        banner: {
-                            js: `globalThis.process = {
-								argv: [],
-								env: {},
-							};`,
-                        },
-                        logOverride: {
-                            'ignored-bare-import': 'silent',
-                        },
-                        plugins: esbuildPlugins,
-                    });
-                    // Rename to worker.js
-                    await fs.promises.rename(buildPath, finalBuildUrl);
-                    if (isModeDirectory) {
-                        const directoryUrl = new URL('[[path]].js', functionsUrl);
-                        await fs.promises.rename(finalBuildUrl, directoryUrl);
-                    }
-                }
-                // throw the server folder in the bin
-                const serverUrl = new URL(_buildConfig.server);
-                await fs.promises.rm(serverUrl, { recursive: true, force: true });
-                // move cloudflare specific files to the root
-                const cloudflareSpecialFiles = ['_headers', '_redirects', '_routes.json'];
+            'astro:build:done': async ({ pages, routes, dir, logger }) => {
+                const PLATFORM_FILES = ['_headers', '_redirects', '_routes.json'];
                 if (_config.base !== '/') {
-                    for (const file of cloudflareSpecialFiles) {
+                    for (const file of PLATFORM_FILES) {
                         try {
-                            await fs.promises.rename(new URL(file, _buildConfig.client), new URL(file, _config.outDir));
+                            await rename(new URL(file, _config.build.client), new URL(file, _config.outDir));
                         }
                         catch (e) {
-                            // ignore
+                            logger.error(`There was an error moving ${file} to the root of the output directory.`);
                         }
                     }
                 }
-                // Add also the worker file so it's excluded from the _routes.json generation
-                if (!isModeDirectory) {
-                    cloudflareSpecialFiles.push('_worker.js');
+                let redirectsExists = false;
+                try {
+                    const redirectsStat = await stat(new URL('./_redirects', _config.outDir));
+                    if (redirectsStat.isFile()) {
+                        redirectsExists = true;
+                    }
                 }
-                const routesExists = await fs.promises
-                    .stat(new URL('./_routes.json', _config.outDir))
-                    .then((stat) => stat.isFile())
-                    .catch(() => false);
-                // this creates a _routes.json, in case there is none present to enable
-                // cloudflare to handle static files and support _redirects configuration
-                if (!routesExists) {
-                    /**
-                     * 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()
-                            .map((segment) => (segment.dynamic ? '*' : segment.content))
-                            .join('/')}`;
-                        const regexp = new RegExp(`^\\/${route.segments
-                            .flat()
-                            .map((segment) => (segment.dynamic ? '(.*)' : segment.content))
-                            .join('\\/')}$`);
-                        return {
-                            includePattern,
-                            regexp,
-                        };
+                catch (error) {
+                    redirectsExists = false;
+                }
+                const redirects = [];
+                if (redirectsExists) {
+                    const rl = createInterface({
+                        input: createReadStream(new URL('./_redirects', _config.outDir)),
+                        crlfDelay: Number.POSITIVE_INFINITY,
                     });
-                    const staticPathList = (await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
-                        cwd: fileURLToPath(_config.outDir),
-                        filesOnly: true,
-                        dot: true,
-                    }))
-                        .filter((file) => cloudflareSpecialFiles.indexOf(file) < 0)
-                        .map((file) => `/${file.replace(/\\/g, '/')}`);
-                    for (const page of pages) {
-                        let pagePath = prependForwardSlash(page.pathname);
-                        if (_config.base !== '/') {
-                            const base = _config.base.endsWith('/') ? _config.base.slice(0, -1) : _config.base;
-                            pagePath = `${base}${pagePath}`;
+                    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);
                         }
-                        staticPathList.push(pagePath);
                     }
-                    const redirectsExists = await fs.promises
-                        .stat(new URL('./_redirects', _config.outDir))
-                        .then((stat) => stat.isFile())
-                        .catch(() => false);
-                    // convert all redirect source paths into a list of routes
-                    // and add them to the static path
-                    if (redirectsExists) {
-                        const redirects = (await fs.promises.readFile(new URL('./_redirects', _config.outDir), 'utf-8'))
-                            .split(os.EOL)
-                            .map((line) => {
-                            const parts = line.split(' ');
-                            if (parts.length < 2) {
-                                return null;
-                            }
-                            // convert /products/:id to /products/*
-                            return (parts[0]
-                                .replace(/\/:.*?(?=\/|$)/g, '/*')
-                                // remove query params as they are not supported by cloudflare
-                                .replace(/\?.*$/, ''));
-                        })
-                            .filter((line, index, arr) => line !== null && arr.indexOf(line) === index);
-                        if (redirects.length > 0) {
-                            staticPathList.push(...redirects);
-                        }
-                    }
-                    const redirectRoutes = routes
-                        .filter((r) => r.type === 'redirect')
-                        .map((r) => {
-                        return [r, ''];
-                    });
-                    const trueRedirects = createRedirectsFromAstroRoutes({
-                        config: _config,
-                        routeToDynamicTargetMap: new Map(Array.from(redirectRoutes)),
-                        dir,
-                    });
-                    if (!trueRedirects.empty()) {
-                        await fs.promises.appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
+                }
+                let routesExists = false;
+                try {
+                    const routesStat = await stat(new URL('./_routes.json', _config.outDir));
+                    if (routesStat.isFile()) {
+                        routesExists = true;
                     }
-                    staticPathList.push(...routes.filter((r) => r.type === 'redirect').map((r) => r.route));
-                    const strategy = args?.routes?.strategy ?? 'auto';
-                    // Strategy `include`: include all function endpoints, and then exclude static paths that would be matched by an include pattern
-                    const includeStrategy = strategy === 'exclude'
-                        ? undefined
-                        : {
-                            include: deduplicatePatterns(functionEndpoints
-                                .map((endpoint) => endpoint.includePattern)
-                                .concat(args?.routes?.include ?? [])),
-                            exclude: deduplicatePatterns(staticPathList
-                                .filter((file) => functionEndpoints.some((endpoint) => endpoint.regexp.test(file)))
-                                .concat(args?.routes?.exclude ?? [])),
-                        };
-                    // Cloudflare requires at least one include pattern:
-                    // https://developers.cloudflare.com/pages/platform/functions/routing/#limits
-                    // So we add a pattern that we immediately exclude again
-                    if (includeStrategy?.include.length === 0) {
-                        includeStrategy.include = ['/'];
-                        includeStrategy.exclude = ['/'];
+                }
+                catch (error) {
+                    routesExists = false;
+                }
+                if (!routesExists) {
+                    await createRoutesFile(_config, logger, routes, pages, redirects, args?.routes?.extend?.include, args?.routes?.extend?.exclude);
+                }
+                const redirectRoutes = [];
+                for (const route of routes) {
+                    if (route.type === 'redirect')
+                        redirectRoutes.push([route, '']);
+                }
+                const trueRedirects = createRedirectsFromAstroRoutes({
+                    config: _config,
+                    routeToDynamicTargetMap: new Map(Array.from(redirectRoutes)),
+                    dir,
+                });
+                if (!trueRedirects.empty()) {
+                    try {
+                        await appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
                     }
-                    // Strategy `exclude`: include everything, and then exclude all static paths
-                    const excludeStrategy = strategy === 'include'
-                        ? undefined
-                        : {
-                            include: ['/*'],
-                            exclude: deduplicatePatterns(staticPathList.concat(args?.routes?.exclude ?? [])),
-                        };
-                    switch (args?.routes?.strategy) {
-                        case 'include':
-                            await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                                version: 1,
-                                ...includeStrategy,
-                            }, null, 2));
-                            break;
-                        case 'exclude':
-                            await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                                version: 1,
-                                ...excludeStrategy,
-                            }, null, 2));
-                            break;
-                        default:
-                            {
-                                const includeStrategyLength = includeStrategy
-                                    ? includeStrategy.include.length + includeStrategy.exclude.length
-                                    : Number.POSITIVE_INFINITY;
-                                const excludeStrategyLength = excludeStrategy
-                                    ? excludeStrategy.include.length + excludeStrategy.exclude.length
-                                    : Number.POSITIVE_INFINITY;
-                                const winningStrategy = notFoundIsSSR
-                                    ? excludeStrategy
-                                    : includeStrategyLength <= excludeStrategyLength
-                                        ? includeStrategy
-                                        : excludeStrategy;
-                                await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
-                                    version: 1,
-                                    ...winningStrategy,
-                                }, null, 2));
-                            }
-                            break;
+                    catch (error) {
+                        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>;