eddev 2.3.31 → 2.4.0-beta.2

package/dist/node/compiler/serverless-app.js

@@ -0,0 +1,332 @@
+import glsl from "vite-plugin-glsl";
+import { nitro } from "nitro/vite";
+import { join } from "node:path";
+import { joinURL } from "ufo";
+import { cliMode } from "../cli/cli-mode.js";
+import { getAppFolder } from "./app-codegen.js";
+import { getCacheConfig } from "./cache-config.js";
+import { collectDevStylesheets, cssLinkHmrPlugin } from "./dev-css-links.js";
+import { baseConfigPlugin, corePlugins, createBuildStatusTracker, envPlugin, ignoreRollupErrorsPlugin, loggerPlugin, reactPlugin, workersPlugin, } from "./get-vite-config.js";
+/**
+ * The Vite environments that make up the serverless app (Nitro adds its own `nitro` environment):
+ * - `client`: the public site in the browser, served from `/_build/`
+ * - `admin`: the WordPress editor bundle for proxied wp-admin pages, served from `/_admin/`
+ * - `ssr`: the server entry, rendering pages and handling data/RPC requests
+ *
+ * In dev, `admin` runs as a separate Vite server mounted at `/_admin/` instead, because a dev server
+ * only serves its `client` environment to browsers (see `adminDevServerPlugin`).
+ */
+export const SERVERLESS_ENVIRONMENTS = ["client", "admin", "ssr"];
+/**
+ * Dev only: lets the server runtime (which runs in the same process, via Nitro's `self` runner) ask the
+ * admin dev server for the admin bundle's stylesheets. Read by the generated `manifest/assets.ts`.
+ */
+export const ADMIN_DEV_STYLESHEETS_HOOK = "__EDDEV_ADMIN_DEV_STYLESHEETS__";
+/** URL prefix for the admin bundle (`assetsDir` in builds, the admin dev server's `base` in dev). */
+const ADMIN_BASE = "/_admin/";
+/** The bundle settings used by eddev's shared plugins, per environment. */
+function getEnvironmentArgs(args, environment) {
+    const shared = {
+        mode: args.mode,
+        serverless: true,
+        rootDir: args.rootDir,
+        publicUrl: args.publicUrl,
+        console: args.log,
+    };
+    switch (environment) {
+        case "client":
+            return { ...shared, target: "frontend", client: true };
+        case "admin":
+            return { ...shared, target: "cms", client: true };
+        case "ssr":
+            return { ...shared, target: "frontend", client: false };
+        default:
+            return null;
+    }
+}
+function getTransformTargetForEnvironment(environment) {
+    if (environment === "admin")
+        return "cms";
+    if (environment === "client")
+        return "frontend";
+    return "server";
+}
+/**
+ * Compile-time `env.*` values differ per environment (eg. `env.client`, `env.admin`), so the replace
+ * plugin is instantiated separately for each one. Nitro's own environment is left alone.
+ */
+function environmentEnvPlugin(args) {
+    return {
+        name: "eddev:env-per-environment",
+        applyToEnvironment(environment) {
+            const envArgs = getEnvironmentArgs(args, environment.name);
+            return envArgs ? envPlugin(envArgs) : false;
+        },
+    };
+}
+/** Build status for the CLI, tracked per environment (production builds only). */
+function environmentBuildStatusPlugin(status) {
+    return {
+        name: "eddev:build-status",
+        apply: "build",
+        buildStart() {
+            status.start(this.environment.name);
+        },
+        buildEnd(error) {
+            if (error)
+                status.end(this.environment.name, true);
+        },
+        writeBundle() {
+            status.end(this.environment.name);
+        },
+    };
+}
+/**
+ * In dev, serves the admin bundle from a second Vite server (in middleware mode) under `/_admin/`.
+ * It shares the main server's HTTP server for HMR, on its own websocket path.
+ */
+function adminDevServerPlugin(args) {
+    let admin;
+    return {
+        name: "eddev:admin-dev-server",
+        apply: "serve",
+        async configureServer(server) {
+            const { createServer } = await import("vite");
+            const adminArgs = getEnvironmentArgs(args, "admin");
+            admin = await createServer({
+                configFile: false,
+                root: args.rootDir,
+                mode: args.mode,
+                base: ADMIN_BASE,
+                appType: "custom",
+                publicDir: false,
+                // A separate dependency cache, so the two dev servers don't overwrite each other's optimized deps
+                cacheDir: "node_modules/.vite/eddev-admin",
+                logLevel: cliMode.verbose ? "info" : "warn",
+                plugins: [...corePlugins({ ...adminArgs, logLabel: "admin" }), cssLinkHmrPlugin()],
+                server: {
+                    middlewareMode: true,
+                    hmr: server.httpServer ? { server: server.httpServer } : undefined,
+                    allowedHosts: true,
+                    cors: true,
+                },
+            });
+            server.middlewares.use((req, res, next) => {
+                if (req.url?.startsWith(ADMIN_BASE)) {
+                    admin.middlewares(req, res, next);
+                }
+                else {
+                    next();
+                }
+            });
+            // Link the admin bundle's stylesheets in the head of proxied wp-admin pages, so blocks don't
+            // render before their CSS. See cssLinkHmrPlugin() for how these links hot reload.
+            const entryUrl = `/.eddev/${getAppFolder({ mode: args.mode, serverless: true })}/entry.admin.tsx`;
+            globalThis[ADMIN_DEV_STYLESHEETS_HOOK] = async () => {
+                const stylesheets = await collectDevStylesheets(admin.environments.client, entryUrl);
+                return stylesheets.map((sheet) => ({ href: joinURL(ADMIN_BASE, sheet.url), "data-vite-dev-id": sheet.id }));
+            };
+            server.httpServer?.once("close", () => {
+                delete globalThis[ADMIN_DEV_STYLESHEETS_HOOK];
+                admin?.close();
+            });
+        },
+    };
+}
+/**
+ * Route rules for the Nitro server: WordPress proxies, and Vercel ISR for pages and data.
+ *
+ * Nitro's `cache`/`static` rules are deliberately not used. Under Vinxi (Nitro v2) they had no effect on
+ * eddev's handlers, but Nitro v3 applies them, which would add a server-side page cache and
+ * `Cache-Control: public` headers. Data caching is handled by eddev itself (see `serverless.dataCache`).
+ */
+function getRouteRules(args) {
+    const cacheConfig = getCacheConfig(args.origin, args.config);
+    const serverlessDataRoute = (expiration) => cacheConfig.serverless.isr
+        ? {
+            isr: {
+                expiration,
+                allowQuery: [],
+                passQuery: false,
+            },
+            headers: {
+                "Vercel-Cache-Tag": "data",
+            },
+        }
+        : {
+            isr: false,
+        };
+    const serverlessPageRoute = (expiration) => cacheConfig.serverless.isr
+        ? {
+            isr: {
+                expiration,
+                allowQuery: [],
+                passQuery: false,
+            },
+            headers: {
+                "Vercel-Cache-Tag": "data",
+            },
+        }
+        : {
+            isr: false,
+        };
+    return {
+        "/wp-content/uploads/**": {
+            proxy: joinURL(args.origin, "wp-content/uploads/**"),
+            headers: {
+                "Cache-Control": "max-age=86400",
+                "CDN-Cache-Control": "max-age=86400",
+                "Vercel-CDN-Cache-Control": "max-age=86400",
+            },
+        },
+        "/wp-content/plugins/**": {
+            proxy: joinURL(args.origin, "wp-content/plugins/**"),
+            headers: {
+                "Cache-Control": "max-age=86400",
+                "CDN-Cache-Control": "max-age=86400",
+                "Vercel-CDN-Cache-Control": "max-age=86400",
+            },
+        },
+        "/wp-content/**": { proxy: joinURL(args.origin, "wp-content/**") },
+        "/wp-includes/**": { proxy: joinURL(args.origin, "wp-includes/**") },
+        "/_data/route/**": serverlessDataRoute(cacheConfig.pageDataTTL ?? 0),
+        "/_data/query/**": serverlessDataRoute(cacheConfig.queryHooksTTL ?? 0),
+        "/_data/mutation/**": { isr: false },
+        "/_data/submit-gf": { isr: false },
+        "/_bypass/**": { isr: false },
+        ...Object.fromEntries((args.rpcBases ?? []).map((base) => ["/" + base.replace(/(^\/|\/$)/g, "") + "/**", { isr: false }])),
+        "/": serverlessPageRoute(cacheConfig.pageDataTTL ?? 0),
+        "/**": serverlessPageRoute(cacheConfig.pageDataTTL ?? 0),
+    };
+}
+function getNitroConfig(args) {
+    // Builds are written inside `.eddev`, except for platforms that require a fixed location
+    // (Vercel's `.vercel/output`, Netlify's `.netlify`). Cloudflare finds its output through the
+    // `.wrangler/deploy/config.json` redirect that Nitro writes, so it can live in `.eddev` too.
+    const hasFixedOutput = !!args.preset && /^(vercel|netlify)/.test(args.preset);
+    return {
+        preset: args.preset,
+        compatibilityDate: "2026-09-01",
+        // eddev provides the server entry; don't scan `server/` (that's for RPC routes, handled by eddev).
+        serverDir: false,
+        buildDir: ".eddev/nitro",
+        ...(hasFixedOutput ? {} : { output: { dir: ".eddev/output" } }),
+        publicAssets: args.config.serverless.themeAssets.map((folder) => {
+            const folderName = folder
+                .split("/")
+                .filter((p) => !p.includes("*") && p !== ".")
+                .join("/");
+            return {
+                dir: join(args.rootDir, folderName),
+                baseURL: joinURL(args.publicUrl, folderName),
+                // As with Vinxi: missing files fall through to the app, and (since these files aren't
+                // content-hashed) they don't get long-lived `immutable` caching on Vercel.
+                fallthrough: true,
+            };
+        }),
+        routeRules: getRouteRules(args),
+        vercel: {
+            config: {
+                version: 3,
+                bypassToken: process.env.VERCEL_BYPASS_TOKEN,
+            },
+            // eddev sets its own (JS-readable) __vdpl cookie, see createServerApp()
+            skewProtection: false,
+        },
+        devServer: {
+            // Run the dev server in-process, so server logs go through the CLI's log display.
+            runner: "self",
+        },
+    };
+}
+/**
+ * The Vite config for the serverless app, used by both `eddev dev` and `eddev build --serverless`.
+ */
+export function getServerlessViteConfig(args) {
+    const dev = args.mode === "development";
+    const folder = "./.eddev/" + getAppFolder({ mode: args.mode, serverless: true });
+    const status = createBuildStatusTracker(args.log);
+    const environmentsToBuild = SERVERLESS_ENVIRONMENTS.filter((name) => !(dev && name === "admin"));
+    const clientOptimizeDeps = {
+        include: ["valtio", "valtio/utils", "@tanstack/react-query", "qs", "react", "react-dom/client"],
+        exclude: ["eddev"],
+    };
+    const plugins = [
+        dev && adminDevServerPlugin(args),
+        nitro(getNitroConfig(args)),
+        glsl({ root: args.rootDir }),
+        baseConfigPlugin(),
+        environmentEnvPlugin(args),
+        reactPlugin({ target: getTransformTargetForEnvironment }),
+        ignoreRollupErrorsPlugin(),
+        workersPlugin(),
+        loggerPlugin({ console: args.log }),
+        !dev && environmentBuildStatusPlugin(status),
+    ];
+    return {
+        configFile: false,
+        root: args.rootDir,
+        mode: args.mode,
+        base: "/",
+        appType: "custom",
+        publicDir: false,
+        logLevel: cliMode.verbose ? "info" : "warn",
+        define: {
+            "process.env.NODE_ENV": JSON.stringify(args.mode),
+        },
+        plugins,
+        legacy: {
+            skipWebSocketTokenCheck: true,
+        },
+        server: {
+            allowedHosts: true,
+            cors: true,
+        },
+        environments: {
+            client: {
+                optimizeDeps: clientOptimizeDeps,
+                build: {
+                    // Nitro reads `rollupOptions.input` to discover entries
+                    rollupOptions: { input: `${folder}/entry.client.tsx` },
+                    assetsDir: "_build",
+                    sourcemap: true,
+                },
+            },
+            ...(dev
+                ? {}
+                : {
+                    admin: {
+                        consumer: "client",
+                        optimizeDeps: clientOptimizeDeps,
+                        build: {
+                            rollupOptions: {
+                                input: `${folder}/entry.admin.tsx`,
+                                // Fixed name, so proxied wp-admin pages can load it without a manifest lookup
+                                output: { entryFileNames: "_admin/entry.admin.js" },
+                            },
+                            assetsDir: "_admin",
+                            sourcemap: true,
+                        },
+                    },
+                }),
+            ssr: {
+                resolve: {
+                    // eddev relies on compile-time `env.*` replacement, so it must be bundled rather than externalized
+                    noExternal: ["eddev", "react-use"],
+                },
+                build: {
+                    rollupOptions: { input: `${folder}/entry.server.ts` },
+                    // Keep the server's own copies of CSS/assets away from the theme's `/assets` folder
+                    assetsDir: "_ssr",
+                    sourcemap: true,
+                },
+            },
+        },
+        builder: {
+            // Build the client, admin and server bundles in parallel. Nitro then bundles the server output.
+            async buildApp(builder) {
+                await Promise.all(environmentsToBuild.map((name) => builder.build(builder.environments[name])));
+            },
+        },
+    };
+}

