eddev 2.0.0-beta.21 → 2.0.0-beta.211

package/dist/node/project/manifest/manifest.js

@@ -31,20 +31,24 @@ export function createManifestGenerator(args) {
                 }
             };
             if (args.watch) {
-                const disposer = await watchFileTree(args.pattern, (fileList, event) => {
-                    files = fileList;
-                    cache = new Map();
-                    if (args.onFileChange)
-                        fileList.forEach(args.onFileChange);
-                    update();
-                    if (event) {
-                        events.push(event);
-                    }
+                const disposer = await watchFileTree({
+                    pattern: args.pattern,
+                    ignore: args.ignore,
+                    callback: (fileList, event) => {
+                        files = fileList;
+                        cache = new Map();
+                        if (args.onFileChange)
+                            fileList.forEach(args.onFileChange);
+                        update();
+                        if (event) {
+                            events.push(event);
+                        }
+                    },
                 });
                 disposers.push(disposer);
             }
             else {
-                files = await getFileTree(args.pattern);
+                files = await getFileTree({ pattern: args.pattern, ignore: args.ignore });
                 update();
             }
         });

package/dist/node/project/manifest/routes-manifest.d.ts

@@ -0,0 +1,21 @@
+import { Project } from "../project.js";
+export type RouteManifest = {
+    routes: Record<string, RouteInfo>;
+    contextFileName: string | null;
+    validationMessages: {
+        fieldKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+    bases: string[];
+};
+type RouteInfo = {
+    kind: "context" | "route";
+    fileName: string;
+    prefix?: string;
+    error?: string;
+};
+export type RouteManifestGenerator = ReturnType<typeof loadRouteManifest>;
+export declare function loadRouteManifest(project: Project): import("./manifest.js").ManifestGenerator<RouteInfo, RouteManifest>;
+export {};
+//# sourceMappingURL=routes-manifest.d.ts.map

package/dist/node/project/manifest/routes-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/routes-manifest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAGvC,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACjC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,kBAAkB,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;KAC9B,EAAE,CAAA;IACH,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,SAAS,GAAG,OAAO,CAAA;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEzE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,uEA4EjD"}

package/dist/node/project/manifest/routes-manifest.js

@@ -0,0 +1,74 @@
+import { cliMode } from "../../cli/cli-mode.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadRouteManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: ["server/routes/**/*.{ts,tsx}", "server/_context.{ts,tsx}"],
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                routes: {},
+                contextFileName: null,
+                validationMessages: [],
+                bases: [],
+            };
+            const bases = new Set();
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                if (entry.value.kind === "context") {
+                    result.contextFileName = entry.value.fileName;
+                }
+                else if (entry.value.kind === "route") {
+                    const { error: initialError } = entry.value;
+                    const prefix = entry.value.prefix;
+                    result.routes[key] = entry.value;
+                    if (prefix) {
+                        let shouldAdd = true;
+                        bases.forEach((base) => {
+                            if (base.startsWith(prefix)) {
+                                bases.delete(base);
+                            }
+                            else if (prefix.startsWith(base)) {
+                                shouldAdd = false;
+                                return;
+                            }
+                        });
+                        if (shouldAdd) {
+                            bases.add(entry.value.prefix);
+                        }
+                    }
+                    if (initialError) {
+                        result.validationMessages.push({
+                            fieldKey: key,
+                            message: initialError,
+                            severity: "error",
+                        });
+                        return;
+                    }
+                }
+            });
+            result.bases = [...bases].sort().map((base) => "/" + base.replace(/\./g, "/"));
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx?$/, "").replace(/^server\/routes\//, "");
+        },
+        async loadValue(fileName, key) {
+            if (fileName.startsWith("server/_context.")) {
+                return {
+                    kind: "context",
+                    fileName,
+                };
+            }
+            return {
+                kind: "route",
+                prefix: key.replace("/index", "").replace(/\//g, "."),
+                fileName,
+            };
+        },
+    });
+}

package/dist/node/project/manifest/view-manifest.d.ts

