@wix/astro 0.1.1

package/README.md

@@ -0,0 +1,51 @@
+# Wix Astro Integration
+
+## Features
+
+### Session Management
+
+The Wix Astro integration provides session management for your Astro project.
+
+### Integrating into an exinsting Astro project
+
+If you already have an Astro project and you want to add the Wix Astro integration to it, follow these steps:
+
+1. Install the Wix Astro integration package and the Wix CLI packages:
+
+```bash
+npm install @wix/astro @wix/cli @wix/cli-astro
+```
+
+2. Add the Wix integration to your Astro project's `astro.config.mjs` file:
+
+```js
+import wix from "@wix/astro-internal";
+
+export default {
+  // ...
+  output: "server",
+  integrations: [wix()],
+  // ...
+};
+```
+
+3. Build your Astro project:
+
+```bash
+npm run build
+```
+
+4. Create a `wix.config.json` at the root of your project:
+
+```json
+{
+  "siteId": "<your site id>",
+  "projectId": "<your project id>"
+}
+```
+
+4. Deploy your Astro project to Wix:
+
+```bash
+npx wix astro deploy
+```

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

@@ -0,0 +1 @@
+export {};

package/dist/entrypoints/image-endpoint.js

@@ -0,0 +1,4 @@
+export {};
+// NOTE: this file is empty on purpose
+// it allows use to offer `imageService: 'compile'`
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtZW5kcG9pbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW50cnlwb2ludHMvaW1hZ2UtZW5kcG9pbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHNDQUFzQztBQUN0QyxtREFBbUQifQ==

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,35 @@
+/// <reference types="astro/client" />
+import { joinPaths } from "@astrojs/internal-helpers/path";
+import { baseService } from "astro/assets";
+import { isESMImportedImage, isRemoteAllowed } 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(import.meta.env.BASE_URL, "/cdn-cgi/image", resizingParams.join(","), imageSource);
+        return imageEndpoint;
+    },
+};
+export default service;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2Utc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbnRyeXBvaW50cy9pbWFnZS1zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHNDQUFzQztBQUl0QyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDM0QsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUMzQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFekUsTUFBTSxPQUFPLEdBQXlCO0lBQ3BDLEdBQUcsV0FBVztJQUNkLE1BQU0sRUFBRSxDQUFDLE9BQU8sRUFBRSxXQUFXLEVBQUUsRUFBRTtRQUMvQixNQUFNLGNBQWMsR0FBRyxFQUFFLENBQUM7UUFDMUIsSUFBSSxPQUFPLENBQUMsS0FBSztZQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUMsU0FBUyxPQUFPLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztRQUNqRSxJQUFJLE9BQU8sQ0FBQyxNQUFNO1lBQUUsY0FBYyxDQUFDLElBQUksQ0FBQyxVQUFVLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQ3BFLElBQUksT0FBTyxDQUFDLE9BQU87WUFBRSxjQUFjLENBQUMsSUFBSSxDQUFDLFdBQVcsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDdkUsSUFBSSxPQUFPLENBQUMsS0FBSyxDQUFDO1lBQUUsY0FBYyxDQUFDLElBQUksQ0FBQyxPQUFPLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDakUsSUFBSSxPQUFPLENBQUMsTUFBTTtZQUFFLGNBQWMsQ0FBQyxJQUFJLENBQUMsVUFBVSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUVwRSxJQUFJLFdBQVcsR0FBRyxFQUFFLENBQUM7UUFDckIsSUFBSSxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNwQyxXQUFXLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUM7UUFDaEMsQ0FBQzthQUFNLElBQUksZUFBZSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsV0FBVyxDQUFDLEVBQUUsQ0FBQztZQUNyRCxXQUFXLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQztRQUM1QixDQUFDO2FBQU0sQ0FBQztZQUNOLG9JQUFvSTtZQUNwSSxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUM7UUFDckIsQ0FBQztRQUVELE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FDN0IsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUN4QixnQkFBZ0IsRUFDaEIsY0FBYyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFDeEIsV0FBVyxDQUNaLENBQUM7UUFFRixPQUFPLGFBQWEsQ0FBQztJQUN2QixDQUFDO0NBQ0YsQ0FBQztBQUVGLGVBQWUsT0FBTyxDQUFDIn0=