package/dist/node/compiler/transforms/block-meta.d.ts

@@ -0,0 +1,10 @@
+import type { SourceTransform } from "./types.js";
+/**
+ * Handles `export const meta = { ... }` in blocks and views.
+ *
+ * The meta object is consumed by the CLI at build time (block manifest, ed.dist.json), so it is
+ * normally stripped from bundles. In the `cms` target, block meta is kept and registered with
+ * `defineBlock.meta("<file name>", meta)` so the editor can read it at runtime.
+ */
+export declare const blockMetaTransform: SourceTransform;
+//# sourceMappingURL=block-meta.d.ts.map

package/dist/node/compiler/transforms/block-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-meta.d.ts","sourceRoot":"","sources":["../../../../src/node/compiler/transforms/block-meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAiBhC,CAAA"}

package/dist/node/compiler/transforms/block-meta.js

@@ -0,0 +1,27 @@
+/**
+ * Handles `export const meta = { ... }` in blocks and views.
+ *
+ * The meta object is consumed by the CLI at build time (block manifest, ed.dist.json), so it is
+ * normally stripped from bundles. In the `cms` target, block meta is kept and registered with
+ * `defineBlock.meta("<file name>", meta)` so the editor can read it at runtime.
+ */
+export const blockMetaTransform = {
+    name: "block-meta",
+    visitor: ({ s, code, kind, name, target }) => ({
+        ExportNamedDeclaration(node) {
+            const decl = node.declaration;
+            if (decl?.type !== "VariableDeclaration")
+                return;
+            const declarator = decl.declarations[0];
+            if (declarator?.id?.type !== "Identifier" || declarator.id.name !== "meta")
+                return;
+            if (target === "cms" && kind === "block" && declarator.init) {
+                const init = code.slice(declarator.init.start, declarator.init.end);
+                s.overwrite(node.start, node.end, `defineBlock.meta(${JSON.stringify(name)}, ${init});`);
+            }
+            else {
+                s.remove(node.start, node.end);
+            }
+        },
+    }),
+};

