@ekrist1/vulse 0.1.6-alpha.3

package/dist/core/blueprints/compile.js

@@ -0,0 +1,153 @@
+import { createHash } from 'node:crypto';
+import { z } from 'astro/zod';
+import { validateSetNodes } from '../sets/validate-tree.js';
+import { LinkValueSchema } from './definition.js';
+import { seoZodSchema } from './seo.js';
+import { selectOptionKeys } from './select-helpers.js';
+export function compileBlueprintSchema(def, options = {}) {
+    const shape = {};
+    for (const f of def.fields) {
+        shape[f.name] = compileField(f, options.sets);
+    }
+    if (def.seo) {
+        shape.seo = seoZodSchema();
+    }
+    return z.object(shape);
+}
+function compileField(f, sets) {
+    return compileFieldBase(f, true, sets);
+}
+function compileFieldBase(f, allowMetaFields, sets) {
+    let s = z.never();
+    switch (f.ui.kind) {
+        case 'text':
+        case 'textarea': {
+            let str = z.string();
+            if (f.validation?.min !== undefined)
+                str = str.min(f.validation.min);
+            if (f.validation?.max !== undefined)
+                str = str.max(f.validation.max);
+            s = str;
+            break;
+        }
+        case 'date':
+            s = z.coerce.date();
+            break;
+        case 'boolean':
+            s = z.boolean();
+            break;
+        case 'select': {
+            const keys = selectOptionKeys(f.ui.options);
+            const enumSchema = z.enum(keys);
+            s = f.ui.multiple ? z.array(enumSchema) : enumSchema;
+            break;
+        }
+        case 'blocks': {
+            const declaredSets = f.ui.sets;
+            const tag = declaredSets?.length
+                ? `vulse:blocks:${declaredSets.join(',')}`
+                : 'vulse:blocks';
+            if (declaredSets?.length && sets) {
+                s = z.any().superRefine((value, refinementCtx) => {
+                    validateSetNodes(value, [], sets, refinementCtx);
+                });
+            }
+            else {
+                s = z.any();
+            }
+            s = s.describe(tag);
+            break;
+        }
+        case 'relationship':
+            s = z.string().describe(`vulse:ref:${f.ui.to}`);
+            break;
+        case 'entry':
+            s = z.string().min(1).describe(`vulse:entry:${f.ui.collections.join(',')}`);
+            break;
+        case 'entries': {
+            let arr = z.array(z.string().min(1));
+            if (f.ui.max !== undefined)
+                arr = arr.max(f.ui.max);
+            const tag = f.ui.max !== undefined
+                ? `vulse:entries:${f.ui.collections.join(',')}:${f.ui.max}`
+                : `vulse:entries:${f.ui.collections.join(',')}`;
+            s = arr.describe(tag);
+            break;
+        }
+        case 'link': {
+            const tag = f.ui.collections?.length
+                ? `vulse:link:${f.ui.collections.join(',')}`
+                : 'vulse:link';
+            s = LinkValueSchema.describe(tag);
+            break;
+        }
+        case 'asset':
+            s = z.string().describe('vulse:media');
+            break;
+        case 'replicator':
+            if (!allowMetaFields) {
+                s = z.never();
+                break;
+            }
+            s = compileReplicatorField(f.ui.sets);
+            break;
+        case 'grid':
+            if (!allowMetaFields) {
+                s = z.never();
+                break;
+            }
+            s = compileGridField(f.ui);
+            break;
+    }
+    if (f.default !== undefined)
+        s = s.default(f.default);
+    if (f.optional)
+        s = s.optional();
+    return s;
+}
+function compileReplicatorField(sets) {
+    const schemas = sets.map((set) => z.object({
+        set: z.literal(set.name),
+        content: compileFieldObject(set.fields),
+    }));
+    if (schemas.length === 1)
+        return z.array(schemas[0]);
+    const [first, second, ...rest] = schemas;
+    return z.array(z.discriminatedUnion('set', [first, second, ...rest]));
+}
+function compileGridField(ui) {
+    let arr = z.array(compileFieldObject(ui.fields));
+    if (ui.minRows !== undefined)
+        arr = arr.min(ui.minRows);
+    if (ui.maxRows !== undefined)
+        arr = arr.max(ui.maxRows);
+    return arr.describe('vulse:grid');
+}
+export function compileFieldObject(fields) {
+    const shape = {};
+    for (const field of fields) {
+        shape[field.name] = compileFieldBase(field, false, undefined);
+    }
+    return z.object(shape);
+}
+export function hashDefinition(def) {
+    const canonical = JSON.stringify({
+        handle: def.handle,
+        label: def.label,
+        singleton: def.singleton,
+        tree: def.tree ?? false,
+        maxDepth: def.maxDepth ?? null,
+        drafts: def.drafts ?? false,
+        seo: def.seo ?? false,
+        seoMapping: def.seoMapping ?? null,
+        fields: def.fields.map((f) => ({
+            name: f.name,
+            label: f.label ?? null,
+            ui: f.ui,
+            optional: f.optional,
+            default: f.default ?? null,
+            validation: f.validation ?? null,
+        })),
+    });
+    return createHash('sha256').update(canonical).digest('hex');
+}

package/dist/core/blueprints/define.d.ts

@@ -0,0 +1,6 @@
+import type { z as Zod } from 'astro/zod';
+import type { Blueprint } from './types.js';
+import { z } from './zod-helpers.js';
+export declare function defineCollection<S extends Zod.ZodTypeAny>(input: Blueprint<S>): Blueprint<S>;
+export { z };
+//# sourceMappingURL=define.d.ts.map

package/dist/core/blueprints/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/define.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,IAAI,GAAG,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAA;AAEpC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAK5F;AAED,OAAO,EAAE,CAAC,EAAE,CAAA"}

package/dist/core/blueprints/define.js

@@ -0,0 +1,8 @@
+import { z } from './zod-helpers.js';
+export function defineCollection(input) {
+    if (!input.name || !/^[a-z][a-z0-9_-]*$/.test(input.name)) {
+        throw new Error(`Blueprint "${input.name}": name must be lowercase kebab/snake case`);
+    }
+    return input;
+}
+export { z };