eddev 0.3.35 → 2.0.0-beta.1

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

@@ -0,0 +1,315 @@
+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 { join } from "path";
+import { withoutTrailingSlash } from "ufo";
+import { createLogger } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
+import { cliMode } from "../../cli/cli-mode.js";
+import { pluginAdminManifest } from "./plugin-admin.js";
+import { pluginBlocks } from "./plugin-blocks.js";
+import { pluginEntryFile } from "./plugin-entry.js";
+import { pluginResolvedTailwind } from "./plugin-resolved-tailwind.js";
+import { pluginThemeManifest } from "./plugin-theme.js";
+import { pluginViews } from "./plugin-views.js";
+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();
+    };
+    const envDefines = {
+        client: args.serverless ? "!import.meta.env.SSR" : "true",
+        serverless: args.serverless ? "true" : "false",
+        dev: args.mode === "development" ? "true" : "false",
+        admin: args.mode === "development" && args.serverless
+            ? `(typeof __wp_admin !== "undefined")`
+            : args.target === "cms"
+                ? "true"
+                : "false",
+        themePath: JSON.stringify(args.project.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;
+    };
+    /** Initial config */
+    const config = {
+        appType: "custom",
+        mode: args.mode,
+        root: args.rootDir,
+        customLogger: logger,
+        logLevel: cliMode.verbose ? "info" : "warn",
+        base: withoutTrailingSlash(args.project.publicUrl) + "/dist/" + args.target,
+        define: {
+            "process.env.NODE_ENV": JSON.stringify(args.mode),
+            // ssrLoadModule: "() => Promise.resolve({})",
+        },
+        // optimizeDeps: {
+        //   force: true,
+        //   holdUntilCrawlEnd: true,
+        //   include: ["zustand"],
+        //   noDiscovery: true,
+        //   exclude: ["react-external.js", "react-dom-external.js", "react", "react-dom"],
+        //   esbuildOptions: {},
+        // },
+        resolve: {
+            alias: [
+                { find: "@manifest/blocks", replacement: join(args.project.rootDir, "__block-manifest.js") },
+                { find: "@manifest/views", replacement: join(args.project.rootDir, "__view-manifest.js") },
+                { find: "@manifest/theme", replacement: join(args.project.rootDir, "__theme-manifest.js") },
+                { find: "@manifest/admin", replacement: join(args.project.rootDir, "__admin-manifest.js") },
+                { find: "@manifest/tailwind", replacement: join(args.project.rootDir, "__resolved-tailwind.js") },
+            ],
+        },
+        legacy: {
+            proxySsrExternalModules: true,
+        },
+        plugins: [
+            tsconfigPaths(),
+            // pluginShimReact(args),
+            react({
+                babel: {
+                    overrides: [{ test: /types\./, compact: true }],
+                    plugins: [
+                        {
+                            visitor: {
+                                // TODO: Move this to a separate file
+                                // TODO: Attach the title to the block component, so we can use it for debugging
+                                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.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)));
+                                            }
+                                        }
+                                    }
+                                },
+                            },
+                        },
+                    ],
+                },
+            }),
+            replace({
+                values: expandDefines(envDefines, ["process.env.", "process.", "env."]),
+                preventAssignment: true,
+            }),
+            // SPA Frontend, to be served by WordPress
+            args.target === "frontend" &&
+                !args.serverless &&
+                pluginEntryFile({
+                    code: `
+            import boot from 'eddev/_internal/_entry/main.frontend.spa.js'
+            import "./views/index.css"
+            boot()
+          `,
+                    id: "eddev-bootup",
+                    path: "/_boot.js",
+                }),
+            // SPA Admin bundle, to be served by WordPress admin
+            args.target === "cms" &&
+                !args.serverless &&
+                pluginEntryFile({
+                    code: `
+            import boot from 'eddev/_internal/_entry/main.admin.js'
+            import "./views/index.css"
+            boot()
+          `,
+                    id: "eddev-bootup",
+                    path: "/_boot.js",
+                }),
+            // Frontend + Admin, used during development
+            args.serverless &&
+                pluginEntryFile({
+                    code: `
+            import boot from 'eddev/_internal/_entry/main.serverless.dev.js'
+            import "./views/index.css"
+            boot()
+          `,
+                    id: "eddev-bootup",
+                    path: "/_boot.js",
+                }),
+            args.serverless &&
+                pluginEntryFile({
+                    code: `
+          import React from 'react'
+          import ReactDOM from 'react-dom/client'
+          Object.assign(React, window.React)
+          Object.assign(ReactDOM, window.ReactDOM)
+        `,
+                    id: "eddev-test-shim",
+                    path: "/_boot_test_shim.js",
+                }),
+            // Frontend + Admin, used during development
+            args.serverless &&
+                pluginEntryFile({
+                    code: `
+          import '/_boot_test_shim.js'
+          import boot from 'eddev/_internal/_entry/main.serverless.dev.js'
+          import "./views/index.css"
+          boot()
+        `,
+                    id: "eddev-bootup-serverless-admin",
+                    path: "/_boot_admin.js",
+                }),
+            // SSR Bundle, used for rendering on the server
+            args.serverless &&
+                pluginEntryFile({
+                    code: `
+            export * from 'eddev/_internal/_entry/main.frontend.ssr.js'
+            import "./views/index.css"
+          `,
+                    id: "eddev-ssr",
+                    path: "/_ssr.js",
+                }),
+            // args.serverless && {
+            //   name: "eddev:serverless",
+            //   (chunk) {
+            //     console.log("Chunk", chunk)
+            //     return ""
+            //   },
+            // },
+            pluginResolvedTailwind(args.project, args.console, args.serverless),
+            pluginBlocks(args.project, args.console, args.serverless),
+            pluginViews(args.project, args.console, args.serverless),
+            pluginThemeManifest(args.project, args.console),
+            pluginAdminManifest(args.project, args.console),
+            !args.serverless && buildStatus(console),
+            // args.serverless
+            //   ? pluginEntryFile({
+            //       code: indexHtml,
+            //       id: "index.html",
+            //       path: join(args.rootDir, "index.html"),
+            //     })
+            //   : null,
+        ],
+        build: args.target === "cms"
+            ? {
+                manifest: true,
+                sourcemap: true,
+                modulePreload: false,
+                minify: args.mode === "production",
+                outDir: args.outDir,
+                watch: {},
+                rollupOptions: {
+                    input: "/_boot.js",
+                    external: ["react", "react-dom"],
+                    onwarn(warning, warn) {
+                        if (warning.code === "SOURCEMAP_ERROR") {
+                            return;
+                        }
+                        warn(warning);
+                    },
+                    output: {
+                        entryFileNames: "main.admin.js",
+                        format: "iife",
+                        globals: {
+                            react: "window.React",
+                            "react-dom": "window.ReactDOM",
+                        },
+                    },
+                },
+            }
+            : args.serverless
+                ? {
+                    rollupOptions: {
+                        input: "/_boot.js",
+                        external: ["react", "react-dom"],
+                        onwarn(warning, warn) {
+                            if (warning.code === "SOURCEMAP_ERROR") {
+                                return;
+                            }
+                            warn(warning);
+                        },
+                        output: args.mode === "production"
+                            ? {
+                                entryFileNames: "main.admin.js",
+                                format: "iife",
+                                globals: {
+                                    react: "window.React",
+                                    "react-dom": "window.ReactDOM",
+                                },
+                            }
+                            : undefined,
+                    },
+                }
+                : {
+                    manifest: true,
+                    sourcemap: true,
+                    minify: args.mode === "production",
+                    modulePreload: false,
+                    outDir: args.outDir,
+                    watch: {},
+                    rollupOptions: {
+                        input: "/_boot.js",
+                        onwarn(warning, warn) {
+                            if (warning.code === "SOURCEMAP_ERROR") {
+                                return;
+                            }
+                            warn(warning);
+                        },
+                    },
+                },
+    };
+    return config;
+}
+function buildStatus(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);
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-admin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export declare function pluginAdminManifest(project: Project, console: StatefulLog<any>): Plugin;

