eddev 0.3.35 → 2.0.0-beta.1

package/dist/node/cli/display/hooks/useStatefulLog.js

@@ -0,0 +1,51 @@
+import { useEffect, useState } from "react";
+export function useStatefulLogs(logs) {
+    const captureAll = () => {
+        const result = {};
+        for (let k in logs) {
+            const log = logs[k];
+            if (!log)
+                continue;
+            result[k] = {
+                label: log.label,
+                value: log.state,
+                status: log.status,
+                time: log.getDuration(),
+                entries: log.captureLog(),
+            };
+        }
+        return result;
+    };
+    const [entries, setEntries] = useState(() => captureAll());
+    useEffect(() => {
+        let disposers = [];
+        let debounce;
+        for (let k in logs) {
+            const log = logs[k];
+            if (!log)
+                continue;
+            disposers.push(log.subscribe(() => {
+                setEntries(captureAll());
+                // if (log.needsFlush) {
+                //   setEntries(captureAll())
+                //   log.needsFlush = false
+                //   return
+                // }
+                // // Debounce, to prevent console from going crazy during fast updates
+                // debounce =
+                //   debounce ||
+                //   setTimeout(() => {
+                //     debounce = undefined
+                //     setEntries(captureAll())
+                //   }, 10)
+            }));
+        }
+        return () => {
+            clearTimeout(debounce);
+            for (let disposer of disposers) {
+                disposer();
+            }
+        };
+    }, [Object.keys(logs).length]);
+    return entries;
+}

package/dist/node/cli/display/tools/BlockList.d.ts

@@ -0,0 +1,2 @@
+import { ToolProps } from "./cli-tools.js";
+export declare function BlockList(props: ToolProps): import("react/jsx-runtime").JSX.Element;

package/dist/node/cli/display/tools/BlockList.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { useManifest } from "../hooks/useManifest.js";
+import { describeBlockManifest } from "../../../types/block-type.js";
+export function BlockList(props) {
+    const manifest = useManifest(props.project.blocks);
+    if (!manifest)
+        return _jsx(Text, { children: "Loading..." });
+    return _jsx(Box, { children: manifest && _jsx(Text, { children: describeBlockManifest(manifest) }) });
+}

package/dist/node/cli/display/tools/CreateBlock.d.ts

@@ -0,0 +1,2 @@
+import { ToolProps } from "./cli-tools";
+export declare function CreateBlock(props: ToolProps): import("react/jsx-runtime").JSX.Element;

package/dist/node/cli/display/tools/CreateBlock.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import TextInput from "../components/TextInput.js";
+import { useState } from "react";
+export function CreateBlock(props) {
+    const [name, setName] = useState("");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "What do you want to call your block?" }), _jsx(TextInput, { value: name, onChange: setName, onSubmit: () => { }, placeholder: "Enter a name" })] }));
+}

package/dist/node/cli/display/tools/cli-tool-list.d.ts

@@ -0,0 +1,2 @@
+import { ToolInfo } from "./cli-tools.js";
+export declare const TOOLS: Record<string, Omit<ToolInfo, "id">>;

package/dist/node/cli/display/tools/cli-tool-list.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { BlockList } from "./BlockList.js";
+import { CreateBlock } from "./CreateBlock.js";
+export const TOOLS = {
+    blocks: {
+        name: "Show block manifest",
+        type: "list",
+        keywords: ["list blocks", "show blocks"],
+        component: BlockList,
+    },
+    views: {
+        name: "Show view manifest",
+        type: "list",
+        component: () => (_jsx(Box, { children: _jsx(Text, { children: "Views" }) })),
+    },
+    createBlock: {
+        name: "Create a new block",
+        type: "action",
+        keywords: ["create blocks", "new block"],
+        component: CreateBlock,
+    },
+};

package/dist/node/cli/display/tools/cli-tools.d.ts