package/dist/node/compiler/transforms/component-names.d.ts

@@ -0,0 +1,19 @@
+import type { SourceTransform } from "./types.js";
+/**
+ * Rewrites `export default defineBlock("name", (props) => ...)` (and `defineView`) into a named
+ * function declaration with a `displayName`, so React DevTools and error stacks show
+ * `Block(name)` / `View(name)` instead of an anonymous component.
+ *
+ * ```tsx
+ * export default defineBlock("hero/main", (props) => <div />)
+ * // becomes
+ * export default function Block_hero_main(props) { return <div /> }
+ * Block_hero_main.displayName = "Block(hero/main)"
+ * ```
+ *
+ * Only the exact two-argument form with a string literal and an arrow function is rewritten.
+ * The arrow's return type annotation and type parameters are dropped, matching the previous Babel
+ * implementation.
+ */
+export declare const componentNamesTransform: SourceTransform;
+//# sourceMappingURL=component-names.d.ts.map

package/dist/node/compiler/transforms/component-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-names.d.ts","sourceRoot":"","sources":["../../../../src/node/compiler/transforms/component-names.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,EAAE,eA+BrC,CAAA"}

package/dist/node/compiler/transforms/component-names.js

@@ -0,0 +1,45 @@
+import { pascalCase } from "change-case-all";
+/**
+ * Rewrites `export default defineBlock("name", (props) => ...)` (and `defineView`) into a named
+ * function declaration with a `displayName`, so React DevTools and error stacks show
+ * `Block(name)` / `View(name)` instead of an anonymous component.
+ *
+ * ```tsx
+ * export default defineBlock("hero/main", (props) => <div />)
+ * // becomes
+ * export default function Block_hero_main(props) { return <div /> }
+ * Block_hero_main.displayName = "Block(hero/main)"
+ * ```
+ *
+ * Only the exact two-argument form with a string literal and an arrow function is rewritten.
+ * The arrow's return type annotation and type parameters are dropped, matching the previous Babel
+ * implementation.
+ */
+export const componentNamesTransform = {
+    name: "component-names",
+    visitor: ({ s, code }) => ({
+        ExportDefaultDeclaration(node) {
+            const call = node.declaration;
+            if (call?.type !== "CallExpression" || call.callee?.type !== "Identifier")
+                return;
+            if (call.callee.name !== "defineBlock" && call.callee.name !== "defineView")
+                return;
+            if (call.arguments.length !== 2)
+                return;
+            const [nameArg, fn] = call.arguments;
+            if (nameArg.type !== "Literal" || typeof nameArg.value !== "string")
+                return;
+            if (fn.type !== "ArrowFunctionExpression")
+                return;
+            const type = pascalCase(call.callee.name.replace("define", ""));
+            const name = nameArg.value;
+            const componentName = type + "_" + name.replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_");
+            const params = fn.params.length ? code.slice(fn.params[0].start, fn.params[fn.params.length - 1].end) : "";
+            const body = fn.body.type === "BlockStatement"
+                ? code.slice(fn.body.start, fn.body.end)
+                : `{\n  return ${code.slice(fn.body.start, fn.body.end)}\n}`;
+            s.overwrite(node.start, node.end, `export default ${fn.async ? "async " : ""}function ${componentName}(${params}) ${body}\n` +
+                `${componentName}.displayName = ${JSON.stringify(type + "(" + name + ")")};`);
+        },
+    }),
+};