package/dist/node/compiler/vite/plugin-admin.js

@@ -0,0 +1,67 @@
+import { join } from "path";
+export function pluginAdminManifest(project, console) {
+    const virtualId = "\0virtual:admin-manifest.js";
+    let server = null;
+    const fakePath = join(project.rootDir, "__admin-manifest.js");
+    let lastHash = "";
+    project.views.subscribeFuture(async (manifest) => {
+        if (server) {
+            const hash = Object.keys(manifest.views).join("");
+            const virtualModule = server.moduleGraph.getModuleById(virtualId);
+            if (virtualModule && hash !== lastHash && lastHash !== "") {
+                server.moduleGraph.invalidateModule(virtualModule);
+            }
+            lastHash = hash;
+        }
+    });
+    return {
+        name: "eddev:adminManifest",
+        resolveId(id) {
+            if (id === fakePath) {
+                return virtualId;
+            }
+        },
+        async load(id) {
+            if (id === virtualId) {
+                const fieldManifest = await project.fields.get();
+                const widgetManifest = await project.widgets.get();
+                return `
+          import { adminManifestReader } from 'eddev/_internal'
+          import editorConfig from './blocks/_editor'
+
+          const fields = {${Object.entries(fieldManifest.fields)
+                    .map(([name, field]) => {
+                    const importStatement = `() => import(${JSON.stringify("./" + field.fileName)}).then(m => m.default)`;
+                    return JSON.stringify(field.slug) + ": " + importStatement;
+                })
+                    .join(",\n")}}
+          const widgets = {${Object.entries(widgetManifest.widgets)
+                    .map(([name, widget]) => {
+                    const importStatement = `() => import(${JSON.stringify("./" + widget.fileName)}).then(m => m.default)`;
+                    return JSON.stringify(widget.slug) + ": " + importStatement;
+                })
+                    .join(",\n")}}
+
+          const manifest = {
+            fields,
+            widgets,
+            editorConfig
+          }
+
+          adminManifestReader.set(manifest)
+          
+          export default manifest
+
+          export { editorConfig }
+
+          if (import.meta.hot) {
+            import.meta.hot.accept()
+          }
+        `;
+            }
+        },
+        configureServer(_server) {
+            server = _server;
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-blocks.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export declare function pluginBlocks(project: Project, console: StatefulLog<any>, ssr: boolean): Plugin;

package/dist/node/compiler/vite/plugin-blocks.js

@@ -0,0 +1,73 @@
+import { join } from "path";
+export function pluginBlocks(project, console, ssr) {
+    const manifestId = "\0virtual:block-manifest.js";
+    let server = null;
+    const fakePath = join(project.rootDir, "__block-manifest.js");
+    let lastHash = "";
+    project.blocks.subscribeFuture(async (manifest) => {
+        if (server) {
+            const hash = Object.keys(manifest.blocks).join("");
+            const virtualModule = server.moduleGraph.getModuleById(manifestId);
+            if (virtualModule && hash !== lastHash && lastHash !== "") {
+                server.moduleGraph.invalidateModule(virtualModule);
+            }
+            lastHash = hash;
+        }
+    });
+    return {
+        name: "eddev:blockManifest",
+        enforce: "pre",
+        resolveId(id) {
+            if (id === fakePath) {
+                return manifestId;
+            }
+        },
+        async load(id) {
+            if (id === manifestId) {
+                const blockManifest = await project.blocks.get();
+                return `
+          import { blockManifestReader } from 'eddev/_internal'
+          import { dynamic } from 'eddev/dynamic'
+          import core from './blocks/_core'
+
+          const manifest = {
+            ${Object.entries(blockManifest.blocks)
+                    .filter(([name]) => !name.match(/^_[a-z]+$/i))
+                    .map(([name, block]) => {
+                    const importStatement = `dynamic(() => import(${JSON.stringify("./" + block.fileName)}))`;
+                    return JSON.stringify(block.acfName) + ": " + importStatement;
+                })
+                    .join(",\n")},
+            ...core
+          }
+
+          const info = {
+            ${Object.entries(blockManifest.blocks)
+                    .filter(([name]) => !name.match(/^_[a-z]+$/i))
+                    .map(([name, block]) => {
+                    return (JSON.stringify(block.acfName) +
+                        ": " +
+                        JSON.stringify({
+                            slug: block.slug,
+                            tags: block.tags,
+                            flags: block.flags ?? {},
+                        }));
+                })
+                    .join(",\n")}
+          }
+
+          blockManifestReader.set(manifest, info)
+
+          export default manifest
+
+          if (import.meta.hot) {
+            import.meta.hot.accept()
+          }
+        `;
+            }
+        },
+        configureServer(_server) {
+            server = _server;
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-entry.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+export declare function pluginEntryFile(args: {
+    code: string;
+    id: string;
+    path: string;
+}): Plugin;

package/dist/node/compiler/vite/plugin-entry.js

@@ -0,0 +1,16 @@
+export function pluginEntryFile(args) {
+    const virtualId = "\0virtual:" + args.id;
+    return {
+        name: "eddev:entry:" + args.id,
+        resolveId(id) {
+            if (id === args.path) {
+                return virtualId;
+            }
+        },
+        load(id) {
+            if (id === virtualId) {
+                return args.code;
+            }
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-resolved-tailwind.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export declare function pluginResolvedTailwind(project: Project, console: StatefulLog<any>, ssr: boolean): Plugin;

package/dist/node/compiler/vite/plugin-resolved-tailwind.js

@@ -0,0 +1,29 @@
+import { join } from "path";
+export function pluginResolvedTailwind(project, console, ssr) {
+    const virtualId = "\0virtual:resolved-tailwind.js";
+    const fakePath = join(project.rootDir, "__resolved-tailwind.js");
+    return {
+        name: "eddev:resolvedTailwind",
+        resolveId(id) {
+            if (id === fakePath) {
+                return virtualId;
+            }
+        },
+        async load(id) {
+            if (id === virtualId) {
+                return `
+          import tw from "./tailwind.config"
+          import resolveConfig from 'tailwindcss/resolveConfig'
+          import { internalStore } from 'eddev/_internal'
+
+          const value = resolveConfig(tw)
+          internalStore.set('tailwindConfig', value)
+
+          if (import.meta.hot) {
+            import.meta.hot.accept()
+          }
+        `;
+            }
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-theme.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export declare function pluginThemeManifest(project: Project, console: StatefulLog<any>): Plugin;

package/dist/node/compiler/vite/plugin-theme.js

@@ -0,0 +1,40 @@
+import { join } from "path";
+export function pluginThemeManifest(project, console) {
+    const virtualId = "\0virtual:theme-manifest.js";
+    const fakePath = join(project.rootDir, "__theme-manifest.js");
+    const usingStitches = project.config?.legacyStitches;
+    return {
+        name: "eddev:themeManifest",
+        resolveId(id) {
+            if (id === fakePath) {
+                return virtualId;
+            }
+        },
+        async load(id) {
+            if (id === virtualId) {
+                if (usingStitches) {
+                    return `
+            import * as theme from './theme.css'
+            export const getCssText = () => {
+              if (theme.getCssText) {
+                return theme.getCssText()
+              }
+              return ''
+            }
+
+            export const editorGlobalStyles = () => {
+              if (theme.editorGlobalStyles)
+                return theme.editorGlobalStyles()
+            }
+          `;
+                }
+                else {
+                    return `
+            export const getCssText = undefined
+            export const editorGlobalStyles = () => {}
+          `;
+                }
+            }
+        },
+    };
+}

package/dist/node/compiler/vite/plugin-views.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { Project } from "../../project/project.js";
+import { StatefulLog } from "../../utils/statefulLog.js";
+export declare function pluginViews(project: Project, console: StatefulLog<any>, ssr: boolean): Plugin;

package/dist/node/compiler/vite/plugin-views.js

@@ -0,0 +1,51 @@
+import { join } from "path";
+export function pluginViews(project, console, ssr) {
+    const virtualId = "\0virtual:view-manifest.js";
+    let server = null;
+    const fakePath = join(project.rootDir, "__view-manifest.js");
+    let lastHash = "";
+    project.views.subscribeFuture(async (manifest) => {
+        if (server) {
+            const hash = Object.keys(manifest.views).join("");
+            const virtualModule = server.moduleGraph.getModuleById(virtualId);
+            if (virtualModule && hash !== lastHash && lastHash !== "") {
+                server.moduleGraph.invalidateModule(virtualModule);
+            }
+            lastHash = hash;
+        }
+    });
+    return {
+        name: "eddev:viewManifest",
+        resolveId(id) {
+            if (id === fakePath) {
+                return virtualId;
+            }
+        },
+        async load(id) {
+            if (id === virtualId) {
+                const viewManifest = await project.views.get();
+                return `
+          import { viewManifestReader } from 'eddev/_internal'
+          import { dynamic } from 'eddev/dynamic'
+          const manifest = {${Object.entries(viewManifest.views)
+                    .map(([name, view]) => {
+                    const importStatement = `dynamic(() => import(${JSON.stringify("./" + view.fileName)}))`;
+                    return JSON.stringify(view.slug) + ": " + importStatement;
+                })
+                    .join(",\n")}}
+
+          viewManifestReader.value = manifest
+          
+          export default manifest
+
+          if (import.meta.hot) {
+            import.meta.hot.accept()
+          }
+        `;
+            }
+        },
+        configureServer(_server) {
+            server = _server;
+        },
+    };
+}

package/dist/node/graphql/graphql-codegen.d.ts

@@ -0,0 +1,30 @@
+import { Project } from "../project/project.js";
+export declare const graphqlLog: import("../utils/statefulLog.js").StatefulLog<GraphQLGenerator>;
+export declare class GraphQLGenerator {
+    project: Project;
+    private needsRegenerate;
+    private needsReload;
+    private regenerateReason;
+    private regenerateReasonInfo;
+    private isGenerating;
+    private schemaLoader;
+    private fileLoader;
+    private debouncer?;
+    private retryTimer?;
+    constructor(project: Project);
+    queueRegenerate(full: boolean, reason: string, info?: string | string[]): Promise<void>;
+    start(): Promise<void>;
+    private listen;
+    scheduleRetry(): void;
+    generate(): Promise<void>;
+    /**
+     * Validates a GraphQL manifest against a schema, ensuring there are no user errors.
+     */
+    private validateGraphQLFiles;
+    private generateTS;
+    generateUtilTypes(): Promise<unknown[]>;
+    /**
+     * Saves the schema to a file, for use by the VSCode GraphQL extension
+     */
+    private writeSchemaFile;
+}