eddev 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/node/cli/display/CLIApp.d.ts

@@ -2,7 +2,7 @@ import type { graphqlLog } from "../../graphql/graphql-codegen.js";
 import type { Project, projectLog } from "../../project/project.js";
 import type { adminLog } from "../../compiler/bundler.admin.js";
 import type { frontendLog } from "../../compiler/bundler.frontend.js";
-import { serverlessLog } from "../../compiler/serverless.dev.js";
+import { serverlessLog } from "../../compiler/dev-server.js";
 export type CLIDisplayProps = {
     getProject: () => Project;
     logs: {

package/dist/node/cli/display/CLIApp.js

@@ -5,7 +5,7 @@ import { VERSION } from "../version.js";
 import { LogEntries, LogItem } from "./components/LogEntries.js";
 import { useStatefulLogs } from "./hooks/useStatefulLog.js";
 import { statusColor, statusIcon } from "./util/colors.js";
-import { serverlessLog } from "../../compiler/serverless.dev.js";
+import { serverlessLog } from "../../compiler/dev-server.js";
 import { useEffect, useState } from "react";
 import TextInput from "./components/TextInput.js";
 import { findTools } from "./tools/cli-tools.js";

package/dist/node/cli/display/components/LogEntries.d.ts

@@ -1,4 +1,4 @@
-import type { LogEntry, LogGroup, LogGroupOrEntry } from "../../../utils/statefulLog.js";
+import type { LogEntry, LogGroup, LogGroupOrEntry } from "../../../utils/stateful-log.js";
 export declare function LogEntries(props: {
     entries: LogGroupOrEntry[];
 }): import("react/jsx-runtime").JSX.Element;

package/dist/node/cli/display/hooks/useStatefulLog.d.ts

@@ -1,4 +1,4 @@
-import { StatefulLog } from "../../../utils/statefulLog.js";
+import { StatefulLog } from "../../../utils/stateful-log.js";
 export type LogInfo<T extends StatefulLog<any> | undefined> = {
     label: string;
     value: Exclude<T, undefined>["state"];

package/dist/node/cli/display/util/colors.d.ts

@@ -1,4 +1,4 @@
-import { LogStatus } from "../../../utils/statefulLog.js";
-export declare function statusColor(status: LogStatus): "greenBright" | "redBright" | "blueBright" | "whiteBright" | "#FF890C" | "#0C86FF" | "grayBright";
+import { LogStatus } from "../../../utils/stateful-log.js";
+export declare function statusColor(status: LogStatus): "greenBright" | "redBright" | "#FF890C" | "blueBright" | "#0C86FF" | "grayBright" | "whiteBright";
 export declare function statusIcon(status: LogStatus): "✖" | "✔" | "⚠" | "ℹ" | "⚙" | "v" | "?" | "➜";
 export declare function statusLabel(status: LogStatus): "Error" | "Warning" | "Info" | "Working" | "Fail" | "Success" | "Verbose" | "Help" | "Log";

package/dist/node/cli/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.0.0";
+export declare const VERSION = "2.0.0-beta.11";

package/dist/node/cli/version.js

@@ -1 +1 @@
-export const VERSION = "2.0.0";
+export const VERSION = "2.0.0-beta.11";

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

@@ -0,0 +1,8 @@
+import { Project } from "../project/project.js";
+import { StatefulLog } from "../utils/stateful-log.js";
+type Options = {
+    project: Project;
+    console: StatefulLog<any>;
+};
+export declare function buildVinxi(opts: Options): Promise<void>;
+export {};

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

@@ -0,0 +1,37 @@
+import { code } from "ts-poet";
+import { createVinxiApp } from "./vinxi-app.js";
+import { createVinxiCodegen } from "./vinxi-codegen.js";
+export async function buildVinxi(opts) {
+    const { project, console } = opts;
+    const preset = process.env.TARGET ??
+        process.env.PRESET ??
+        process.env.SERVER_PRESET ??
+        process.env.SERVER_TARGET ??
+        process.env.NITRO_PRESET ??
+        process.env.NITRO_TARGET ??
+        (process.env.VERCEL ? "vercel" : undefined) ??
+        (process.versions.bun !== undefined ? "bun" : "node-server");
+    const appConf = {
+        mode: "production",
+        origin: project.origin,
+        publicUrl: project.publicUrl,
+        rootDir: project.rootDir,
+        // log: console,
+        preset,
+    };
+    const codegen = createVinxiCodegen({
+        mode: "production",
+        project: project,
+        serverless: true,
+    });
+    codegen.registerFile({
+        name: "../../app.config.mjs",
+        generate: code /* ts */ `
+      import { createVinxiApp } from 'eddev/_internal/create-vinxi-app.js'
+      export default createVinxiApp(${JSON.stringify(appConf)})
+    `,
+    });
+    await codegen.runAndWatch();
+    const app = createVinxiApp(appConf);
+    await app.build();
+}

package/dist/node/compiler/bundler.admin.d.ts

@@ -1,5 +1,5 @@
 import { Project } from "../project/project.js";
-export declare const adminLog: import("../utils/statefulLog.js").StatefulLog<unknown>;
+export declare const adminLog: import("../utils/stateful-log.js").StatefulLog<unknown>;
 type Options = {
     mode: "development" | "production";
     watch?: boolean;

package/dist/node/compiler/bundler.admin.js

@@ -1,7 +1,7 @@
 import { relative } from "path";
 import { build, defineConfig, mergeConfig } from "vite";
-import { createConsole } from "../utils/statefulLog.js";
-import { getViteConfig } from "./vite/get-vite-config.js";
+import { createConsole } from "../utils/stateful-log.js";
+import { getViteConfig } from "./get-vite-config.js";
 const console = createConsole("Admin Bundle", "admin");
 export const adminLog = console;
 export class AdminBundler {
@@ -17,7 +17,7 @@ export class AdminBundler {
         const baseConfig = getViteConfig({
             console,
             mode: this.opts.mode,
-            project: this.project,
+            publicUrl: this.project.publicUrl,
             rootDir: this.project.rootDir,
             outDir: relative(this.project.rootDir, "./dist/cms/"),
             serverless: false,

package/dist/node/compiler/bundler.frontend.d.ts

@@ -1,5 +1,5 @@
 import { Project } from "../project/project.js";
-export declare const frontendLog: import("../utils/statefulLog.js").StatefulLog<unknown>;
+export declare const frontendLog: import("../utils/stateful-log.js").StatefulLog<unknown>;
 type Options = {
     mode: "development" | "production";
     watch?: boolean;

package/dist/node/compiler/bundler.frontend.js

@@ -1,7 +1,7 @@
 import { relative } from "path";
 import { build, defineConfig, mergeConfig } from "vite";
-import { createConsole } from "../utils/statefulLog.js";
-import { getViteConfig } from "./vite/get-vite-config.js";
+import { createConsole } from "../utils/stateful-log.js";
+import { getViteConfig } from "./get-vite-config.js";
 const console = createConsole("Frontend Bundler", "spa");
 export const frontendLog = console;
 export class FrontendBundler {
@@ -17,7 +17,7 @@ export class FrontendBundler {
         const baseConfig = getViteConfig({
             console,
             mode: this.opts.mode,
-            project: this.project,
+            publicUrl: this.project.publicUrl,
             rootDir: this.project.rootDir,
             outDir: relative(this.project.rootDir, "./dist/frontend/"),
             serverless: false,

package/dist/node/compiler/{serverless.dev.d.ts → dev-server.d.ts}

@@ -3,13 +3,15 @@ export type ServerlessDevStatus = {
     serverlessUrl: string;
     wordpressUrl: string;
 };
-export declare const serverlessLog: import("../utils/statefulLog.js").StatefulLog<ServerlessDevStatus>;
-type Options = {
-    mode: "development" | "production";
-};
-export declare class ServerlessDevServer {
+export declare const serverlessLog: import("../utils/stateful-log.js").StatefulLog<ServerlessDevStatus>;
+type Options = {};
+export declare class DevServer {
     project: Project;
     opts: Options;
+    origin: string;
+    hostname: string;
+    hostOrigin: string;
+    port: number;
     constructor(project: Project, opts: Options);
     start(): Promise<void>;
 }

package/dist/node/compiler/dev-server.js

@@ -0,0 +1,97 @@
+import { parseURL } from "ufo";
+import { createDevServer } from "vinxi/dev-server";
+import { ProjectEnvUtils } from "../project/env.js";
+import { ensureSelfSignedCert } from "../utils/self-signed-cert.js";
+import { createConsole } from "../utils/stateful-log.js";
+import { createVinxiApp } from "./vinxi-app.js";
+import { createVinxiCodegen } from "./vinxi-codegen.js";
+const console = createConsole("Dev Server", "dev");
+export const serverlessLog = console;
+export class DevServer {
+    project;
+    opts;
+    origin;
+    hostname;
+    hostOrigin;
+    port = 8080;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.start();
+        this.origin = ProjectEnvUtils.get("SITE_URL");
+        const parsedSiteURL = parseURL(this.origin);
+        this.hostname = parsedSiteURL.host?.endsWith(".local") ? parsedSiteURL.host : "localhost";
+        this.hostOrigin = "https://" + this.hostname + ":" + this.port;
+    }
+    async start() {
+        console.setWorking(true);
+        const codegen = createVinxiCodegen({
+            mode: "development",
+            project: this.project,
+            serverless: true,
+        });
+        await codegen.runAndWatch();
+        const app = createVinxiApp({
+            mode: "development",
+            origin: this.origin,
+            publicUrl: this.project.publicUrl,
+            rootDir: this.project.rootDir,
+            log: console,
+        });
+        const preset = process.env.TARGET ??
+            process.env.PRESET ??
+            process.env.SERVER_PRESET ??
+            process.env.SERVER_TARGET ??
+            process.env.NITRO_PRESET ??
+            process.env.NITRO_TARGET ??
+            (process.versions.bun !== undefined ? "bun" : "node-server");
+        const keys = await ensureSelfSignedCert(this.hostname, this.project.rootDir);
+        const httpsConfig = {
+            cert: keys.certFile,
+            key: keys.keyFile,
+            domains: [this.hostname, "localhost"],
+        };
+        let devApp = null;
+        app.hooks.addHooks({
+            "app:dev:start": async ({ app, serveConfig }) => {
+                serveConfig.https = httpsConfig;
+                serveConfig.hostname = this.hostname;
+            },
+            "app:dev:server:created": async (args) => {
+                devApp = args.devApp;
+            },
+        });
+        await createDevServer(app, {
+            force: false,
+            devtools: false,
+            // @ts-ignore
+            hostname: this.hostname,
+            port: this.port,
+            // @ts-ignore
+            preset: preset,
+            https: httpsConfig,
+        });
+        // @ts-ignore
+        await app.hooks.callHook("app:dev:server:listener:creating", {
+            app,
+            devApp,
+        });
+        const listener = await devApp.listen(this.port, {
+            hostname: this.hostname,
+            port: this.port,
+            https: httpsConfig,
+            qr: false,
+            showURL: false,
+        });
+        await app.hooks.callHook("app:dev:server:listener:created", {
+            app,
+            devApp,
+            listener,
+        });
+        console.setWorking(false);
+        console.setState({
+            serverlessUrl: this.hostOrigin,
+            wordpressUrl: this.origin,
+        });
+    }
+}

package/dist/node/compiler/get-vite-config.d.ts

@@ -0,0 +1,19 @@
+import { InlineConfig, PluginOption } from "vite";
+import { StatefulLog } from "../utils/stateful-log.js";
+export type Args = {
+    mode: "development" | "production";
+    serverless: boolean;
+    target: "frontend" | "cms";
+    rootDir: string;
+    outDir?: string;
+    publicUrl: string;
+    console: StatefulLog<any>;
+};
+export declare function envPlugin(args: Args): PluginOption;
+export declare function reactPlugin(): PluginOption[];
+/**
+ * Turns on SSR module proxying,
+ */
+export declare function ssrPlugin(): PluginOption;
+export declare function corePlugins(args: Args): PluginOption[];
+export declare function getViteConfig(args: Args): InlineConfig;

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

@@ -0,0 +1,184 @@
+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.serverless ? "!import.meta.env.SSR" : "true",
+        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: "false",
+        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;
+    };
+    return replace({
+        values: expandDefines(envDefines, ["process.env.", "process.", "env."]),
+        preventAssignment: true,
+    });
+}
+export function reactPlugin() {
+    return react({
+        babel: {
+            overrides: [{ test: /types\./, compact: true }],
+            plugins: [
+                {
+                    visitor: {
+                        ExportNamedDeclaration: (path) => {
+                            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") {
+                                path.remove();
+                            }
+                        },
+                        ExportDefaultDeclaration: (path) => {
+                            if (!path.hub.file.opts.filename.match(/\/(blocks|views)\//))
+                                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)]);
+                                        }
+                                        path.replaceWith(t.exportDefaultDeclaration(t.functionDeclaration(t.identifier(pascalCase(type + "-" + name)), args[1].params, body, args[1].generator, args[1].async)));
+                                    }
+                                }
+                            }
+                        },
+                    },
+                },
+            ],
+        },
+    });
+}
+/**
+ * Turns on SSR module proxying,
+ */
+export function ssrPlugin() {
+    return {
+        name: "proxy-external-ssr-modules",
+        config(config) {
+            config.legacy = {
+                proxySsrExternalModules: 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 [
+        tsconfigPaths(),
+        reactPlugin(),
+        args.mode === "development" && args.serverless && ssrPlugin(),
+        envPlugin(args),
+    ].flat();
+}
+export function getViteConfig(args) {
+    const console = args.console;
+    const logger = createLogger();
+    logger.info = (msg) => args.console.info(msg.replace(/\n/, ""));
+    logger.warn = (msg) => {
+        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();
+    };
+    /** Initial config */
+    const config = {
+        appType: "custom",
+        mode: args.mode,
+        root: args.rootDir,
+        customLogger: logger,
+        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(), buildStatusPlugin(console)],
+        build: {
+            manifest: true,
+            sourcemap: true,
+            minify: args.mode === "production",
+            modulePreload: false,
+            outDir: args.outDir,
+            watch: {},
+            rollupOptions: {
+                input: `/.eddev/${args.mode === "production" ? "prod" : "dev"}-spa/entry.${args.target === "cms" ? "admin" : "client"}.tsx`,
+                external: args.target === "cms" ? ["react", "react-dom"] : [],
+                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;
+                    }
+                    warn(warning);
+                },
+                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,10 @@
+import { StatefulLog } from "../utils/stateful-log.js";
+export type AppArgs = {
+    mode: "development" | "production";
+    publicUrl: string;
+    rootDir: string;
+    origin: string;
+    log?: StatefulLog<any>;
+    preset?: string;
+};
+export declare function createVinxiApp(args: AppArgs): import("vinxi").App;

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

@@ -0,0 +1,121 @@
+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,
+            // },
+            preset: args.preset,
+            routeRules: {
+                "/wp-content/**": { proxy: joinURL(args.origin, "wp-content/**") },
+                "/wp-includes/**": { proxy: joinURL(args.origin, "wp-includes/**") },
+            },
+        },
+        routers: [
+            {
+                name: "public",
+                type: "static",
+                dir: "./assets",
+                base: joinURL(args.publicUrl, "assets"),
+            },
+            {
+                name: "data-api",
+                type: "http",
+                base: "/_data/",
+                handler: `${folder}/handler.data-api.ts`,
+                target: "server",
+                plugins: () => [
+                    tsconfigPaths(),
+                    envPlugin({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: "development",
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                    }),
+                ],
+            },
+            {
+                name: "wp-proxy",
+                type: "http",
+                base: "/wp-",
+                handler: `${folder}/handler.wp-proxy.ts`,
+                target: "server",
+                plugins: () => [
+                    tsconfigPaths(),
+                    envPlugin({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: "development",
+                        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: "development",
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                    }),
+                ],
+                base: "/_build",
+            },
+            {
+                name: "admin",
+                type: "client",
+                handler: `${folder}/entry.admin.tsx`,
+                target: "browser",
+                plugins: () => [
+                    ...corePlugins({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: "development",
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "cms",
+                    }),
+                ],
+                base: "/_admin",
+            },
+            {
+                name: "ssr",
+                type: "http",
+                handler: `${folder}/handler.ssr-page.ts`,
+                target: "server",
+                plugins: () => [
+                    // reactRefresh(),
+                    ...corePlugins({
+                        rootDir: args.rootDir,
+                        console: log,
+                        mode: "development",
+                        publicUrl: args.publicUrl,
+                        serverless: true,
+                        target: "frontend",
+                    }),
+                ],
+            },
+        ],
+    });
+}

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

@@ -0,0 +1,12 @@
+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 {};