package/dist/node/compiler/transforms/index.d.ts

@@ -0,0 +1,36 @@
+import MagicString from "magic-string";
+import type { Plugin } from "vite";
+import type { SourceFileKind, SourceTransform, TransformTarget } from "./types.js";
+export type { SourceTransform, SourceTransformContext, TransformTarget } from "./types.js";
+/**
+ * The built-in transforms, in the order their handlers run for each node.
+ * Add new transforms here.
+ */
+export declare const defaultTransforms: SourceTransform[];
+/** Classify a module id as a block or view, using the last `/blocks/` or `/views/` segment. */
+export declare function getSourceFileInfo(id: string): {
+    kind: SourceFileKind;
+    name: string;
+} | null;
+export type TransformResult = {
+    code: string;
+    map: ReturnType<MagicString["generateMap"]>;
+} | null;
+/**
+ * Run the transforms over a single block or view file. Returns null when nothing changed.
+ * Exposed separately from the plugin so it can be unit tested.
+ */
+export declare function transformSource(id: string, code: string, target: TransformTarget, transforms?: SourceTransform[]): TransformResult;
+export type TransformsPluginOptions = {
+    /**
+     * The target for the modules being compiled. Pass a function when one Vite instance builds
+     * several environments (eg. the serverless app, where `admin` is `cms` and `ssr` is `server`).
+     */
+    target: TransformTarget | ((environmentName: string) => TransformTarget);
+    transforms?: SourceTransform[];
+};
+/**
+ * Applies eddev's source transforms to block and view files, before JSX/TypeScript are compiled.
+ */
+export declare function transformsPlugin(options: TransformsPluginOptions): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/node/compiler/transforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/node/compiler/transforms/index.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,cAAc,CAAA;AAEtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAGlC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAA0B,eAAe,EAAmB,MAAM,YAAY,CAAA;AAE3H,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE1F;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,EAAkD,CAAA;AAEjG,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAS3F;AAiBD,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAA;CAAE,GAAG,IAAI,CAAA;AAElG;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,UAAU,GAAE,eAAe,EAAsB,GAChD,eAAe,CAqBjB;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;OAGG;IACH,MAAM,EAAE,eAAe,GAAG,CAAC,CAAC,eAAe,EAAE,MAAM,KAAK,eAAe,CAAC,CAAA;IACxE,UAAU,CAAC,EAAE,eAAe,EAAE,CAAA;CAC/B,CAAA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,MAAM,CAezE"}