package/dist/entrypoints/manifest.d.ts

@@ -0,0 +1,2 @@
+import { APIRoute } from "astro";
+export declare const GET: APIRoute;

package/dist/entrypoints/manifest.js

@@ -0,0 +1,6 @@
+// @ts-expect-error
+import wixManifest from "/src/wix/index";
+export const GET = async ({}) => {
+    return Response.json(wixManifest);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFuaWZlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW50cnlwb2ludHMvbWFuaWZlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsbUJBQW1CO0FBQ25CLE9BQU8sV0FBVyxNQUFNLGdCQUFnQixDQUFDO0FBRXpDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsR0FBYSxLQUFLLEVBQUUsRUFBRSxFQUFFLEVBQUU7SUFDeEMsT0FBTyxRQUFRLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO0FBQ3BDLENBQUMsQ0FBQyJ9

package/dist/entrypoints/server.d.ts

@@ -0,0 +1,20 @@
+import type { CacheStorage as CLOUDFLARE_CACHESTORAGE, Request as CLOUDFLARE_REQUEST, ExecutionContext } from "@cloudflare/workers-types";
+import type { SSRManifest } from "astro";
+type Env = {
+    __STATIC_CONTENT: KVNamespace;
+    ASTRO_STUDIO_APP_TOKEN?: string;
+};
+export interface Runtime<T extends object = object> {
+    runtime: {
+        env: Env & T;
+        cf: CLOUDFLARE_REQUEST["cf"];
+        caches: CLOUDFLARE_CACHESTORAGE;
+        ctx: ExecutionContext;
+    };
+}
+export declare function createExports(manifest: SSRManifest): {
+    default: {
+        fetch: (request: Request & CLOUDFLARE_REQUEST, env: Env, context: ExecutionContext) => Promise<Response>;
+    };
+};
+export {};

package/dist/entrypoints/server.js

@@ -0,0 +1,67 @@
+import { App } from "astro/app";
+import { getAssetFromKV } from "@cloudflare/kv-asset-handler";
+// @ts-expect-error
+import staticContentManifest from "__STATIC_CONTENT_MANIFEST";
+import { createClient } from "@wix/sdk";
+// @ts-expect-error
+import wixManifest from "/src/wix/index";
+export function createExports(manifest) {
+    const app = new App(manifest);
+    const runtimeManifest = wixManifest;
+    const client = createClient({});
+    for (const extension of runtimeManifest.extensions) {
+        if ("register" in extension) {
+            extension.register(client);
+        }
+    }
+    const fetch = async (request, env, context) => {
+        const { pathname } = new URL(request.url);
+        if (request.method === "POST" && pathname.startsWith("/_wix/events")) {
+            await client.webhooks.processRequest(request);
+            return new Response(null, { status: 200 });
+        }
+        if (request.method === "POST" &&
+            pathname.startsWith("/_wix/service-plugins")) {
+            return client.servicePlugins.processRequest(request);
+        }
+        const routeData = app.match(request);
+        if (!routeData) {
+            return await getAssetFromKV({
+                request,
+                waitUntil: context.waitUntil.bind(context),
+            }, {
+                ASSET_NAMESPACE: env.__STATIC_CONTENT,
+                ASSET_MANIFEST: JSON.parse(staticContentManifest),
+                cacheControl: {
+                    bypassCache: true,
+                },
+            });
+        }
+        Reflect.set(request, Symbol.for("astro.clientAddress"), request.headers.get("cf-connecting-ip"));
+        process.env["ASTRO_STUDIO_APP_TOKEN"] ??= (() => {
+            if (typeof env.ASTRO_STUDIO_APP_TOKEN === "string") {
+                return env.ASTRO_STUDIO_APP_TOKEN;
+            }
+        })();
+        const locals = {
+            runtime: {
+                env: env,
+                cf: request.cf,
+                caches: caches,
+                ctx: {
+                    waitUntil: (promise) => context.waitUntil(promise),
+                    passThroughOnException: () => context.passThroughOnException(),
+                },
+            },
+        };
+        const 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 { default: { fetch } };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/extensions.d.ts

@@ -0,0 +1,25 @@
+import { BuildEventDefinition, BuildServicePluginDefinition, EventDefinition, ServicePluginDefinition, WixClient } from "@wix/sdk";
+export type WixExtensionsRegistrar = {
+    on<T extends EventDefinition>(event: T, ...args: Parameters<BuildEventDefinition<T>>): Manifest & WixExtensionsRegistrar;
+    provide<T extends ServicePluginDefinition<any>>(servicePlugin: {
+        provideHandlers: T;
+    }, config: unknown, ...impl: Parameters<BuildServicePluginDefinition<T>>): Manifest & WixExtensionsRegistrar;
+    plugin(manifest: Manifest): Manifest & WixExtensionsRegistrar;
+    permissions(permissions: string[]): Manifest & WixExtensionsRegistrar;
+};
+export type Manifest = {
+    extensions: Array<{
+        type: "ServicePlugin";
+        componentType: string;
+        config: unknown;
+        register(client: WixClient): void;
+    } | {
+        type: "EventHandler";
+        webhookSlug: string;
+        register(client: WixClient): void;
+    } | {
+        type: "Permission";
+        permission: string;
+    }>;
+};
+export declare const manifest: Manifest & WixExtensionsRegistrar;

package/dist/extensions.js

@@ -0,0 +1,54 @@
+function wixManifestRegistrar(manifest = { extensions: [] }) {
+    return {
+        ...manifest,
+        plugin(manifest) {
+            return wixManifestRegistrar({
+                extensions: [...this.extensions, ...manifest.extensions],
+            });
+        },
+        on(event, ...args) {
+            const newManifest = {
+                ...manifest,
+                extensions: [
+                    ...manifest.extensions,
+                    {
+                        type: "EventHandler",
+                        webhookSlug: event.type,
+                        register: (client) => client.use(event)(...args),
+                    },
+                ],
+            };
+            return wixManifestRegistrar(newManifest);
+        },
+        provide(servicePlugin, config, ...impl) {
+            const newManifest = {
+                ...manifest,
+                extensions: [
+                    ...manifest.extensions,
+                    {
+                        type: "ServicePlugin",
+                        componentType: servicePlugin.provideHandlers.componentType,
+                        config,
+                        register: (client) => client.use(servicePlugin.provideHandlers)(...impl),
+                    },
+                ],
+            };
+            return wixManifestRegistrar(newManifest);
+        },
+        permissions(permissions) {
+            const newManifest = {
+                ...manifest,
+                extensions: [
+                    ...manifest.extensions,
+                    ...permissions.map((permission) => ({
+                        type: "Permission",
+                        permission,
+                    })),
+                ],
+            };
+            return wixManifestRegistrar(newManifest);
+        },
+    };
+}
+export const manifest = wixManifestRegistrar();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0ZW5zaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9leHRlbnNpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXVDQSxTQUFTLG9CQUFvQixDQUMzQixXQUFxQixFQUFFLFVBQVUsRUFBRSxFQUFFLEVBQUU7SUFFdkMsT0FBTztRQUNMLEdBQUcsUUFBUTtRQUNYLE1BQU0sQ0FBQyxRQUFRO1lBQ2IsT0FBTyxvQkFBb0IsQ0FBQztnQkFDMUIsVUFBVSxFQUFFLENBQUMsR0FBRyxJQUFJLENBQUMsVUFBVSxFQUFFLEdBQUcsUUFBUSxDQUFDLFVBQVUsQ0FBQzthQUN6RCxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0QsRUFBRSxDQUNBLEtBQVEsRUFDUixHQUFHLElBQXlDO1lBRTVDLE1BQU0sV0FBVyxHQUFhO2dCQUM1QixHQUFHLFFBQVE7Z0JBQ1gsVUFBVSxFQUFFO29CQUNWLEdBQUcsUUFBUSxDQUFDLFVBQVU7b0JBQ3RCO3dCQUNFLElBQUksRUFBRSxjQUFjO3dCQUNwQixXQUFXLEVBQUUsS0FBSyxDQUFDLElBQUk7d0JBQ3ZCLFFBQVEsRUFBRSxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQ2xCLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUE2QixDQUFDLEdBQUcsSUFBSSxDQUFDO3FCQUMxRDtpQkFDRjthQUNGLENBQUM7WUFFRixPQUFPLG9CQUFvQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzNDLENBQUM7UUFDRCxPQUFPLENBQ0wsYUFBcUMsRUFDckMsTUFBZSxFQUNmLEdBQUcsSUFBaUQ7WUFFcEQsTUFBTSxXQUFXLEdBQWE7Z0JBQzVCLEdBQUcsUUFBUTtnQkFDWCxVQUFVLEVBQUU7b0JBQ1YsR0FBRyxRQUFRLENBQUMsVUFBVTtvQkFDdEI7d0JBQ0UsSUFBSSxFQUFFLGVBQWU7d0JBQ3JCLGFBQWEsRUFBRSxhQUFhLENBQUMsZUFBZSxDQUFDLGFBQWE7d0JBQzFELE1BQU07d0JBQ04sUUFBUSxFQUFFLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FFakIsTUFBTSxDQUFDLEdBQUcsQ0FDUixhQUFhLENBQUMsZUFBZSxDQUVoQyxDQUFDLEdBQUcsSUFBSSxDQUFDO3FCQUNiO2lCQUNGO2FBQ0YsQ0FBQztZQUVGLE9BQU8sb0JBQW9CLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDM0MsQ0FBQztRQUNELFdBQVcsQ0FBQyxXQUFxQjtZQUMvQixNQUFNLFdBQVcsR0FBYTtnQkFDNUIsR0FBRyxRQUFRO2dCQUNYLFVBQVUsRUFBRTtvQkFDVixHQUFHLFFBQVEsQ0FBQyxVQUFVO29CQUN0QixHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLENBQUM7d0JBQ2xDLElBQUksRUFBRSxZQUFxQjt3QkFDM0IsVUFBVTtxQkFDWCxDQUFDLENBQUM7aUJBQ0o7YUFDRixDQUFDO1lBRUYsT0FBTyxvQkFBb0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUMzQyxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsb0JBQW9CLEVBQUUsQ0FBQyJ9

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,290 @@
+import { appendForwardSlash, prependForwardSlash, removeLeadingForwardSlash, } from "@astrojs/internal-helpers/path";
+import { createRedirectsFromAstroRoutes } from "@astrojs/underscore-redirects";
+import { AstroError } from "astro/errors";
+import { walk } from "estree-walker";
+import MagicString from "magic-string";
+import { createReadStream } from "node:fs";
+import { appendFile, rename, stat, unlink } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { createInterface } from "node:readline/promises";
+import { createRoutesFile, getParts } from "./utils/generate-routes-json.js";
+import { setImageConfig } from "./utils/image-config.js";
+import { mutateDynamicPageImportsInPlace, mutatePageMapInPlace, } from "./utils/index.js";
+import { NonServerChunkDetector } from "./utils/non-server-chunk-detector.js";
+import { wasmModuleLoader } from "./utils/wasm-module-loader.js";
+import { buildResolver } from "esm-resolve";
+import { fileURLToPath } from "node:url";
+export default function createIntegration(args) {
+    let _config;
+    // Initialize the unused chunk analyzer as a shared state between hooks.
+    // The analyzer is used on earlier hooks to collect information about used hooks on a Vite plugin
+    // and then later after the full build to clean up unused chunks, so it has to be shared between them.
+    const chunkAnalyzer = new NonServerChunkDetector();
+    return {
+        name: "@astrojs/cloudflare",
+        hooks: {
+            "astro:config:setup": async ({ command, config, updateConfig, logger, addMiddleware, injectRoute, }) => {
+                const aRequire = buildResolver(fileURLToPath(import.meta.url), {
+                    resolveToAbsolute: true,
+                });
+                addMiddleware({
+                    entrypoint: aRequire("./middleware"),
+                    order: "pre",
+                });
+                injectRoute({
+                    entrypoint: aRequire("./entrypoints/manifest"),
+                    pattern: "/_wix/manifest.json",
+                    prerender: true,
+                });
+                updateConfig({
+                    build: {
+                        client: new URL(`.${prependForwardSlash(appendForwardSlash(config.base))}`, config.outDir),
+                        server: new URL("./_worker.js/", config.outDir),
+                        serverEntry: "index.js",
+                        redirects: false,
+                    },
+                    vite: {
+                        // load .wasm files as WebAssembly modules
+                        plugins: [
+                            wasmModuleLoader({
+                                disabled: !args?.wasmModuleImports,
+                            }),
+                            chunkAnalyzer.getPlugin(),
+                            {
+                                name: "dynamic-imports-analyzer",
+                                enforce: "post",
+                                generateBundle(_, bundle) {
+                                    let astrojsSSRVirtualEntryAST;
+                                    const prerenderImports = [];
+                                    let entryChunk;
+                                    // Find all pages (ignore the ssr entrypoint) which are prerendered based on the dynamic imports of the prerender chunk
+                                    for (const chunk of Object.values(bundle)) {
+                                        if (chunk.type !== "chunk")
+                                            continue;
+                                        if (chunk.name === "_@astrojs-ssr-virtual-entry") {
+                                            astrojsSSRVirtualEntryAST = this.parse(chunk.code);
+                                            entryChunk = chunk;
+                                            continue;
+                                        }
+                                        const isPrerendered = chunk.dynamicImports.some((entry) => entry.includes("prerender"));
+                                        if (isPrerendered) {
+                                            prerenderImports.push(chunk.fileName);
+                                        }
+                                    }
+                                    if (!astrojsSSRVirtualEntryAST)
+                                        return;
+                                    if (!entryChunk)
+                                        return;
+                                    const s = new MagicString(entryChunk.code);
+                                    const constsToRemove = [];
+                                    walk(astrojsSSRVirtualEntryAST, {
+                                        leave(node) {
+                                            // We are only looking for VariableDeclarations, since both (dynamic imports and pageMap) are declared as constants in the code
+                                            if (node.type !== "VariableDeclaration")
+                                                return;
+                                            if (!node.declarations[0] ||
+                                                node.declarations[0].type !== "VariableDeclarator")
+                                                return;
+                                            // This function will remove the dynamic imports from the entrypoint
+                                            mutateDynamicPageImportsInPlace(node, prerenderImports, constsToRemove, s);
+                                            // This function will remove the pageMap entries which are invalid now
+                                            mutatePageMapInPlace(node, constsToRemove, s);
+                                        },
+                                    });
+                                    entryChunk.code = s.toString();
+                                },
+                            },
+                            // The plugin is used to inject the Wix SDK context into the client bundle
+                            // It's currently commented out because there are some issues with the current implementation
+                            // (currently the magic import is injected into any type of module, not only JS)
+                            // not sure if it's necessary to inject the Wix SDK context into the client bundle
+                            // wixSDKContext(),
+                        ],
+                    },
+                    image: setImageConfig(args?.imageService ?? "DEFAULT", config.image, command, logger),
+                });
+            },
+            "astro:config:done": async ({ setAdapter, config }) => {
+                _config = config;
+                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.');
+                }
+                setAdapter({
+                    name: "@astrojs/wix",
+                    serverEntrypoint: createRequire(import.meta.url).resolve("./entrypoints/server"),
+                    exports: ["default"],
+                    adapterFeatures: {
+                        functionPerRoute: false,
+                        edgeMiddleware: false,
+                    },
+                    supportedAstroFeatures: {
+                        serverOutput: "stable",
+                        hybridOutput: "stable",
+                        staticOutput: "unsupported",
+                        i18nDomains: "experimental",
+                        assets: {
+                            supportKind: "stable",
+                            isSharpCompatible: false,
+                            isSquooshCompatible: false,
+                        },
+                    },
+                });
+            },
+            "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.resolve.conditions ||= [];
+                    // We need those conditions, previous these conditions where applied at the esbuild step which we removed
+                    // https://github.com/withastro/astro/pull/7092
+                    vite.resolve.conditions.push("workerd", "worker");
+                    vite.ssr ||= {};
+                    vite.ssr.target = "webworker";
+                    vite.ssr.noExternal = true;
+                    if (typeof _config.vite.ssr?.external === "undefined")
+                        vite.ssr.external = ["node:async_hooks"];
+                    if (typeof _config.vite.ssr?.external === "boolean")
+                        vite.ssr.external = _config.vite.ssr?.external;
+                    if (Array.isArray(_config.vite.ssr?.external)) {
+                        // `@astrojs/vue` sets `@vue/server-renderer` to external
+                        // https://github.com/withastro/astro/blob/e648c5575a8774af739231cfa9fc27a32086aa5f/packages/integrations/vue/src/index.ts#L119
+                        // the cloudflare adapter needs to get all dependencies inlined, we use `noExternal` for that, but any `external` config overrides that
+                        // therefore we need to remove `@vue/server-renderer` from the external config again
+                        vite.ssr.external = _config.vite.ssr?.external.filter((entry) => entry !== "@vue/server-renderer");
+                        vite.ssr.external.push("node:async_hooks");
+                    }
+                    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 ?? [];
+                    // @ts-expect-error
+                    vite.build.rollupOptions.external.push("__STATIC_CONTENT_MANIFEST");
+                    // 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,
+                    };
+                }
+                // we thought that vite config inside `if (target === 'server')` would not apply for client
+                // but it seems like the same `vite` reference is used for both
+                // so we need to reset the previous conflicting setting
+                // in the future we should look into a more robust solution
+                if (target === "client") {
+                    vite.resolve ||= {};
+                    vite.resolve.conditions ||= [];
+                    vite.resolve.conditions = vite.resolve.conditions.filter((c) => c !== "workerd" && c !== "worker");
+                }
+            },
+            "astro:build:done": async ({ pages, routes, dir, logger }) => {
+                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;
+                }
+                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());
+                    }
+                    catch (error) {
+                        logger.error("Failed to write _redirects file");
+                    }
+                }
+                // Get chunks from the bundle that are not needed on the server and delete them
+                // Those modules are build only for prerendering routes.
+                const chunksToDelete = chunkAnalyzer.getNonServerChunks();
+                for (const chunk of chunksToDelete) {
+                    try {
+                        // Chunks are located on `./_worker.js` directory inside of the output directory
+                        await unlink(new URL(`./_worker.js/${chunk}`, _config.outDir));
+                    }
+                    catch (error) {
+                        logger.warn(`Issue while trying to delete unused file from server bundle: ${new URL(`./_worker.js/${chunk}`, _config.outDir).toString()}`);
+                    }
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareHandler } from "astro";
+export declare const onRequest: MiddlewareHandler;