@@ -0,0 +1,26 @@
+import { FunctionComponent } from "react";
+import { Project } from "../../../project/project.js";
+type ToolType = "list" | "analyze" | "tasks" | "configure" | "action" | "ai";
+export type ToolProps = {
+    project: Project;
+    close: () => void;
+};
+export type ToolInfo = {
+    id: string;
+    name: string;
+    type: ToolType;
+    keywords?: string[];
+    component: FunctionComponent<ToolProps>;
+};
+export declare function findTools(term: string): {
+    tool: {
+        id: string;
+        type: ToolType;
+        keywords?: string[] | undefined;
+        name: string;
+        component: FunctionComponent<ToolProps>;
+    };
+    score: number;
+    matches: import("@nozbe/microfuzz").FuzzyMatches;
+}[];
+export {};

package/dist/node/cli/display/tools/cli-tools.js

@@ -0,0 +1,15 @@
+import microfuzz from "@nozbe/microfuzz";
+import { TOOLS } from "./cli-tool-list.js";
+const toolList = Object.entries(TOOLS).map(([key, value]) => ({ ...value, id: key }));
+// https://github.com/Nozbe/microfuzz/issues/1
+// @ts-ignore
+const fuzzy = (typeof microfuzz === "function" ? microfuzz : microfuzz.default);
+const fuzzyIndex = fuzzy(toolList, {
+    getText: (tool) => [tool.name, ...(tool.keywords ? tool.keywords : [])],
+});
+export function findTools(term) {
+    if (!term) {
+        return toolList.map((tool) => ({ tool, score: 1, matches: [] }));
+    }
+    return fuzzyIndex(term).map((result) => ({ tool: result.item, score: result.score, matches: result.matches }));
+}

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

@@ -0,0 +1,4 @@
+import { LogStatus } from "../../../utils/statefulLog.js";
+export declare function statusColor(status: LogStatus): "greenBright" | "redBright" | "blueBright" | "whiteBright" | "#FF890C" | "#0C86FF" | "grayBright";
+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/display/util/colors.js

@@ -0,0 +1,63 @@
+export function statusColor(status) {
+    return status === "error"
+        ? "redBright"
+        : status === "warn"
+            ? "#FF890C"
+            : status === "info"
+                ? "blueBright"
+                : status === "working"
+                    ? "#0C86FF"
+                    : status === "fail"
+                        ? "redBright"
+                        : status === "success"
+                            ? "greenBright"
+                            : status === "verbose"
+                                ? "grayBright"
+                                : status === "help"
+                                    ? "blueBright"
+                                    : status === "log"
+                                        ? "whiteBright"
+                                        : "whiteBright";
+}
+export function statusIcon(status) {
+    return status === "error"
+        ? "✖"
+        : status === "warn"
+            ? "⚠"
+            : status === "info"
+                ? "ℹ"
+                : status === "working"
+                    ? "⚙"
+                    : status === "fail"
+                        ? "✖"
+                        : status === "success"
+                            ? "✔"
+                            : status === "verbose"
+                                ? "v"
+                                : status === "help"
+                                    ? "?"
+                                    : status === "log"
+                                        ? "➜"
+                                        : "➜";
+}
+export function statusLabel(status) {
+    return status === "error"
+        ? "Error"
+        : status === "warn"
+            ? "Warning"
+            : status === "info"
+                ? "Info"
+                : status === "working"
+                    ? "Working"
+                    : status === "fail"
+                        ? "Fail"
+                        : status === "success"
+                            ? "Success"
+                            : status === "verbose"
+                                ? "Verbose"
+                                : status === "help"
+                                    ? "Help"
+                                    : status === "log"
+                                        ? "Log"
+                                        : "Log";
+}

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

@@ -0,0 +1 @@
+export declare const VERSION = "2.0.0";

package/dist/node/cli/version.js

@@ -0,0 +1 @@
+export const VERSION = "2.0.0";

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