package/dist/node/compiler/transforms/index.js

@@ -0,0 +1,80 @@
+import MagicString from "magic-string";
+import { parseSync, Visitor } from "vite";
+import { blockMetaTransform } from "./block-meta.js";
+import { componentNamesTransform } from "./component-names.js";
+/**
+ * The built-in transforms, in the order their handlers run for each node.
+ * Add new transforms here.
+ */
+export const defaultTransforms = [blockMetaTransform, componentNamesTransform];
+/** Classify a module id as a block or view, using the last `/blocks/` or `/views/` segment. */
+export function getSourceFileInfo(id) {
+    const file = id.replace(/[?#].*$/, "");
+    if (file.includes("/node_modules/"))
+        return null;
+    // Greedy `.*` so the last matching folder wins, as the previous Babel implementation did.
+    const block = file.match(/.*\/blocks\/(.+)\.tsx$/);
+    if (block)
+        return { kind: "block", name: block[1] };
+    const view = file.match(/.*\/views\/(.+)\.tsx$/);
+    if (view)
+        return { kind: "view", name: view[1] };
+    return null;
+}
+function combineVisitors(handlerSets) {
+    const combined = {};
+    for (const handlers of handlerSets) {
+        for (const [type, handler] of Object.entries(handlers)) {
+            ;
+            (combined[type] ??= []).push(handler);
+        }
+    }
+    return Object.fromEntries(Object.entries(combined).map(([type, handlers]) => [
+        type,
+        handlers.length === 1 ? handlers[0] : (node) => handlers.forEach((handler) => handler(node)),
+    ]));
+}
+/**
+ * Run the transforms over a single block or view file. Returns null when nothing changed.
+ * Exposed separately from the plugin so it can be unit tested.
+ */
+export function transformSource(id, code, target, transforms = defaultTransforms) {
+    const info = getSourceFileInfo(id);
+    if (!info)
+        return null;
+    const base = { id: id.replace(/[?#].*$/, ""), code, kind: info.kind, name: info.name, target };
+    const active = transforms.filter((t) => t.applies?.(base) ?? true);
+    if (!active.length)
+        return null;
+    const { program, errors } = parseSync(base.id, code, { sourceType: "module" });
+    const fatal = errors.filter((e) => e.severity === "Error");
+    if (fatal.length) {
+        // Leave the file untouched; the regular transform pipeline will report the syntax error.
+        return null;
+    }
+    const s = new MagicString(code);
+    const ctx = { ...base, ast: program, s };
+    new Visitor(combineVisitors(active.map((t) => t.visitor(ctx)))).visit(program);
+    if (!s.hasChanged())
+        return null;
+    return { code: s.toString(), map: s.generateMap({ hires: "boundary", source: base.id, includeContent: true }) };
+}
+/**
+ * Applies eddev's source transforms to block and view files, before JSX/TypeScript are compiled.
+ */
+export function transformsPlugin(options) {
+    const transforms = options.transforms ?? defaultTransforms;
+    return {
+        name: "eddev:transforms",
+        enforce: "pre",
+        transform: {
+            filter: {
+                id: { include: [/\/(blocks|views)\/.+\.tsx(?:$|\?)/], exclude: [/\/node_modules\//] },
+            },
+            handler(code, id) {
+                const target = typeof options.target === "function" ? options.target(this.environment.name) : options.target;
+                return transformSource(id, code, target, transforms);
+            },
+        },
+    };
+}

package/dist/node/compiler/transforms/types.d.ts

@@ -0,0 +1,48 @@
+import type MagicString from "magic-string";
+import type { ESTree } from "vite";
+type Program = ESTree.Program;
+/**
+ * Which bundle a module is being compiled for.
+ * - `cms`: the WordPress admin/editor bundle
+ * - `frontend`: the public site, in the browser
+ * - `server`: the public site, rendered on the server (SSR)
+ */
+export type TransformTarget = "cms" | "frontend" | "server";
+/** The kind of eddev source file being transformed. */
+export type SourceFileKind = "block" | "view";
+export type SourceTransformContext = {
+    /** Absolute module id, without any query string */
+    id: string;
+    /** The original source code */
+    code: string;
+    /** The parsed program (ESTree-compatible, with TypeScript nodes) */
+    ast: Program;
+    /**
+     * Shared output buffer. Transforms must only edit ranges they own, because
+     * MagicString cannot re-edit a range that another transform has overwritten.
+     */
+    s: MagicString;
+    kind: SourceFileKind;
+    /**
+     * The file-derived name, relative to the `blocks/` or `views/` folder and without extension.
+     * For example `blocks/hero/carousel.tsx` → `hero/carousel`.
+     */
+    name: string;
+    target: TransformTarget;
+};
+/** Handlers keyed by ESTree node type, as accepted by Vite's (oxc) `Visitor`. */
+export type VisitorHandlers = Record<string, (node: any) => void>;
+/**
+ * A small source transform, run as part of the `eddev:transforms` Vite plugin.
+ *
+ * Each file is parsed once and walked once; the visitors of every applicable
+ * transform are combined into a single walk.
+ */
+export type SourceTransform = {
+    name: string;
+    /** Return false to skip this transform for a particular file/target. Defaults to always applying. */
+    applies?: (ctx: Omit<SourceTransformContext, "ast" | "s">) => boolean;
+    visitor: (ctx: SourceTransformContext) => VisitorHandlers;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/node/compiler/transforms/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/node/compiler/transforms/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,KAAK,OAAO,GAAG,MAAM,CAAC,OAAO,CAAA;AAE7B;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,CAAA;AAE3D,uDAAuD;AACvD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,CAAA;AAE7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAA;IACV,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,oEAAoE;IACpE,GAAG,EAAE,OAAO,CAAA;IACZ;;;OAGG;IACH,CAAC,EAAE,WAAW,CAAA;IACd,IAAI,EAAE,cAAc,CAAA;IACpB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,eAAe,CAAA;CACxB,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC,CAAA;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,qGAAqG;IACrG,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,sBAAsB,EAAE,KAAK,GAAG,GAAG,CAAC,KAAK,OAAO,CAAA;IACrE,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,eAAe,CAAA;CAC1D,CAAA"}

package/dist/node/compiler/transforms/types.js

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

package/dist/node/project/config.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Project } from "./project.js";
+import type { Project } from "./project.js";
 export declare const EDCacheConfigSchema: z.ZodObject<{
     wordpress: z.ZodDefault<z.ZodObject<{
         cacheHeaders: z.ZodDefault<z.ZodBoolean>;

package/dist/node/project/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;iBAmB9B,CAAA;AAqBF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;2BAwChC,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAclB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;iBAmB9B,CAAA;AAqBF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;2BAwChC,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAclB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}

package/dist/node/project/config.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { cliMode } from "../cli/cli-mode.js";
 import { fs } from "../utils/fs.js";
 import { isDeploying } from "../utils/is-deploying.js";
-import { projectLog as console } from "./project.js";
+import { projectLog as console } from "./project-log.js";
 export const EDCacheConfigSchema = z.object({
     wordpress: z
         .object({

package/dist/node/project/env.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { cliMode } from "../cli/cli-mode.js";
-import { projectLog as console } from "./project.js";
+import { projectLog as console } from "./project-log.js";
 import { formatZodError } from "../utils/format-zod-error.js";
 const portNumber = z
     .string()