eddev 2.0.0-beta.2 → 2.0.0-beta.200

package/dist/node/compiler/get-vite-config.js

@@ -0,0 +1,332 @@
+import * as t from "@babel/types";
+import replace from "@rollup/plugin-replace";
+import react from "@vitejs/plugin-react";
+import { pascalCase } from "change-case-all";
+import { withoutTrailingSlash } from "ufo";
+import { createLogger } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { cliMode } from "../cli/cli-mode.js";
+export function envPlugin(args) {
+    const envDefines = {
+        client: args.client ? "true" : "false",
+        serverless: args.serverless ? "true" : "false",
+        dev: args.mode === "development" ? "true" : "false",
+        admin: args.target === "cms" ? "true" : "false",
+        themePath: JSON.stringify(args.publicUrl),
+        devUI: args.mode === "development" ? "true" : "false",
+        serverlessOrigin: JSON.stringify("http://serverleress-endpoint"),
+        rpcEnabled: "true",
+        origin: JSON.stringify(process.env.SITE_URL ?? "/"),
+    };
+    const expandDefines = (obj, prefixes = []) => {
+        const result = {};
+        for (const prefix of prefixes) {
+            for (const [key, value] of Object.entries(obj)) {
+                result[prefix + key] = value;
+            }
+        }
+        return result;
+    };
+    const envVariables = {};
+    for (let key in process.env) {
+        if (key.startsWith("ED_PUBLIC_")) {
+            // Include all ED_PUBLIC_ variables
+            envVariables[key] = JSON.stringify(process.env[key]);
+        }
+        else if (key.startsWith("ED_")) {
+            if (!args.client) {
+                // Only include ED_ variables in non-client bundles
+                envVariables[key] = JSON.stringify(process.env[key]);
+            }
+        }
+    }
+    // console.log("Envs are", envVariables)
+    // const envFile = configDotenv()
+    // if (envFile.parsed) {
+    // }
+    return replace({
+        values: {
+            ...expandDefines(envDefines, ["process.env.", "process.", "env."]),
+            ...expandDefines(envVariables, ["process.env.", "import.meta.env."]),
+            "process.env.SITE_API_KEY": JSON.stringify(process.env.SITE_API_KEY),
+        },
+        preventAssignment: true,
+    });
+}
+export function reactPlugin(args = {}) {
+    let currentFile = null;
+    return react({
+        babel: {
+            overrides: [{ test: /types\./, compact: true }],
+            plugins: [
+                {
+                    visitor: {
+                        Program: {
+                            enter: (path, state) => {
+                                const filename = state.file.opts.filename;
+                                if (filename.match(/.\/blocks\/.+\.tsx/)) {
+                                    currentFile = { type: "block", id: filename.replace(/.*\/blocks\/(.+)\.tsx/, "$1") };
+                                }
+                                else if (filename.match(/.\/views\/.+\.tsx/)) {
+                                    currentFile = { type: "view", id: filename.replace(/.*\/views\/(.+)\.tsx/, "$1") };
+                                }
+                                else {
+                                    currentFile = null;
+                                }
+                            },
+                            exit: (path, state) => {
+                                currentFile = null;
+                                // console.log("Exiting", state.file.opts.filename)
+                            },
+                        },
+                        ExportNamedDeclaration: (path, state) => {
+                            if (!currentFile)
+                                return;
+                            const decl = path.node.declaration;
+                            if (decl?.type !== "VariableDeclaration")
+                                return;
+                            const id = decl.declarations[0].id;
+                            if (!t.isIdentifier(id))
+                                return;
+                            if (id.name === "meta") {
+                                if (args.retainBlockMeta && currentFile?.type === "block") {
+                                    // Adds a defineBlock.meta("name", meta) call, which can be used by the editor
+                                    path.replaceWith(t.callExpression(t.memberExpression(t.identifier("defineBlock"), t.identifier("meta")), [
+                                        t.stringLiteral(currentFile.id),
+                                        decl.declarations[0].init,
+                                    ]));
+                                }
+                                else {
+                                    path.remove();
+                                }
+                            }
+                        },
+                        ExportDefaultDeclaration: (path) => {
+                            if (!currentFile)
+                                return;
+                            if (path.node.declaration.type === "CallExpression") {
+                                const call = path.node.declaration;
+                                if (call.callee.type === "Identifier" && ["defineBlock", "defineView"].includes(call.callee.name)) {
+                                    const type = call.callee.name.replace("define", "");
+                                    const args = call.arguments;
+                                    if (args.length === 2 &&
+                                        args[0].type === "StringLiteral" &&
+                                        args[1].type === "ArrowFunctionExpression") {
+                                        const name = args[0].value;
+                                        let body = args[1].body;
+                                        if (t.isExpression(body)) {
+                                            body = t.blockStatement([t.returnStatement(body)]);
+                                        }
+                                        const componentName = pascalCase(type) + "_" + name.replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_");
+                                        path.replaceWithMultiple([
+                                            t.exportDefaultDeclaration(t.functionDeclaration(t.identifier(componentName), args[1].params, body, args[1].generator, args[1].async)),
+                                            t.expressionStatement(t.assignmentExpression("=", t.memberExpression(t.identifier(componentName), t.identifier("displayName")), t.stringLiteral(pascalCase(type) + "(" + name + ")"))),
+                                        ]);
+                                    }
+                                }
+                            }
+                        },
+                    },
+                },
+            ],
+        },
+    });
+}
+/**
+ * Turns on SSR module proxying,
+ */
+export function ssrPlugin() {
+    return {
+        name: "proxy-external-ssr-modules",
+        config(config) {
+            config.legacy = {
+                ...config.legacy,
+                proxySsrExternalModules: true,
+                // @ts-ignore
+                skipWebSocketTokenCheck: true,
+            };
+            config.ssr = {
+                ...config.ssr,
+                noExternal: [
+                    "eddev",
+                    "vinxi",
+                    "react-use",
+                    // @ts-ignore
+                    ...(config?.optimizeDeps?.noExternal ?? []),
+                ],
+                optimizeDeps: {
+                    exclude: ["eddev", "vinxi"],
+                },
+            };
+            config.optimizeDeps = {
+                ...config.optimizeDeps,
+                include: [
+                    "valtio",
+                    "@tanstack/react-query",
+                    "qs",
+                    "react",
+                    "react-dom/client",
+                    ...(config?.optimizeDeps?.include ?? []),
+                ],
+                exclude: ["eddev", "vinxi", ...(config?.optimizeDeps?.exclude ?? [])],
+            };
+            config.server = {
+                ...config.server,
+                allowedHosts: true,
+                cors: true,
+            };
+            return config;
+        },
+    };
+}
+function buildStatusPlugin(console) {
+    let timer = 0;
+    return {
+        name: "eddev:logging",
+        enforce: "post",
+        watchChange() {
+            console.resetLog();
+            clearTimeout(timer);
+        },
+        buildStart() {
+            clearTimeout(timer);
+            console.setWorking(true);
+        },
+        buildEnd() {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                console.setWorking(false);
+            }, 0);
+        },
+    };
+}
+export function corePlugins(args) {
+    return [
+        args.serverless && ssrPlugin(),
+        envPlugin(args),
+        tsconfigPaths(),
+        reactPlugin({ retainBlockMeta: args.target === "cms" }),
+        ignoreRollupErrorsPlugin(),
+        args.console && loggerPlugin({ console: args.console }),
+    ].flat();
+}
+export function storybookVitePlugins(args) {
+    return [args.serverless && ssrPlugin(), envPlugin(args), tsconfigPaths()].flat();
+}
+export function ignoreRollupErrorsPlugin() {
+    return {
+        name: "ignore-rollup-errors",
+        config(config) {
+            const onWarn = config.build?.rollupOptions?.onwarn;
+            return {
+                build: {
+                    rollupOptions: {
+                        onwarn(warning, warn) {
+                            if (!cliMode.verbose &&
+                                warning.code &&
+                                ["SOURCEMAP_ERROR", "UNUSED_EXTERNAL_IMPORT", "INVALID_ANNOTATION", "EVAL"].includes(warning.code)) {
+                                return;
+                            }
+                            if (warning.code) {
+                                warning.message = warning.code + ": " + warning.message;
+                            }
+                            if (onWarn) {
+                                onWarn(warning, warn);
+                            }
+                            else {
+                                warn(warning);
+                            }
+                        },
+                    },
+                },
+            };
+        },
+    };
+}
+export function loggerPlugin(args) {
+    return {
+        name: "eddev:logger",
+        config() {
+            const logger = createLogger();
+            logger.info = (msg) => {
+                if (msg.includes("hmr update"))
+                    args.console.resetLog();
+                args.console.info(msg.replace(/\n/, ""));
+            };
+            logger.warn = (msg) => {
+                if (typeof msg === "string" && msg.includes("auto-determine entry point"))
+                    return;
+                if (typeof msg === "string" && msg.includes("Error when using sourcemap for reporting"))
+                    return;
+                return args.console.warn(msg.replace(/\n/, ""));
+            };
+            logger.error = (msg) => {
+                args.console.fail(msg.replace(/\n/, ""));
+            };
+            logger.warnOnce = (msg) => {
+                args.console.warn(msg.replace(/\n/, ""));
+            };
+            logger.clearScreen = () => {
+                args.console.resetLog();
+            };
+            return {
+                customLogger: logger,
+            };
+        },
+    };
+}
+export function getViteConfig(args) {
+    const console = args.console;
+    const entryFile = `./.eddev/${args.mode === "production" ? "prod" : "dev"}-spa/entry.${args.target === "cms" ? "admin" : "client"}.tsx`;
+    /** Initial config */
+    const config = {
+        appType: "custom",
+        mode: args.mode,
+        root: args.rootDir,
+        logLevel: cliMode.verbose ? "info" : "warn",
+        base: withoutTrailingSlash(args.publicUrl) + "/dist/" + args.target,
+        define: {
+            "process.env.NODE_ENV": JSON.stringify(args.mode),
+        },
+        plugins: [
+            tsconfigPaths(),
+            envPlugin(args),
+            reactPlugin({
+                retainBlockMeta: args.target === "cms",
+            }),
+            buildStatusPlugin(console),
+            ignoreRollupErrorsPlugin(),
+            loggerPlugin({ console }),
+        ],
+        build: {
+            manifest: true,
+            sourcemap: true,
+            minify: args.target === "cms" ? false : args.mode === "production",
+            modulePreload: false,
+            outDir: args.outDir,
+            lib: args.target === "cms"
+                ? {
+                    entry: [entryFile],
+                    fileName: (format, entryName) => `${entryName}.${format}.js`,
+                    name: "eddev",
+                    formats: ["iife"],
+                }
+                : undefined,
+            rollupOptions: {
+                input: args.target === "frontend" ? entryFile : undefined,
+                external: args.target === "cms" ? ["react", "react-dom"] : [],
+                output: args.target === "cms"
+                    ? {
+                        // entryFileNames: "main.admin.js",
+                        // format: "iife",
+                        globals: {
+                            react: "window.React",
+                            "react-dom": "window.ReactDOM",
+                        },
+                    }
+                    : undefined,
+            },
+        },
+    };
+    return config;
+}