@@ -0,0 +1,13 @@
+import { Project } from "../project/project.js";
+export declare const adminLog: import("../utils/statefulLog.js").StatefulLog<unknown>;
+type Options = {
+    mode: "development" | "production";
+    watch?: boolean;
+};
+export declare class AdminBundler {
+    project: Project;
+    opts: Options;
+    constructor(project: Project, opts: Options);
+    protected start(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import { relative } from "path";
+import { build, defineConfig, mergeConfig } from "vite";
+import { createConsole } from "../utils/statefulLog.js";
+import { getViteConfig } from "./vite/get-vite-config.js";
+const console = createConsole("Admin Bundle", "admin");
+export const adminLog = console;
+export class AdminBundler {
+    project;
+    opts;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.start();
+    }
+    async start() {
+        console.info(`Creating ${this.opts.mode} WordPress admin build...`);
+        const baseConfig = getViteConfig({
+            console,
+            mode: this.opts.mode,
+            project: this.project,
+            rootDir: this.project.rootDir,
+            outDir: relative(this.project.rootDir, "./dist/cms/"),
+            serverless: false,
+            target: "cms",
+        });
+        console.verbose("Vite config:", baseConfig);
+        await build(mergeConfig(baseConfig, defineConfig({
+            build: {
+                watch: this.opts.watch
+                    ? {
+                        buildDelay: 200,
+                    }
+                    : undefined,
+            },
+        })));
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Project } from "../project/project.js";
+export declare const frontendLog: import("../utils/statefulLog.js").StatefulLog<unknown>;
+type Options = {
+    mode: "development" | "production";
+    watch?: boolean;
+};
+export declare class FrontendBundler {
+    project: Project;
+    opts: Options;
+    constructor(project: Project, opts: Options);
+    start(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import { relative } from "path";
+import { build, defineConfig, mergeConfig } from "vite";
+import { createConsole } from "../utils/statefulLog.js";
+import { getViteConfig } from "./vite/get-vite-config.js";
+const console = createConsole("Frontend Bundler", "spa");
+export const frontendLog = console;
+export class FrontendBundler {
+    project;
+    opts;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.start();
+    }
+    async start() {
+        console.info(`Creating ${this.opts.mode} SPA build...`);
+        const baseConfig = getViteConfig({
+            console,
+            mode: this.opts.mode,
+            project: this.project,
+            rootDir: this.project.rootDir,
+            outDir: relative(this.project.rootDir, "./dist/frontend/"),
+            serverless: false,
+            target: "frontend",
+        });
+        console.verbose("Vite config:", baseConfig);
+        await build(mergeConfig(baseConfig, defineConfig({
+            build: {
+                watch: this.opts.watch
+                    ? {
+                        buildDelay: 200,
+                    }
+                    : undefined,
+            },
+        })));
+    }
+}

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

@@ -0,0 +1,2 @@
+declare const _default: "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/vite.svg\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <link rel=\"stylesheet\" href=\"/views/index.css\" />\n    <!--ssr-meta-->\n  </head>\n  <body>\n    <div id=\"root\"><!--ssr-outlet--></div>\n    <!--ssr-meta-->\n    <script type=\"module\" src=\"/_boot.js\"></script>\n  </body>\n</html>";
+export default _default;

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

@@ -0,0 +1,15 @@
+export default `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="/views/index.css" />
+    <!--ssr-meta-->
+  </head>
+  <body>
+    <div id="root"><!--ssr-outlet--></div>
+    <!--ssr-meta-->
+    <script type="module" src="/_boot.js"></script>
+  </body>
+</html>`;

package/dist/node/compiler/serverless.dev.d.ts

@@ -0,0 +1,16 @@
+import { Project } from "../project/project.js";
+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 {
+    project: Project;
+    opts: Options;
+    constructor(project: Project, opts: Options);
+    start(): Promise<void>;
+}
+export {};

package/dist/node/compiler/serverless.dev.js

@@ -0,0 +1,215 @@
+import { getRequestListener } from "@hono/node-server";
+import express from "express";
+import expressProxy from "express-http-proxy";
+import { Agent as HttpAgent } from "http";
+import { Agent as HttpsAgent } from "https";
+import { listen } from "listhen";
+import fetch from "node-fetch";
+import { relative } from "path";
+import { parseURL } from "ufo";
+import { createServer as createViteServer, defineConfig, mergeConfig } from "vite";
+import { ProjectEnvUtils } from "../project/env.js";
+import { ensureSelfSignedCert } from "../utils/selfSignedCert.js";
+import { createConsole } from "../utils/statefulLog.js";
+import indexHtml from "./index.html.js";
+import { getViteConfig } from "./vite/get-vite-config.js";
+const console = createConsole("Dev Server", "dev");
+export const serverlessLog = console;
+export class ServerlessDevServer {
+    project;
+    opts;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.start();
+    }
+    async start() {
+        console.setWorking(true);
+        const siteURL = ProjectEnvUtils.get("SITE_URL");
+        const parsedSiteURL = parseURL(siteURL);
+        let serverlessPort = 8080;
+        let hmrPort = serverlessPort + 5;
+        const serverlessHost = parsedSiteURL.host?.endsWith(".local") ? parsedSiteURL.host : "localhost";
+        console.info(`Starting dev server...`);
+        const keys = await ensureSelfSignedCert(serverlessHost, this.project.rootDir);
+        const app = express();
+        const hotServer = await listen(() => { }, {
+            port: hmrPort,
+            hostname: serverlessHost,
+            qr: false,
+            showURL: false,
+            https: {
+                cert: keys.certFile,
+                key: keys.keyFile,
+                domains: [serverlessHost],
+            },
+        });
+        hmrPort = hotServer.address.port;
+        const mainServer = await listen(app, {
+            port: serverlessPort,
+            hostname: serverlessHost,
+            qr: false,
+            showURL: false,
+            https: {
+                cert: keys.certFile,
+                key: keys.keyFile,
+                domains: [serverlessHost],
+            },
+        });
+        const vite = await createViteServer(mergeConfig(getViteConfig({
+            console,
+            mode: this.opts.mode,
+            project: this.project,
+            rootDir: this.project.rootDir,
+            outDir: relative(this.project.rootDir, "./dist/ssr/"),
+            serverless: true,
+            target: "frontend",
+        }), defineConfig({
+            mode: "development",
+            base: "/",
+            server: {
+                middlewareMode: true,
+                hmr: {
+                    server: hotServer.server,
+                    port: hmrPort,
+                    path: "/_hmr",
+                },
+            },
+            build: {
+                ssr: true,
+                sourcemap: true,
+                watch: {
+                    clearScreen: true,
+                },
+                rollupOptions: {
+                    onwarn(warning, warn) {
+                        if (warning.code === "SOURCEMAP_ERROR") {
+                            return;
+                        }
+                        warn(warning);
+                    },
+                },
+            },
+            appType: "custom",
+        })));
+        vite.watcher.on("change", (file) => {
+            console.resetLog();
+        });
+        console.setWorking(false);
+        const proxyTarget = "https://" + serverlessHost + ":" + serverlessPort + "/";
+        const proxyDest = parsedSiteURL.protocol + "//" + parsedSiteURL.host + "/";
+        console.info("Proxying WordPress from", proxyDest);
+        const replaceTargetString = proxyDest.replaceAll(/https?:/g, "https?:").replaceAll("/", "\\/");
+        const replaceTargetEscapedString = proxyDest.replaceAll(/https?:/g, "https?:").replaceAll("/", "\\\\/");
+        const replaceTarget = new RegExp(replaceTargetString, "g");
+        const replaceTargetEscaped = new RegExp(replaceTargetEscapedString, "g");
+        const replaceHost = (value) => {
+            return value.replace(replaceTarget, proxyTarget).replace(replaceTargetEscaped, proxyTarget.replaceAll("/", "\\/"));
+        };
+        const proxy = expressProxy(parsedSiteURL.protocol + "//" + parsedSiteURL.host, {
+            proxyReqOptDecorator: function (proxyReqOpts, originalReq) {
+                // @ts-ignore
+                proxyReqOpts.rejectUnauthorized = false;
+                // @ts-ignore
+                proxyReqOpts.headers["X-ED-Dev-Proxy"] = "true";
+                return proxyReqOpts;
+            },
+            userResHeaderDecorator(headers, userReq, userRes, proxyReq, proxyRes) {
+                for (let [key, value] of Object.entries(headers)) {
+                    if (typeof value === "string") {
+                        headers[key] = replaceHost(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        headers[key] = value.map((v) => {
+                            return replaceHost(v);
+                        });
+                    }
+                }
+                return headers;
+            },
+            userResDecorator(proxyRes, proxyResData, userReq, userRes) {
+                if (userReq.path.includes(".php") || !userReq.path.includes(".") || userReq.path.startsWith("/wp-json")) {
+                    proxyResData = replaceHost(proxyResData.toString("utf8"));
+                }
+                return proxyResData;
+            },
+        });
+        app.use(async (req, res, next) => {
+            if (!req.originalUrl.includes(".php") && !req.originalUrl.includes("/?")) {
+                vite.middlewares.handle(req, res, next);
+            }
+            else {
+                next();
+            }
+        });
+        /**
+         * Allow https access from self-signed certificates, when working locally during development
+         */
+        const httpsAgent = new HttpsAgent({
+            rejectUnauthorized: false,
+        });
+        const httpAgent = new HttpAgent({});
+        const fetchImpl = (...args) => {
+            return fetch(args[0], {
+                ...(args[1] ?? {}),
+                agent: function (_parsedURL) {
+                    if (_parsedURL.protocol == "http:") {
+                        return httpAgent;
+                    }
+                    else {
+                        return httpsAgent;
+                    }
+                },
+            });
+        };
+        app.use(async (req, res, next) => {
+            if (!req.path.startsWith("/api"))
+                return next();
+            const { getHonoAPI, patchConsole } = await vite.ssrLoadModule("/_ssr.js", {
+                fixStacktrace: true,
+            });
+            patchConsole(console);
+            const hono = getHonoAPI({
+                fetchImpl,
+                replaceUrls: {
+                    from: proxyDest,
+                    to: "/",
+                },
+            });
+            const handler = getRequestListener(hono.fetch, {
+                errorHandler: (err) => {
+                    console.error(err);
+                },
+            });
+            await handler(req, res);
+        });
+        app.use(async (req, res, next) => {
+            const url = req.originalUrl;
+            if (url.includes(".") || url.startsWith("/wp-") || url.startsWith("/graphql"))
+                return next();
+            const { patchConsole, setFetchImpl, getHonoSSR, setIndexTransformer } = await vite.ssrLoadModule("/_ssr.js", {
+                fixStacktrace: true,
+            });
+            patchConsole(console);
+            const hono = getHonoSSR({
+                fetchImpl,
+                indexTransformer: async (index) => await vite.transformIndexHtml(url, indexHtml),
+                replaceUrls: {
+                    from: proxyDest,
+                    to: "/",
+                },
+            });
+            const handler = getRequestListener(hono.fetch, {
+                errorHandler: (err) => {
+                    console.error(err);
+                },
+            });
+            await handler(req, res);
+        });
+        app.use(proxy);
+        console.setState({
+            serverlessUrl: "https://" + serverlessHost + ":" + mainServer.address.port + "/",
+            wordpressUrl: proxyDest,
+        });
+    }
+}

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

@@ -0,0 +1,13 @@
+import { InlineConfig } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export type Args = {
+    mode: "development" | "production";
+    serverless: boolean;
+    target: "frontend" | "cms";
+    rootDir: string;
+    outDir: string;
+    project: Project;
+    console: StatefulLog<any>;
+};
+export declare function getViteConfig(args: Args): InlineConfig;