eddev 0.3.38 → 2.0.0-beta.10

package/dist/node/cli/display/components/TextInput.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Text, useInput } from "ink";
+import chalk from "chalk";
+function TextInput({ value: originalValue, placeholder = "", focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit, }) {
+    const [state, setState] = useState({
+        cursorOffset: (originalValue || "").length,
+        cursorWidth: 0,
+    });
+    const { cursorOffset, cursorWidth } = state;
+    useEffect(() => {
+        setState((previousState) => {
+            if (!focus || !showCursor) {
+                return previousState;
+            }
+            const newValue = originalValue || "";
+            if (previousState.cursorOffset > newValue.length - 1) {
+                return {
+                    cursorOffset: newValue.length,
+                    cursorWidth: 0,
+                };
+            }
+            return previousState;
+        });
+    }, [originalValue, focus, showCursor]);
+    const cursorActualWidth = highlightPastedText ? cursorWidth : 0;
+    const value = mask ? mask.repeat(originalValue.length) : originalValue;
+    let renderedValue = value;
+    let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+    // Fake mouse cursor, because it's too inconvenient to deal with actual cursor and ansi escapes
+    if (showCursor && focus) {
+        renderedPlaceholder =
+            placeholder.length > 0 ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1)) : chalk.inverse(" ");
+        renderedValue = value.length > 0 ? "" : chalk.inverse(" ");
+        let i = 0;
+        for (const char of value) {
+            renderedValue += i >= cursorOffset - cursorActualWidth && i <= cursorOffset ? chalk.inverse(char) : char;
+            i++;
+        }
+        if (value.length > 0 && cursorOffset === value.length) {
+            renderedValue += chalk.inverse(" ");
+        }
+    }
+    useInput((input, key) => {
+        if (key.upArrow || key.downArrow || (key.ctrl && input === "c") || key.tab || (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            if (onSubmit) {
+                onSubmit(originalValue);
+            }
+            return;
+        }
+        let nextCursorOffset = cursorOffset;
+        let nextValue = originalValue;
+        let nextCursorWidth = 0;
+        if (key.leftArrow) {
+            if (showCursor) {
+                nextCursorOffset--;
+            }
+        }
+        else if (key.rightArrow) {
+            if (showCursor) {
+                nextCursorOffset++;
+            }
+        }
+        else if ((key.backspace || key.delete) && (key.meta || key.ctrl)) {
+            nextValue = "";
+            nextCursorOffset = 0;
+        }
+        else if (key.backspace || key.delete) {
+            if (cursorOffset > 0) {
+                nextValue = originalValue.slice(0, cursorOffset - 1) + originalValue.slice(cursorOffset, originalValue.length);
+                nextCursorOffset--;
+            }
+        }
+        else {
+            nextValue =
+                originalValue.slice(0, cursorOffset) + input + originalValue.slice(cursorOffset, originalValue.length);
+            nextCursorOffset += input.length;
+            if (input.length > 1) {
+                nextCursorWidth = input.length;
+            }
+        }
+        if (cursorOffset < 0) {
+            nextCursorOffset = 0;
+        }
+        if (cursorOffset > originalValue.length) {
+            nextCursorOffset = originalValue.length;
+        }
+        setState({
+            cursorOffset: nextCursorOffset,
+            cursorWidth: nextCursorWidth,
+        });
+        if (nextValue !== originalValue) {
+            onChange(nextValue);
+        }
+    }, { isActive: focus });
+    return _jsx(Text, { children: placeholder ? (value.length > 0 ? renderedValue : renderedPlaceholder) : renderedValue });
+}
+export default TextInput;
+export function UncontrolledTextInput({ initialValue = "", ...props }) {
+    const [value, setValue] = useState(initialValue);
+    return _jsx(TextInput, { ...props, value: value, onChange: setValue });
+}

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

@@ -0,0 +1,2 @@
+import { ManifestGenerator } from "../../../project/manifest/manifest.js";
+export declare function useManifest<T>(manifest: ManifestGenerator<any, T>): T | null;

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

@@ -0,0 +1,8 @@
+import { useEffect, useState } from "react";
+export function useManifest(manifest) {
+    const [value, setValue] = useState(null);
+    useEffect(() => {
+        return manifest.subscribe(setValue);
+    }, [manifest]);
+    return value;
+}

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

@@ -0,0 +1,11 @@
+import { StatefulLog } from "../../../utils/stateful-log.js";
+export type LogInfo<T extends StatefulLog<any> | undefined> = {
+    label: string;
+    value: Exclude<T, undefined>["state"];
+    status: Exclude<T, undefined>["status"];
+    time: number;
+    entries: Exclude<T, undefined>["entries"];
+};
+export declare function useStatefulLogs<T extends {
+    [K in keyof T]: StatefulLog<any> | undefined;
+}>(logs: T): { [K in keyof T]: LogInfo<T[K]>; };

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/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/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-beta.9";

package/dist/node/cli/version.js

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

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

@@ -0,0 +1,13 @@
+import { Project } from "../project/project.js";
+export declare const adminLog: import("../utils/stateful-log.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/stateful-log.js";
+import { getViteConfig } from "./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,
+            publicUrl: this.project.publicUrl,
+            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/stateful-log.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/stateful-log.js";
+import { getViteConfig } from "./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,
+            publicUrl: this.project.publicUrl,
+            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/dev-server.d.ts

@@ -0,0 +1,18 @@
+import { Project } from "../project/project.js";
+export type ServerlessDevStatus = {
+    serverlessUrl: string;
+    wordpressUrl: string;
+};
+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>;
+}
+export {};

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;