@wix/astro 0.1.1

package/dist/middleware.js

@@ -0,0 +1,98 @@
+import { OAuthStrategy, TokenRole, createClient, } from "@wix/sdk";
+import { z } from "astro/zod";
+import { defineMiddleware } from "astro:middleware";
+import { AsyncLocalStorage } from "node:async_hooks";
+const authStrategyAsyncLocalStorage = new AsyncLocalStorage();
+const sessionClient = createClient({
+    auth: {
+        async getAuthHeaders() {
+            const auth = authStrategyAsyncLocalStorage.getStore()?.auth;
+            if (!auth) {
+                throw new Error("No authentication strategy found in the current context");
+            }
+            return auth.getAuthHeaders();
+        },
+    },
+});
+sessionClient.enableContext("global");
+/**
+ * Checks if the incoming request is a request for a dynamic (server-side rendered) page.
+ * We can check this by looking at the middleware's `clientAddress` context property because accessing
+ * this prop in a static route will throw an error which we can conveniently catch.
+ */
+function checkIsDynamicPageRequest(context) {
+    try {
+        return context.clientAddress != null;
+    }
+    catch {
+        return false;
+    }
+}
+export const onRequest = defineMiddleware(async (context, next) => {
+    const { clientId } = getClientEnvVars(context.locals.runtime?.env ?? import.meta.env);
+    const wixSessionCookie = checkIsDynamicPageRequest(context)
+        ? context.cookies.get("wixSession")?.json()
+        : undefined;
+    let tokens;
+    if (wixSessionCookie) {
+        const tokensParseResult = z
+            .object({
+            clientId: z.string(),
+            tokens: z.object({
+                accessToken: z.object({
+                    value: z.string(),
+                    expiresAt: z.number(),
+                }),
+                refreshToken: z.object({
+                    value: z.string(),
+                    role: z.nativeEnum(TokenRole),
+                }),
+            }),
+        })
+            .safeParse(wixSessionCookie);
+        if (!tokensParseResult.success) {
+            throw new Error(`Invalid wixSession cookie: ${tokensParseResult.error}`);
+        }
+        else {
+            if (tokensParseResult.data.clientId === clientId) {
+                tokens = tokensParseResult.data.tokens;
+            }
+        }
+    }
+    const auth = OAuthStrategy({
+        clientId,
+        tokens,
+    });
+    const response = await authStrategyAsyncLocalStorage.run({
+        auth,
+    }, () => next());
+    if (checkIsDynamicPageRequest(context)) {
+        context.cookies.set("wixSession", JSON.stringify({ clientId, tokens: auth.getTokens() }), {
+            secure: true,
+            path: "/",
+        });
+    }
+    return response;
+});
+function getClientEnvVars(env) {
+    const { WIX_CLIENT_ID, WIX_CLIENT_SECRET, WIX_CLIENT_PUBLIC_KEY, WIX_CLIENT_INSTANCE_ID, } = env;
+    if (!WIX_CLIENT_ID) {
+        throw new Error("Missing environment variable: PUBLIC_WIX_CLIENT_ID");
+    }
+    if (!WIX_CLIENT_SECRET) {
+        throw new Error("Missing environment variable: WIX_CLIENT_SECRET");
+    }
+    if (!WIX_CLIENT_PUBLIC_KEY) {
+        throw new Error("Missing environment variable: WIX_CLIENT_PUBLIC_KEY");
+    }
+    if (!WIX_CLIENT_INSTANCE_ID) {
+        throw new Error("Missing environment variable: WIX_CLIENT_INSTANCE_ID");
+    }
+    return {
+        clientId: WIX_CLIENT_ID,
+        clientSecret: WIX_CLIENT_SECRET,
+        publicKey: WIX_CLIENT_PUBLIC_KEY,
+        instanceId: WIX_CLIENT_INSTANCE_ID,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/assets.d.ts

@@ -0,0 +1,9 @@
+import type { AstroConfig, ImageMetadata, RemotePattern } from "astro";
+export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
+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;

package/dist/utils/assets.js

@@ -0,0 +1,69 @@
+import { isRemotePath } from "@astrojs/internal-helpers/path";
+export 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;
+}
+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;
+    }
+    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;
+}
+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;
+}
+//# sourceMappingURL=data:application/json;base64,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

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,237 @@
+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;
+    returnHasWildcard = false;
+    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) {
+            this.returnHasWildcard = true;
+            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, this.returnHasWildcard];
+    }
+}
+export async function createRoutesFile(_config, logger, routes, pages, redirects, includeExtends, excludeExtends) {
+    const includePaths = [];
+    const excludePaths = [];
+    /**
+     * 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);
+    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));
+        }
+    }
+    for (const redirect of redirects) {
+        excludePaths.push(segmentsToCfSyntax(redirect, _config));
+    }
+    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) {
+        if (page.pathname === "404")
+            hasPrerendered404 = true;
+        const pageSegments = removeLeadingForwardSlash(page.pathname)
+            .split(posix.sep)
+            .filter(Boolean)
+            .map((s) => {
+            return getParts(s);
+        });
+        excludePaths.push(segmentsToCfSyntax(pageSegments, _config));
+    }
+    const includeTrie = new PathTrie();
+    for (const includePath of includePaths) {
+        includeTrie.insert(includePath);
+    }
+    const [deduplicatedIncludePaths, includedPathsHaveWildcard] = includeTrie.getAllPaths();
+    const excludeTrie = new PathTrie();
+    for (const excludePath of excludePaths) {
+        /**
+         * A excludePath with starts with a wildcard (*) is a catch-all
+         * that would mean all routes are static, that would be equal to a full SSG project
+         * the adapter is not needed in this case, so we do not consider such paths
+         */
+        if (excludePath[0] === "*")
+            continue;
+        excludeTrie.insert(excludePath);
+    }
+    const [deduplicatedExcludePaths, _excludedPathsHaveWildcard] = 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;
+    /**
+     * Caluclate the number of automated and extended include rules
+     */
+    const AUTOMATIC_INCLUDE_RULES_COUNT = deduplicatedIncludePaths.length;
+    const EXTENDED_INCLUDE_RULES_COUNT = includeExtends?.length ?? 0;
+    const INCLUDE_RULES_COUNT = AUTOMATIC_INCLUDE_RULES_COUNT + EXTENDED_INCLUDE_RULES_COUNT;
+    /**
+     * Caluclate the number of automated and extended exclude rules
+     */
+    const AUTOMATIC_EXCLUDE_RULES_COUNT = deduplicatedExcludePaths.length;
+    const EXTENDED_EXCLUDE_RULES_COUNT = excludeExtends?.length ?? 0;
+    const EXCLUDE_RULES_COUNT = AUTOMATIC_EXCLUDE_RULES_COUNT + EXTENDED_EXCLUDE_RULES_COUNT;
+    if (!hasPrerendered404 ||
+        INCLUDE_RULES_COUNT > CLOUDFLARE_COMBINED_LIMIT ||
+        EXCLUDE_RULES_COUNT > CLOUDFLARE_COMBINED_LIMIT) {
+        await writeRoutesFileToOutDir(_config, logger, ["/*"].concat(includeExtends?.map((entry) => entry.pattern) ?? []), deduplicatedExcludePaths
+            .map((path) => `${prependForwardSlash(path.join("/"))}`)
+            .slice(0, CLOUDFLARE_COMBINED_LIMIT -
+            EXTENDED_INCLUDE_RULES_COUNT -
+            EXTENDED_EXCLUDE_RULES_COUNT -
+            1)
+            .concat(excludeExtends?.map((entry) => entry.pattern) ?? []));
+    }
+    else {
+        await writeRoutesFileToOutDir(_config, logger, deduplicatedIncludePaths
+            .map((path) => `${prependForwardSlash(path.join("/"))}`)
+            .concat(includeExtends?.map((entry) => entry.pattern) ?? []), includedPathsHaveWildcard
+            ? deduplicatedExcludePaths
+                .map((path) => `${prependForwardSlash(path.join("/"))}`)
+                .concat(excludeExtends?.map((entry) => entry.pattern) ?? [])
+            : []);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-routes-json.js","sourceRoot":"","sources":["../../src/utils/generate-routes-json.ts"],"names":[],"mappings":"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"}

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

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

package/dist/utils/image-config.js

@@ -0,0 +1,30 @@
+import { passthroughImageService, sharpImageService } from "astro/config";
+export function setImageConfig(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" },
+            };
+        case "compile":
+            return {
+                ...config,
+                service: sharpImageService(),
+                endpoint: command === "dev" ? undefined : "@astrojs/cloudflare/image-endpoint",
+            };
+        case "custom":
+            return { ...config };
+        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 };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2ltYWdlLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFMUUsTUFBTSxVQUFVLGNBQWMsQ0FDNUIsT0FBZSxFQUNmLE1BQTRCLEVBQzVCLE9BQTZDLEVBQzdDLE1BQThCO0lBRTlCLFFBQVEsT0FBTyxFQUFFLENBQUM7UUFDaEIsS0FBSyxhQUFhO1lBQ2hCLE9BQU8sRUFBRSxHQUFHLE1BQU0sRUFBRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsRUFBRSxDQUFDO1FBRTNELEtBQUssWUFBWTtZQUNmLE9BQU87Z0JBQ0wsR0FBRyxNQUFNO2dCQUNULE9BQU8sRUFDTCxPQUFPLEtBQUssS0FBSztvQkFDZixDQUFDLENBQUMsaUJBQWlCLEVBQUU7b0JBQ3JCLENBQUMsQ0FBQyxFQUFFLFVBQVUsRUFBRSxtQ0FBbUMsRUFBRTthQUMxRCxDQUFDO1FBRUosS0FBSyxTQUFTO1lBQ1osT0FBTztnQkFDTCxHQUFHLE1BQU07Z0JBQ1QsT0FBTyxFQUFFLGlCQUFpQixFQUFFO2dCQUM1QixRQUFRLEVBQ04sT0FBTyxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxvQ0FBb0M7YUFDdkUsQ0FBQztRQUVKLEtBQUssUUFBUTtZQUNYLE9BQU8sRUFBRSxHQUFHLE1BQU0sRUFBRSxDQUFDO1FBRXZCO1lBQ0UsSUFDRSxNQUFNLENBQUMsT0FBTyxDQUFDLFVBQVUsS0FBSyw2QkFBNkI7Z0JBQzNELE1BQU0sQ0FBQyxPQUFPLENBQUMsVUFBVSxLQUFLLCtCQUErQixFQUM3RCxDQUFDO2dCQUNELE1BQU0sQ0FBQyxJQUFJLENBQ1QsOFJBQThSLENBQy9SLENBQUM7Z0JBQ0YsT0FBTyxFQUFFLEdBQUcsTUFBTSxFQUFFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxFQUFFLENBQUM7WUFDM0QsQ0FBQztZQUNELE9BQU8sRUFBRSxHQUFHLE1BQU0sRUFBRSxDQUFDO0lBQ3pCLENBQUM7QUFDSCxDQUFDIn0=

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -0,0 +1,59 @@
+export function mutatePageMapInPlace(node, constsToRemove, s) {
+    const declarator = node.declarations[0];
+    if (declarator.id.type !== "Identifier")
+        return;
+    if (declarator.id.name !== "pageMap")
+        return;
+    if (!declarator.init || declarator.init.type !== "NewExpression")
+        return;
+    if (!declarator.init.arguments[0] ||
+        declarator.init.arguments[0].type !== "ArrayExpression")
+        return;
+    for (const arrayExpression of declarator.init.arguments[0].elements) {
+        if (!arrayExpression || arrayExpression.type !== "ArrayExpression")
+            continue;
+        if (!arrayExpression.elements[1] ||
+            arrayExpression.elements[1].type !== "Identifier")
+            continue;
+        if (constsToRemove.includes(arrayExpression.elements[1].name)) {
+            // @ts-expect-error - @types/estree seem to be wrong
+            if (arrayExpression.start && arrayExpression.end) {
+                // @ts-expect-error - @types/estree seem to be wrong
+                s.remove(arrayExpression.start, arrayExpression.end);
+                // We need to check if there are any leftover commas, which are not part of the `ArrayExpression` node
+                // @ts-expect-error - @types/estree seem to be wrong
+                const endChar = s.slice(arrayExpression.end, arrayExpression.end + 1);
+                if (endChar.includes(",")) {
+                    // @ts-expect-error - @types/estree seem to be wrong
+                    s.remove(arrayExpression.end, arrayExpression.end + 1);
+                }
+            }
+        }
+    }
+}
+export function mutateDynamicPageImportsInPlace(node, prerenderImports, constsToRemove, s) {
+    const declarator = node.declarations[0];
+    if (declarator.id.type !== "Identifier")
+        return;
+    if (!declarator.id.name.startsWith("_page"))
+        return;
+    if (!declarator.init || declarator.init.type !== "ArrowFunctionExpression")
+        return;
+    if (!declarator.init.body || declarator.init.body.type !== "ImportExpression")
+        return;
+    if (!declarator.init.body.source ||
+        declarator.init.body.source.type !== "Literal")
+        return;
+    const sourceValue = declarator.init.body.source.value;
+    if (typeof sourceValue !== "string")
+        return;
+    if (prerenderImports.some((importItem) => sourceValue.includes(importItem))) {
+        // @ts-expect-error - @types/estree seem to be wrong
+        if (node.start && node.end) {
+            constsToRemove.push(declarator.id.name);
+            // @ts-expect-error - @types/estree seem to be wrong
+            s.remove(node.start, node.end);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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