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

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

@@ -5,124 +5,257 @@ export declare const EDConfigSchema: z.ZodObject<{
     version: z.ZodEffects<z.ZodEnum<["1", "2"]>, "2", "1" | "2">;
     legacyMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     legacyStitches: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    tracking: z.ZodOptional<z.ZodObject<{
-        tagManagerID: z.ZodOptional<z.ZodString>;
-        ga: z.ZodOptional<z.ZodObject<{
-            trackingID: z.ZodOptional<z.ZodString>;
-            version: z.ZodEnum<["3", "4"]>;
-        }, "strip", z.ZodTypeAny, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }>>;
+    trackers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
+        provider: z.ZodLiteral<"ga4">;
+        id: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
+        id: string;
+        provider: "ga4";
     }, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    }>>;
+        id: string;
+        provider: "ga4";
+    }>, z.ZodObject<{
+        provider: z.ZodLiteral<"gtm">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        provider: "gtm";
+    }, {
+        id: string;
+        provider: "gtm";
+    }>]>, "many">>;
     serverless: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         uploads: z.ZodEnum<["proxy", "remote"]>;
         plugins: z.ZodDefault<z.ZodEnum<["proxy", "remote"]>>;
+        admin: z.ZodDefault<z.ZodEnum<["proxy", "hide"]>>;
+        originProtection: z.ZodDefault<z.ZodObject<{
+            requireLogin: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            requireLogin: boolean;
+        }, {
+            requireLogin?: boolean | undefined;
+        }>>;
         themeAssets: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-        apiOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
-        defaultRevalidate: z.ZodOptional<z.ZodNumber>;
-        defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
+        cors: z.ZodOptional<z.ZodObject<{
+            origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            origins?: string[] | undefined;
+        }, {
+            origins?: string[] | undefined;
+        }>>;
+        csp: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            autoDetect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            nonce: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            commonOrigins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            nonce: boolean;
+            enabled: boolean;
+            autoDetect: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        }, {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            nonce?: boolean | undefined;
+            autoDetect?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
+        admin: "hide" | "proxy";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        csp: {
+            nonce: boolean;
+            enabled: boolean;
+            autoDetect: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        };
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }, {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
+        admin?: "hide" | "proxy" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
+        csp?: {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            nonce?: boolean | undefined;
+            autoDetect?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        } | undefined;
     }>;