@@ -17,3 +17,4 @@ type ViewLoadResult = {
 export type ViewManifestGenerator = ReturnType<typeof loadViewManifest>;
 export declare function loadViewManifest(project: Project): import("./manifest.js").ManifestGenerator<ViewLoadResult, ViewManifest>;
 export {};
+//# sourceMappingURL=view-manifest.d.ts.map

package/dist/node/project/manifest/view-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/view-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,YAAY,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAIhG,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAKvC,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE;QACL,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;KAC1B,CAAA;IACD,kBAAkB,EAAE;QAClB,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;KAC9B,EAAE,CAAA;CACJ,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAAA;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEvE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,2EAwFhD"}

package/dist/node/project/manifest/widget-manifest.d.ts

@@ -15,3 +15,4 @@ type WidgetInfo = {
 export type WidgetManifestGenerator = ReturnType<typeof loadWidgetManifest>;
 export declare function loadWidgetManifest(project: Project): import("./manifest.js").ManifestGenerator<WidgetInfo, WidgetManifest>;
 export {};
+//# sourceMappingURL=widget-manifest.d.ts.map

package/dist/node/project/manifest/widget-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/widget-manifest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAGvC,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACnC,kBAAkB,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;KAC9B,EAAE,CAAA;CACJ,CAAA;AAED,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE3E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,yEA0ClD"}

package/dist/node/project/project.d.ts

@@ -1,6 +1,7 @@
 import { EDConfig } from "./config.js";
 import { BlockManifestGenerator } from "./manifest/block-manifest.js";
 import { FieldManifestGenerator } from "./manifest/field-manifest.js";
+import { RouteManifestGenerator } from "./manifest/routes-manifest.js";
 import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { WidgetManifestGenerator } from "./manifest/widget-manifest.js";
 export declare const projectLog: import("../utils/stateful-log.js").StatefulLog<Project>;
@@ -20,14 +21,23 @@ export declare class Project {
     configFile: string;
     origin: string;
     config?: EDConfig;
+    cssEntryFile: string;
     blocks: BlockManifestGenerator;
     views: ViewManifestGenerator;
     fields: FieldManifestGenerator;
     widgets: WidgetManifestGenerator;
+    serverRoutes: RouteManifestGenerator;
     private wp;
     reportPluginCompatibility: boolean;
     private constructor();
+    verifyOriginAccess(): Promise<{
+        success: true;
+    } | {
+        success: false;
+        message: string;
+    }>;
     private load;
+    detectCssEntryFile(): Promise<void>;
     reportProjectInfo(): string;
     getWordpressInfo(): Promise<{
         postTypes: {
@@ -52,7 +62,9 @@ export declare class Project {
             isScalar: boolean;
             typeName: string;
         }[];
+        scalarTypeImports?: string[];
     }>;
     static create(args: ProjectArgs): Promise<Project>;
 }
 export {};
+//# sourceMappingURL=project.d.ts.map

package/dist/node/project/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/node/project/project.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEpD,OAAO,EAAE,sBAAsB,EAAqB,MAAM,8BAA8B,CAAA;AACxF,OAAO,EAAE,sBAAsB,EAAqB,MAAM,8BAA8B,CAAA;AACxF,OAAO,EAAE,sBAAsB,EAAqB,MAAM,+BAA+B,CAAA;AACzF,OAAO,EAAE,qBAAqB,EAAoB,MAAM,6BAA6B,CAAA;AACrF,OAAO,EAAE,uBAAuB,EAAsB,MAAM,+BAA+B,CAAA;AAO3F,eAAO,MAAM,UAAU,yDAAU,CAAA;AAEjC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,yBAAyB,CAAC,EAAE,OAAO,CAAA;CACpC,CAAA;AAED;;;GAGG;AACH,qBAAa,OAAO;IAClB,OAAO,SAAK;IACZ,SAAS,SAAK;IACd,SAAS,SAAK;IACd,OAAO,SAAK;IACZ,UAAU,SAAK;IACf,MAAM,SAAK;IAEX,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,YAAY,SAAoB;IAChC,MAAM,EAAG,sBAAsB,CAAA;IAC/B,KAAK,EAAG,qBAAqB,CAAA;IAC7B,MAAM,EAAG,sBAAsB,CAAA;IAC/B,OAAO,EAAG,uBAAuB,CAAA;IACjC,YAAY,EAAG,sBAAsB,CAAA;IACrC,OAAO,CAAC,EAAE,CAAS;IAEnB,yBAAyB,UAAQ;IAEjC,OAAO;IAYD,kBAAkB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,IAAI,CAAA;KAAE,GAAG;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;YA4B9E,IAAI;IAmEZ,kBAAkB;IAUxB,iBAAiB;IAkBX,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;WAKT,MAAM,CAAC,IAAI,EAAE,WAAW;CAKtC"}

package/dist/node/project/project.js

@@ -8,9 +8,11 @@ import { Configurator } from "./config.js";
 import { ProjectEnvUtils } from "./env.js";
 import { loadBlockManifest } from "./manifest/block-manifest.js";
 import { loadFieldManifest } from "./manifest/field-manifest.js";
+import { loadRouteManifest } from "./manifest/routes-manifest.js";
 import { loadViewManifest } from "./manifest/view-manifest.js";
 import { loadWidgetManifest } from "./manifest/widget-manifest.js";
 import { WPInfo } from "./wp-info.js";
+import { fs } from "../utils/fs.js";
 const console = createConsole("Project", "project");
 export const projectLog = console;
 /**
@@ -25,31 +27,74 @@ export class Project {
     configFile = "";
     origin = "";
     config;
+    cssEntryFile = "views/index.css";
     blocks;
     views;
     fields;
     widgets;
+    serverRoutes;
     wp;
     reportPluginCompatibility = false;
     constructor(opts) {
         this.rootDir = opts.rootDir;
-        this.origin = ProjectEnvUtils.get("SITE_URL");
+        this.origin = ProjectEnvUtils.getSafe("SITE_URL") ?? "";
         this.reportPluginCompatibility = opts.reportPluginCompatibility || false;
         this.blocks = loadBlockManifest(this);
         this.views = loadViewManifest(this);
         this.fields = loadFieldManifest(this);
         this.widgets = loadWidgetManifest(this);
-        this.wp = new WPInfo(ProjectEnvUtils.get("SITE_URL"));
+        this.serverRoutes = loadRouteManifest(this);
+        this.wp = new WPInfo(this.origin);
+    }
+    async verifyOriginAccess() {
+        try {
+            const response = await this.wp.ping();
+            if (!response.ok) {
+                return {
+                    success: false,
+                    message: [
+                        `Failed to access WordPress origin at ${this.origin}`,
+                        `Using API Key?: ${ProjectEnvUtils.getSafe("SITE_API_KEY") ? "Yes" : "No"}`,
+                        `Response: ${response.status} ${response.statusText}`,
+                    ].join("\n"),
+                };
+            }
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: [
+                    `Failed to access WordPress origin at ${this.origin}`,
+                    `Using API Key?: ${ProjectEnvUtils.getSafe("SITE_API_KEY") ? "Yes" : "No"}`,
+                    `The following error occurred:${err}`,
+                ].join("\n"),
+            };
+        }
     }
     async load() {
         console.setWorking(true);
         console.setState(this);
-        const repoInfo = await getRepoInfo(this.rootDir);
+        const repoInfo = await getRepoInfo(this.rootDir).catch(() => {
+            projectLog.warn("Failed to get repo info");
+            const name = this.rootDir.split("/").pop();
+            return {
+                themeName: name,
+                repoName: name,
+                repoURL: "",
+            };
+        });
         this.themeName = repoInfo.themeName;
         this.publicUrl = `/wp-content/themes/${repoInfo.themeName}/`;
         this.configFile = relative(process.cwd(), resolve(this.rootDir, "ed.config.json"));
         this.repoUrl = repoInfo.repoURL?.replace("git@github.com:", "https://github.com/").replace(".git", "") || "";
         this.reportProjectInfo();
+        /**
+         * Detect CSS file
+         */
+        await this.detectCssEntryFile();
         /**
          * Make sure the git repo name matches
          */
@@ -87,6 +132,15 @@ export class Project {
         console.setWorking(false);
         console.info(this.reportProjectInfo());
     }
+    async detectCssEntryFile() {
+        const candidates = ["styles/index.css", "views/index.css", "style.css"];
+        for (const candidate of candidates) {
+            if (await fs.exists(resolve(this.rootDir, candidate))) {
+                this.cssEntryFile = candidate;
+                break;
+            }
+        }
+    }
     reportProjectInfo() {
         return objFormat({
             "Theme Name": this.themeName,

package/dist/node/project/wp-info.d.ts

@@ -21,12 +21,15 @@ type WPInfoData = {
         isScalar: boolean;
         typeName: string;
     }[];
+    scalarTypeImports?: string[];
 };
 export declare class WPInfo {
     siteUrl: string;
     private cached?;
     constructor(siteUrl: string);
+    ping(): Promise<Response>;
     getInfo(force?: boolean): Promise<WPInfoData>;
     getPluginIssues(): Promise<string[]>;
 }
 export {};
+//# sourceMappingURL=wp-info.d.ts.map

package/dist/node/project/wp-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wp-info.d.ts","sourceRoot":"","sources":["../../../src/node/project/wp-info.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE;QACT,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,UAAU,EAAE,OAAO,CAAA;QACnB,iBAAiB,EAAE,MAAM,CAAA;QACzB,iBAAiB,EAAE,MAAM,CAAA;QACzB,iBAAiB,EAAE,OAAO,CAAA;KAC3B,EAAE,CAAA;IACH,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,GAAG,EAAE,MAAM,CAAA;KACZ,EAAE,CAAA;IACH,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,aAAa,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACrE,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC7B,CAAA;AAED,qBAAa,MAAM;IAEE,OAAO,EAAE,MAAM;IADlC,OAAO,CAAC,MAAM,CAAC,CAAY;gBACR,OAAO,EAAE,MAAM;IAE5B,IAAI;IASJ,OAAO,CAAC,KAAK,GAAE,OAAe;IAe9B,eAAe;CAetB"}

package/dist/node/project/wp-info.js

@@ -1,15 +1,27 @@
 import { resolveURL } from "ufo";
+import { fetchWP } from "../utils/fetch-wp.js";
 export class WPInfo {
     siteUrl;
     cached;
     constructor(siteUrl) {
         this.siteUrl = siteUrl;
     }
+    async ping() {
+        if (!this.siteUrl) {
+            throw new Error("Attempted to ping WordPress, but SITE_URL was not present in the environment.");
+        }
+        const url = resolveURL(this.siteUrl, "/wp-json/ed/v1/handshake");
+        const response = await fetchWP(url);
+        return response;
+    }
     async getInfo(force = false) {
+        if (!this.siteUrl) {
+            throw new Error("Attempted to get site info from WordPress, but SITE_URL was not present in the environment.");
+        }
         if (this.cached && !force)
             return this.cached;
         const url = resolveURL(this.siteUrl, "/wp-json/ed/v1/dev/site-info");
-        const response = await fetch(url);
+        const response = await fetchWP(url);
         const result = (await response.json());
         this.cached = result;
         return result;

package/dist/node/storybook/index.d.ts

@@ -0,0 +1,3 @@
+import { InlineConfig } from "vite";
+export declare function applyViteStorybookConfig(config: InlineConfig): InlineConfig;
+//# sourceMappingURL=index.d.ts.map

package/dist/node/storybook/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node/storybook/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAGnC,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,YAAY,gBAc5D"}

package/dist/node/storybook/index.js

@@ -0,0 +1,13 @@
+import { storybookVitePlugins } from "../compiler/get-vite-config";
+export function applyViteStorybookConfig(config) {
+    config.plugins?.push(storybookVitePlugins({
+        client: true,
+        console: console,
+        mode: process.env.NODE_ENV === "production" ? "production" : "development",
+        rootDir: process.cwd(),
+        publicUrl: "/",
+        serverless: true,
+        target: "frontend",
+    }));
+    return config;
+}

package/dist/node/types/block-type.d.ts

@@ -9,7 +9,7 @@ export declare const BlockMetaSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     category: z.ZodDefault<z.ZodString>;
     icon: z.ZodOptional<z.ZodString>;
-    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
     types: z.ZodArray<z.ZodString, "many">;
     templates: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     mode: z.ZodDefault<z.ZodEnum<["preview", "edit", "both"]>>;
@@ -23,70 +23,102 @@ export declare const BlockMetaSchema: z.ZodObject<{
     cache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     allowMultiple: z.ZodDefault<z.ZodBoolean>;
     postMetaBlock: z.ZodOptional<z.ZodObject<{
+        postTypes: z.ZodArray<z.ZodString, "many">;
         fieldName: z.ZodString;
     }, "strip", z.ZodTypeAny, {
+        postTypes: string[];
         fieldName: string;
     }, {
+        postTypes: string[];
         fieldName: string;
     }>>;
     frontendMode: z.ZodDefault<z.ZodEnum<["hidden", "childrenOnly", "default"]>>;
     inserter: z.ZodDefault<z.ZodBoolean>;
+    blockStyles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        name: string;
+        isDefault?: boolean | undefined;
+    }, {
+        label: string;
+        name: string;
+        isDefault?: boolean | undefined;
+    }>, "many">>;
+    lazyLoad: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    cache: boolean;
+    title: string;
+    mode: "both" | "edit" | "preview";
+    slug: string;
+    tags: string[];
+    flags: Record<string, any>;
+    category: string;
+    parent: string[];
+    inserter: boolean;
     acfName: string;
     fileName: string;
-    slug: string;
     graphqlFieldName: string;
-    title: string;
-    category: string;
     types: string[];
-    mode: "preview" | "edit" | "both";
-    tags: string[];
-    flags: Record<string, any>;
     childTags: string[];
     childBlocks: string[];
-    parent: string[];
     ancestors: string[];
     dynamic: boolean;
+    cache: boolean;
     allowMultiple: boolean;
-    frontendMode: "default" | "hidden" | "childrenOnly";
-    inserter: boolean;
-    description?: string | undefined;
+    frontendMode: "hidden" | "default" | "childrenOnly";
     icon?: string | undefined;
-    keywords?: string[] | undefined;
+    description?: string | undefined;
+    keywords?: string | string[] | undefined;
     templates?: string[] | null | undefined;
     postMetaBlock?: {
+        postTypes: string[];
         fieldName: string;
     } | undefined;
+    blockStyles?: {
+        label: string;
+        name: string;
+        isDefault?: boolean | undefined;
+    }[] | undefined;
+    lazyLoad?: boolean | undefined;
 }, {
+    title: string;
+    slug: string;
     acfName: string;
     fileName: string;
-    slug: string;
     graphqlFieldName: string;
-    title: string;
     types: string[];
-    cache?: boolean | undefined;
-    description?: string | undefined;
-    category?: string | undefined;
-    icon?: string | undefined;
-    keywords?: string[] | undefined;
-    templates?: string[] | null | undefined;
-    mode?: "preview" | "edit" | "both" | undefined;
+    mode?: "both" | "edit" | "preview" | undefined;
     tags?: string[] | undefined;
     flags?: Record<string, any> | undefined;
+    icon?: string | undefined;
+    category?: string | undefined;
+    description?: string | undefined;
+    keywords?: string | string[] | undefined;
+    parent?: string[] | undefined;
+    inserter?: boolean | undefined;
+    templates?: string[] | null | undefined;
     childTags?: string[] | undefined;
     childBlocks?: string[] | undefined;
-    parent?: string[] | undefined;
     ancestors?: string[] | undefined;
     dynamic?: boolean | undefined;
+    cache?: boolean | undefined;
     allowMultiple?: boolean | undefined;
     postMetaBlock?: {
+        postTypes: string[];
         fieldName: string;
     } | undefined;
-    frontendMode?: "default" | "hidden" | "childrenOnly" | undefined;
-    inserter?: boolean | undefined;
+    frontendMode?: "hidden" | "default" | "childrenOnly" | undefined;
+    blockStyles?: {
+        label: string;
+        name: string;
+        isDefault?: boolean | undefined;
+    }[] | undefined;
+    lazyLoad?: boolean | undefined;
 }>;
 export type BlockMetadata = z.infer<typeof BlockMetaSchema>;
 export type BlockMetadataConstructor = z.input<typeof BlockMetaSchema>;
 export declare function describeBlock(block: BlockMetadata): string;
 export declare function describeBlockManifest(manifest: BlockManifest): string;
+//# sourceMappingURL=block-type.d.ts.map

package/dist/node/types/block-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-type.d.ts","sourceRoot":"","sources":["../../../src/node/types/block-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAMrE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC1B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE3D,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEtE,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,UAkBjD;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,UA6B5D"}

package/dist/node/types/block-type.js

@@ -12,7 +12,7 @@ export const BlockMetaSchema = z.object({
     description: z.string().optional(),
     category: z.string().default("common"),
     icon: z.string().optional(),
-    keywords: z.array(z.string()).optional(),
+    keywords: z.union([z.string(), z.array(z.string())]).optional(),
     types: z.array(z.string()),
     templates: z.array(z.string()).nullable().optional(),
     mode: z.enum(["preview", "edit", "both"]).default("preview"),
@@ -27,11 +27,14 @@ export const BlockMetaSchema = z.object({
     allowMultiple: z.boolean().default(true),
     postMetaBlock: z
         .object({
+        postTypes: z.array(z.string()),
         fieldName: z.string(),
     })
         .optional(),
     frontendMode: z.enum(["hidden", "childrenOnly", "default"]).default("default"),
     inserter: z.boolean().default(true),
+    blockStyles: z.array(z.object({ name: z.string(), label: z.string(), isDefault: z.boolean().optional() })).optional(),
+    lazyLoad: z.boolean().optional(),
 });
 export function describeBlock(block) {
     let output = "";

package/dist/node/types/view-type.d.ts

@@ -9,23 +9,24 @@ export declare const ViewMetaSchema: z.ZodObject<{
     routePattern: z.ZodOptional<z.ZodString>;
     postType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    cache: boolean;
-    fileName: string;
-    slug: string;
     title: string;
+    slug: string;
+    fileName: string;
+    cache: boolean;
     isCustomTemplate: boolean;
-    routePattern?: string | undefined;
     postType?: string[] | undefined;
+    routePattern?: string | undefined;
 }, {
-    fileName: string;
-    slug: string;
     title: string;
+    slug: string;
+    fileName: string;
+    postType?: string[] | undefined;
     cache?: boolean | undefined;
     isCustomTemplate?: boolean | undefined;
     routePattern?: string | undefined;
-    postType?: string[] | undefined;
 }>;
 export type ViewMetadata = z.infer<typeof ViewMetaSchema>;
 export type ViewMetadataConstructor = z.input<typeof ViewMetaSchema>;
 export declare function describeView(view: ViewMetadata): string;
 export declare function describeViewManifest(manifest: ViewManifest): void;
+//# sourceMappingURL=view-type.d.ts.map

package/dist/node/types/view-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-type.d.ts","sourceRoot":"","sources":["../../../src/node/types/view-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAA;AAInE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAQzB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAEzD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAEpE,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,UAiB9C;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,QAuB1D"}

package/dist/node/utils/fetch-wp.d.ts

@@ -0,0 +1,2 @@
+export declare function fetchWP(url: string | URL, args?: RequestInit): Promise<Response>;
+//# sourceMappingURL=fetch-wp.d.ts.map

package/dist/node/utils/fetch-wp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-wp.d.ts","sourceRoot":"","sources":["../../../src/node/utils/fetch-wp.ts"],"names":[],"mappings":"AASA,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAmB1F"}

package/dist/node/utils/fetch-wp.js

@@ -0,0 +1,28 @@
+import { ProjectEnvUtils } from "../project/env.js";
+import { Agent, fetch, setGlobalDispatcher, Headers } from "undici";
+const agent = new Agent({
+    connect: {
+        rejectUnauthorized: false,
+    },
+});
+export async function fetchWP(url, args = {}) {
+    const headers = new Headers(args.headers);
+    // If an API key has been set in the environment, use it
+    const accessKey = ProjectEnvUtils.getSafe("SITE_API_KEY");
+    if (accessKey) {
+        headers.set("x-ed-api-key", accessKey);
+    }
+    // Allow self-signed certificates when using a local development domain
+    let allowSelfSigned = isDevelopmentDomain(url);
+    const response = (await fetch(url, {
+        ...args,
+        dispatcher: allowSelfSigned ? agent : undefined,
+        headers,
+    }));
+    return response;
+}
+setGlobalDispatcher(agent);
+function isDevelopmentDomain(url) {
+    const hostname = typeof url === "string" ? new URL(url).hostname : url.hostname;
+    return !!hostname?.match(/(^[0-9\.]+$|\.local$)/);
+}

package/dist/node/utils/format-zod-error.d.ts

@@ -1,3 +1,4 @@
 import { ZodError } from "zod-validation-error";
 export declare function formatZodError(error: ZodError): string;
 export declare function eachFormattedZodError(error: ZodError): string[];
+//# sourceMappingURL=format-zod-error.d.ts.map

package/dist/node/utils/format-zod-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-zod-error.d.ts","sourceRoot":"","sources":["../../../src/node/utils/format-zod-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAG/C,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,UAmB7C;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,YAapD"}

package/dist/node/utils/fs-codegen.d.ts

@@ -15,14 +15,17 @@ export declare class FSCodegen {
     project: Project;
     opts: {
         outDir: string;
+        onWritten?: (opts: Set<string>) => void;
     };
     outDir: string;
     private generators;
     private generatorFiles;
     private unsubscribers;
+    private writtenContent;
     private flushScheduled;
     constructor(project: Project, opts: {
         outDir: string;
+        onWritten?: (opts: Set<string>) => void;
     });
     register(generator: CodeGenerator): void;
     registerFile({ name, generate, subscribe, }: {
@@ -38,3 +41,4 @@ export declare class FSCodegen {
     stop(): void;
 }
 export {};
+//# sourceMappingURL=fs-codegen.d.ts.map