package/dist/node/compiler/vinxi-app.d.ts

@@ -0,0 +1,23 @@
+import { StatefulLog } from "../utils/stateful-log.js";
+import { EDConfig } from "../project/config.js";
+export type AppArgs = {
+    mode: "development" | "production";
+    publicUrl: string;
+    rootDir: string;
+    origin: string;
+    log?: StatefulLog<any>;
+    preset?: string;
+    routes?: CustomRoute[];
+    rpcBases?: string[];
+    config: EDConfig;
+};
+type HTTPMethod = "GET" | "POST" | "PUT" | "OPTIONS" | "HEAD";
+type CustomRouteFunction = (req: Request) => Response;
+type CustomRouteModule = Record<HTTPMethod, CustomRouteFunction>;
+type CustomRoute = {
+    pattern: string;
+    handler: () => Promise<CustomRouteModule>;
+};
+export declare function createVinxiApp(args: AppArgs): import("vinxi").App;
+export {};
+//# sourceMappingURL=vinxi-app.d.ts.map

package/dist/node/compiler/vinxi-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vinxi-app.d.ts","sourceRoot":"","sources":["../../../src/node/compiler/vinxi-app.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAGtD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,aAAa,GAAG,YAAY,CAAA;IAClC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;IACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED,KAAK,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,CAAA;AAC7D,KAAK,mBAAmB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,CAAA;AACrD,KAAK,iBAAiB,GAAG,MAAM,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAA;AAEhE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAC1C,CAAA;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,uBAiO3C"}

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