-    cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        props: z.ZodNumber;
-        queries: z.ZodNumber;
+    cache: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<["always", "ssr-always-fresh"]>;
+            cacheHeaders: z.ZodDefault<z.ZodBoolean>;
+            transients: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        }, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        }>>>;
+        serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            isr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
+        }, "strip", z.ZodTypeAny, {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        }, {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        }>>>;
+        pageDataTTL: z.ZodDefault<z.ZodNumber>;
+        appDataTTL: z.ZodDefault<z.ZodNumber>;
+        queryHooksTTL: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        props: number;
-        queries: number;
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
     }, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }>>>;
     devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
 }, "strip", z.ZodTypeAny, {
     version: "2";
+    cache: Record<string, {
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
+    }>;
     legacyMetadata: boolean;
     legacyStitches: boolean;
     serverless: {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
+        admin: "hide" | "proxy";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        csp: {
+            nonce: boolean;
+            enabled: boolean;
+            autoDetect: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        };
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
-    devUI: "enabled" | "disabled";
+    devUI: "disabled" | "enabled";
     $schema?: string | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
+    trackers?: ({
+        id: string;
+        provider: "ga4";
+    } | {
+        id: string;
+        provider: "gtm";
+    })[] | undefined;
 }, {
     version: "1" | "2";
     serverless: {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
+        admin?: "hide" | "proxy" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
+        csp?: {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            nonce?: boolean | undefined;
+            autoDetect?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        } | undefined;
     };
+    cache?: Record<string, {
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
+    }> | undefined;
     $schema?: string | undefined;
     legacyMetadata?: boolean | undefined;
     legacyStitches?: boolean | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
-    devUI?: "enabled" | "disabled" | undefined;
+    trackers?: ({
+        id: string;
+        provider: "ga4";
+    } | {
+        id: string;
+        provider: "gtm";
+    })[] | undefined;
+    devUI?: "disabled" | "enabled" | undefined;
 }>;
 export type EDConfig = z.infer<typeof EDConfigSchema>;
 export declare class Configurator {
@@ -136,3 +269,4 @@ export declare class Configurator {
     private reportError;
     static describeConfig(config: EDConfig, project: Project): string;
 }
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAE7D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAYlB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}

package/dist/node/project/config.js

@@ -15,16 +15,18 @@ export const EDConfigSchema = z.object({
         .default(false)
         .describe("Whether to use legacy comments or exported JSON for block and view metadata"),
     legacyStitches: z.boolean().optional().default(true).describe("Whether this site is using Stitches"),
-    tracking: z
-        .object({
-        tagManagerID: z.string().optional(),
-        ga: z
-            .object({
-            trackingID: z.string().optional(),
-            version: z.enum(["3", "4"]),
-        })
-            .optional(),
-    })
+    trackers: z
+        .array(z.discriminatedUnion("provider", [
+        z.object({
+            provider: z.literal("ga4"),
+            id: z.string().describe("The Google Analytics 4 tracking ID"),
+        }),
+        z.object({
+            provider: z.literal("gtm"),
+            id: z.string().describe("The Google Tag Manager project ID (eg. GTM-XXXXXXX)"),
+        }),
+    ]))
+        .describe("An array of standard tracking codes to embed")
         .optional(),
     serverless: z.object({
         enabled: z.boolean().default(true).describe("Whether to deploy the site as a serverless app"),
@@ -35,25 +37,97 @@ export const EDConfigSchema = z.object({
             .enum(["proxy", "remote"])
             .default("remote")
             .describe("Whether to proxy plugin assets or serve them from the serverless endpoint.\nDefault is `remote`, but `proxy` can be used to hide the CMS origin."),
-        // theme: z.enum(["proxy", "copy", "remote"]),
+        admin: z
+            .enum(["proxy", "hide"])
+            .default("proxy")
+            .describe("How to handle the WordPress admin URLs.\nDefault is `proxy`, which will proxy the admin URLs to the CMS origin. When set to `hide`, all /wp-admin, /wp-json and /wp-login.php URLs will show a 404 page.\nHas no effect in dev mode."),
+        originProtection: z
+            .object({
+            requireLogin: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Enabling this will prevent access to the frontend for non-logged-in users on the CMS origin (eg. Flywheel, WPEngine), but allow access to the serverless frontend (eg. Vercel)."),
+        })
+            .default({}),
         themeAssets: z
             .array(z.string())
             .optional()
             .default(["assets"])
-            .describe('Files to include in a serverless deployment.\nDefault is `["assets"]`'),
-        apiOnly: z.boolean().optional().default(false).describe("Whether to deploy only the API, not the frontend"),
+            .describe('Asset folders to include in a serverless deployment.\nDefault is `["assets"]`'),
         endpoints: z
             .record(z.string(), z.string())
             .describe("A map of WordPress hostnames -> serverless hostnames. You can use `*` as a wildcard for the key.\n\nFor example, `{'cms.ed.studio': 'ed.studio'}` tells the WordPress frontend where it can find any serverless API endpoints."),
-        defaultRevalidate: z.number().optional(),
-        defaultRevalidateQueries: z.number().optional(),
+        cors: z
+            .object({
+            origins: z
+                .array(z.string())
+                .optional()
+                .describe("A list of allowed origins for CORS. Set to ['*'] to allow all. All WordPress hosts are also allowed."),
+        })
+            .optional(),
+        csp: z
+            .object({
+            enabled: z.boolean(),
+            autoDetect: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to auto-detect CSP origins from the tracking scripts, and wp_head/wp_footer scripts and styles."),
+            nonce: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Whether to use nonces for scripts and styles. The nonce attribute will be applied to all tracking snipets, and styles/scripts used in wp_head/wp_footer."),
+            commonOrigins: z
+                .string()
+                .array()
+                .describe("A list of common origins, to be shared amoungst all directives. Items should be things like 'hubspot.com' or '*.hubspot.com'")
+                .optional(),
+            values: z
+                .record(z.string().array())
+                .optional()
+                .describe("A map of CSP directives to their values. Keys should be camelCase."),
+        })
+            .default({ enabled: false })
+            .describe("Content Security Policy settings"),
     }),
     cache: z
-        .record(z.string(), z.object({
-        props: z.number(),
-        queries: z.number(),
+        .record(z.object({
+        wordpress: z
+            .object({
+            strategy: z.enum(["always", "ssr-always-fresh"]),
+            cacheHeaders: z.boolean().default(true).describe("Whether to add caching headers to data requests."),
+            transients: z.boolean().default(true).describe("Whether to cache within transients."),
+        })
+            .optional()
+            .default({ strategy: "always", cacheHeaders: true, transients: true }),
+        serverless: z
+            .object({
+            isr: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to use Incremental Static Regeneration for this origin."),
+            dataCache: z
+                .enum(["in-memory", "kv", "none"])
+                .default("in-memory")
+                .describe("The cache strategy to use for page data."),
+        })
+            .optional()
+            .default({ isr: true, dataCache: "in-memory" }),
+        pageDataTTL: z.number().default(300).describe("The number of seconds to cache page data."),
+        appDataTTL: z.number().default(300).describe("The number of seconds to cache global app data."),
+        queryHooksTTL: z.number().default(300).describe("The number of seconds to cache named GraphQL queries."),
     }))
-        .optional(),
+        .default({
+        "*": {
+            pageDataTTL: 300,
+            appDataTTL: 300,
+            queryHooksTTL: 300,
+        },
+    })
+        .describe("A map of WordPress origin hostnames -> cache settings. Wildcards can be used for each domain."),
     devUI: z.enum(["disabled", "enabled"]).default("enabled"),
 });
 export class Configurator {
@@ -115,7 +189,7 @@ export class Configurator {
             this.config = undefined;
             if (exitOnError) {
                 console.flush();
-                process.exit(0);
+                process.exit(1);
             }
         }
     }

package/dist/node/project/eddev-build-file.d.ts

@@ -8,3 +8,4 @@ export declare class BuildInfoWriter {
     watch(): void;
     write(): Promise<void>;
 }
+//# sourceMappingURL=eddev-build-file.d.ts.map

package/dist/node/project/eddev-build-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddev-build-file.d.ts","sourceRoot":"","sources":["../../../src/node/project/eddev-build-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C;;GAEG;AACH,qBAAa,eAAe;IACP,OAAO,EAAE,OAAO;gBAAhB,OAAO,EAAE,OAAO;IAEnC,KAAK;IAUC,KAAK;CAgEZ"}

package/dist/node/project/eddev-build-file.js

@@ -53,14 +53,16 @@ export class BuildInfoWriter {
                         align_text: false,
                         align_center: false,
                         multiple: block.allowMultiple ? true : false,
-                        mode: block.mode ?? "preview",
+                        mode: block.mode === "both" ? true : false,
                         customClassName: false,
                         inserter: block.inserter,
                     },
-                    mode: block.mode ?? "preview",
+                    mode: block.mode === "edit" ? "edit" : "preview",
                     canCache: block.cache,
                     frontendMode: block.frontendMode,
                     postmeta: block.postMetaBlock,
+                    blockStyles: block.blockStyles,
+                    defaultBlockStyle: block.blockStyles?.find((s) => s.isDefault)?.name,
                 };
             }),
             templates: Object.values(viewManifest.views)

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

@@ -5,22 +5,26 @@ export declare const fields: {
     readonly SITE_URL: z.ZodString;
     readonly DEV_HOT_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
     readonly DEV_SERVERLESS_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodString>;
 };
 export declare const ProjectEnvSchema: z.ZodObject<{
     readonly DEBUG_GRAPHQL_URL: z.ZodOptional<z.ZodString>;
     readonly SITE_URL: z.ZodOptional<z.ZodString>;
     readonly DEV_HOT_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
     readonly DEV_SERVERLESS_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: number | undefined;
     DEV_SERVERLESS_PORT?: number | undefined;
+    SITE_API_KEY?: string | undefined;
 }, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: string | undefined;
     DEV_SERVERLESS_PORT?: string | undefined;
+    SITE_API_KEY?: string | undefined;
 }>;
 export type ProjectEnvKey = keyof typeof fields;
 export declare const ProjectEnvUtils: {
@@ -37,3 +41,4 @@ export declare const ProjectEnvUtils: {
     getSafe<T extends ProjectEnvKey>(key: T): Required<ProjectEnvMap[T]> | undefined;
     get<T extends ProjectEnvKey>(key: T, cons?: import("../utils/stateful-log.js").StatefulLog<import("./project.js").Project>): z.infer<(typeof fields)[T]>;
 };
+//# sourceMappingURL=env.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/node/project/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAQ5D,eAAO,MAAM,MAAM;;;;;;CAWT,CAAA;AAEV,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAA6B,CAAA;AAE1D,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,MAAM,CAAA;AAE/C,eAAO,MAAM,eAAe;IAC1B;;;OAGG;sBACe,OAAO,GAAG;QAAE,KAAK,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,aAAa,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE;YA2B1E,CAAC,SAAS,aAAa,OAAO,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;QAQ5E,CAAC,SAAS,aAAa,OAAO,CAAC,0FAAmB,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,MAAM,EAAE,CAAC,CAAC,CAAC;CAclF,CAAA"}

package/dist/node/project/env.js

@@ -15,6 +15,7 @@ export const fields = {
     SITE_URL: z.string().url().describe("The URL of the site"),
     DEV_HOT_PORT: portNumber,
     DEV_SERVERLESS_PORT: portNumber,
+    SITE_API_KEY: z.string().optional().describe("The API key for the site, when origin protection is enabled"),
 };
 export const ProjectEnvSchema = z.object(fields).partial();
 export const ProjectEnvUtils = {

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

@@ -1 +1 @@
-export {};
+//# sourceMappingURL=favicons.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"favicons.d.ts","sourceRoot":"","sources":["../../../src/node/project/favicons.ts"],"names":[],"mappings":""}

package/dist/node/project/favicons.js

@@ -1 +1 @@
-export {};
+"use strict";

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

@@ -17,3 +17,4 @@ type BlockLoadResult = {
 export type BlockManifestGenerator = ReturnType<typeof loadBlockManifest>;
 export declare function loadBlockManifest(project: Project): import("./manifest.js").ManifestGenerator<BlockLoadResult, BlockManifest>;
 export {};
+//# sourceMappingURL=block-manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/block-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,aAAa,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AAIpG,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAMvC,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE;QACN,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAA;KAC3B,CAAA;IACD,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,eAAe,GAAG;IACrB,IAAI,EAAE,wBAAwB,GAAG,IAAI,CAAA;IACrC,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,6EA0GjD"}

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

@@ -129,11 +129,15 @@ function readBlockDataAsJSONExport(file, contents) {
     result.parent = userData.conditions?.parents;
     result.types = userData.conditions?.postTypes;
     result.templates = userData.conditions?.templates;
-    result.allowMultiple = userData.conditions?.multiple !== false;
+    result.allowMultiple = userData.conditions?.multiple === false ? false : true;
+    result.mode = userData.editMode;
     result.inserter = userData.inserter;
     result.frontendMode = userData.frontendMode;
+    result.blockStyles = userData.blockStyles;
+    result.dynamic = userData.lazyLoad ?? true;
     if (userData.postMetaBlock) {
         result.postMetaBlock = {
+            postTypes: userData.postMetaBlock.postTypes,
             fieldName: userData.postMetaBlock.fieldName,
         };
         result.types = userData.postMetaBlock.postTypes;
@@ -192,7 +196,7 @@ function readBlockDataAsComment(file) {
                 meta.childTags = value.split(/,\s*/);
                 return;
             case "dynamic":
-                meta.dynamic = value === "true";
+                meta.dynamic = value !== "false";
                 return;
             case "cache":
                 meta.cache = value === "true";

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

@@ -15,3 +15,4 @@ type FieldInfo = {
 export type FieldManifestGenerator = ReturnType<typeof loadFieldManifest>;
 export declare function loadFieldManifest(project: Project): import("./manifest.js").ManifestGenerator<FieldInfo, FieldManifest>;
 export {};
+//# sourceMappingURL=field-manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/field-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,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,SAAS,GAAG;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,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,uEA0CjD"}

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

@@ -8,6 +8,7 @@ type ManifestEntry<TEntryData> = {
 type ManifestGeneratorArgs<TEntryData, TManifest> = {
     baseDir: string;
     pattern: string | string[];
+    ignore?: string[];
     watch: boolean;
     loadValue: (path: string, key: string) => Promise<TEntryData>;
     getKey: (path: string) => string | null;
@@ -28,3 +29,4 @@ export type ManifestGenerator<TEntryData, TManifest> = {
 };
 export declare function createManifestGenerator<TEntryData, TManifest>(args: ManifestGeneratorArgs<TEntryData, TManifest>): ManifestGenerator<TEntryData, TManifest>;
 export {};
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA8B,MAAM,gCAAgC,CAAA;AAGtF,KAAK,aAAa,CAAC,UAAU,IAAI;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,UAAU,CAAA;CAClB,CAAA;AAED,KAAK,qBAAqB,CAAC,UAAU,EAAE,SAAS,IAAI;IAClD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC1B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAC7D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACvC,gBAAgB,EAAE,CAAC,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAC,UAAU,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,SAAS,CAAC,CAAA;IAC/F,YAAY,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,UAAU,EAAE,SAAS,IAAI;IACrD,2DAA2D;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,+FAA+F;IAC/F,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;IACxF,kCAAkC;IAClC,eAAe,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;IAC9F,qFAAqF;IACrF,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,CAAA;CAC1B,CAAA;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,qBAAqB,CAAC,UAAU,EAAE,SAAS,CAAC,GAkH1G,iBAAiB,CAAC,UAAU,EAAE,SAAS,CAAC,CAC9C"}