@@ -0,0 +1,230 @@
+import { joinURL } from "ufo";
+import { createApp } from "vinxi";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { StatefulLog } from "../utils/stateful-log.js";
+import { corePlugins, envPlugin } from "./get-vite-config.js";
+import { getVinxiFolder } from "./vinxi-codegen.js";
+export function createVinxiApp(args) {
+    const log = args.log ?? new StatefulLog({ label: "Build" });
+    const folder = "./.eddev/" +
+        getVinxiFolder({
+            mode: args.mode,
+            serverless: true,
+        });
+    return createApp({
+        server: {
+            // experimental: {
+            //   websocket: true,
+            // },
+            compatibilityDate: "2025-01-01",
+            preset: args.preset,
+            routeRules: {
+                "/wp-content/uploads/**": {
+                    proxy: joinURL(args.origin, "wp-content/uploads/**"),
+                    static: true,
+                    cache: {
+                        maxAge: 86400,
+                        varies: [],
+                    },
+                },
+                "/favicon.ico": {
+                    proxy: joinURL(args.origin, "favicon.ico"),
+                    static: true,
+                    cache: {
+                        maxAge: 3600,
+                        varies: [],
+                    },
+                },
+                "/robots.txt": {
+                    cache: {
+                        maxAge: 3600,
+                        varies: [],
+                    },
+                },
+                "/sitemap.xml": {
+                    cache: {
+                        maxAge: 3600,
+                        swr: true,
+                    },
+                },
+                "/sitemap*.xml": {
+                    cache: {
+                        maxAge: 3600,
+                        swr: true,
+                    },
+                },
+                "/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/**": {
+                    isr: 300,
+                    swr: true,
+                    cache: {
+                        maxAge: 300,
+                        swr: true,
+                        varies: ["Authorization", "woocommerce-session"],
+                    },
+                },
+                "/_data/query/**": {
+                    isr: 300,
+                    swr: true,
+                    cache: {
+                        maxAge: 300,
+                        varies: ["Authorization", "woocommerce-session"],
+                    },
+                },
+                ...args.rpcBases?.reduce((acc, base) => {
+                    return {
+                        ...acc,
+                        ["/" + base.replace(/(^\/|\/$)/g, "") + "/**/*"]: {
+                            isr: false,
+                            swr: false,
+                        },
+                    };
+                }, {}),
+                "/**/*": {
+                    isr: 300,
+                    swr: true,
+                    cache: {
+                        maxAge: 300,
+                        swr: true,
+                        staleMaxAge: 3600,
+                    },
+                },
+            },
+            vercel: {
+                config: {
+                    bypassToken: process.env.VERCEL_BYPASS_TOKEN,
+                },
+            },
+        },
+        routers: [
+            ...args.config.serverless.themeAssets.map((folder) => {
+                const folderName = folder
+                    .split("/")
+                    .filter((p) => !p.includes("*") && p !== ".")
+                    .join("/");
+                return {
+                    name: "public_" + folderName,
+                    type: "static",
+                    dir: args.rootDir + "/" + folderName,
+                    base: joinURL(args.publicUrl, folderName),
+                };
+            }),
+            {
+                name: "bypass-api",
+                type: "http",
+                base: "/_bypass",
+                handler: `${folder}/handler.bypass.ts`,
+                target: "server",
+                plugins: () => [
+                    tsconfigPaths(),
+                    envPlugin({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                        client: false,
+                    }),
+                ],
+            },
+            // {
+            //   name: "wp-proxy",
+            //   type: "http",
+            //   base: "/wp-",
+            //   handler: `${folder}/handler.wp-proxy.ts`,
+            //   target: "server",
+            //   plugins: () => [
+            //     ...corePlugins({
+            //       rootDir: args.rootDir,
+            //       console: log,
+            //       mode: args.mode,
+            //       publicUrl: args.publicUrl,
+            //       serverless: true,
+            //       target: "frontend",
+            //     }),
+            //   ],
+            // },
+            {
+                name: "client",
+                type: "client",
+                handler: `${folder}/entry.client.tsx`,
+                target: "browser",
+                plugins: () => [
+                    ...corePlugins({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                        client: true,
+                    }),
+                ],
+                base: "/_build",
+            },
+            {
+                name: "admin",
+                type: "client",
+                handler: `${folder}/entry.admin.tsx`,
+                target: "browser",
+                plugins: () => [
+                    ...corePlugins({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "cms",
+                        client: true,
+                    }),
+                ],
+                base: "/_admin",
+            },
+            // ...((args.rpcBases ?? []).map((base) => ({
+            //   name: "trpc" + base.replace(/^\//, "-"),
+            //   type: "http",
+            //   base: "/" + base.replace(/^\//, ""),
+            //   handler: `${folder}/handler.trpc-api.ts`,
+            //   target: "server",
+            //   plugins: () => [
+            //     tsconfigPaths(),
+            //     envPlugin({
+            //       rootDir: args.rootDir,
+            //       console: log,
+            //       mode: args.mode,
+            //       publicUrl: args.publicUrl,
+            //       serverless: true,
+            //       target: "frontend",
+            //     }),
+            //   ],
+            // })) as RouterSchemaInput[]),
+            {
+                name: "ssr",
+                type: "http",
+                handler: `${folder}/handler.ssr-page.ts`,
+                target: "server",
+                plugins: () => [
+                    ...corePlugins({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: args.mode,
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                        client: false,
+                    }),
+                ],
+            },
+        ],
+    });
+}

package/dist/node/compiler/vinxi-codegen.d.ts

@@ -0,0 +1,13 @@
+import { Project } from "../project/project.js";
+import { FSCodegen } from "../utils/fs-codegen.js";
+type Options = {
+    mode: "development" | "production";
+    serverless: boolean;
+    project: Project;
+    endpoint?: string;
+};
+export declare function getVinxiFolder(opts: Pick<Options, "mode" | "serverless">): string;
+export declare function runVinxiCodegen(opts: Options): Promise<void>;
+export declare function createVinxiCodegen(opts: Options): FSCodegen;
+export {};
+//# sourceMappingURL=vinxi-codegen.d.ts.map

package/dist/node/compiler/vinxi-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vinxi-codegen.d.ts","sourceRoot":"","sources":["../../../src/node/compiler/vinxi-codegen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAIlD,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,aAAa,GAAG,YAAY,CAAA;IAClC,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAAC,UAExE;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,OAAO,iBAIlD;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,aAkuB/C"}