@ekrist1/vulse 0.1.6-alpha.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/definition.ts"],"names":[],"mappings":"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"}

package/dist/core/blueprints/definition.js

@@ -0,0 +1,151 @@
+import { z } from 'astro/zod';
+import { SeoFieldMappingSchema } from './seo.js';
+export const SelectOptionSchema = z.union([
+    z.string().min(1),
+    z.object({ key: z.string().min(1), label: z.string().min(1) }),
+]);
+export const LinkValueSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('url'), url: z.string().min(1) }),
+    z.object({
+        type: z.literal('entry'),
+        entryId: z.string().min(1),
+        collection: z.string().min(1),
+    }),
+    z.object({ type: z.literal('first-child') }),
+]);
+const textFieldUiSchema = z.object({ kind: z.literal('text') });
+const textareaFieldUiSchema = z.object({ kind: z.literal('textarea') });
+const blocksFieldUiSchema = z.object({
+    kind: z.literal('blocks'),
+    sets: z.array(z.string().regex(/^[a-z][a-z0-9_-]*$/)).optional(),
+});
+const dateFieldUiSchema = z.object({ kind: z.literal('date') });
+const booleanFieldUiSchema = z.object({ kind: z.literal('boolean') });
+const selectFieldUiSchema = z.object({
+    kind: z.literal('select'),
+    options: z.array(SelectOptionSchema).min(1),
+    multiple: z.boolean().optional(),
+    placeholder: z.string().optional(),
+    clearable: z.boolean().optional(),
+});
+const relationshipFieldUiSchema = z.object({
+    kind: z.literal('relationship'),
+    to: z.string().min(1),
+});
+const entryFieldUiSchema = z.object({
+    kind: z.literal('entry'),
+    collections: z.array(z.string().min(1)).min(1),
+});
+const entriesFieldUiSchema = z.object({
+    kind: z.literal('entries'),
+    collections: z.array(z.string().min(1)).min(1),
+    max: z.number().int().positive().optional(),
+});
+const linkFieldUiSchema = z.object({
+    kind: z.literal('link'),
+    collections: z.array(z.string().min(1)).optional(),
+});
+const assetFieldUiSchema = z.object({ kind: z.literal('asset') });
+const nonReplicatorFieldUiSchemas = [
+    textFieldUiSchema,
+    textareaFieldUiSchema,
+    blocksFieldUiSchema,
+    dateFieldUiSchema,
+    booleanFieldUiSchema,
+    selectFieldUiSchema,
+    relationshipFieldUiSchema,
+    entryFieldUiSchema,
+    entriesFieldUiSchema,
+    linkFieldUiSchema,
+    assetFieldUiSchema,
+];
+export const NonReplicatorFieldUiSchema = z.discriminatedUnion('kind', nonReplicatorFieldUiSchemas);
+export const FieldValidationSchema = z
+    .object({
+    min: z.number().int().nonnegative().optional(),
+    max: z.number().int().positive().optional(),
+})
+    .optional();
+export const NestedFieldDefinitionSchema = z.object({
+    name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/),
+    label: z.string().optional(),
+    ui: NonReplicatorFieldUiSchema,
+    optional: z.boolean(),
+    default: z.unknown().optional(),
+    validation: FieldValidationSchema,
+});
+export const ReplicatorSetSchema = z.object({
+    name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/),
+    label: z.string().optional(),
+    fields: z.array(NestedFieldDefinitionSchema).min(1),
+});
+const replicatorFieldUiSchema = z.object({
+    kind: z.literal('replicator'),
+    sets: z.array(ReplicatorSetSchema).min(1),
+});
+const gridFieldUiSchema = z.object({
+    kind: z.literal('grid'),
+    fields: z.array(NestedFieldDefinitionSchema).min(1),
+    minRows: z.number().int().nonnegative().optional(),
+    maxRows: z.number().int().positive().optional(),
+    mode: z.enum(['table', 'stacked']).optional(),
+    addLabel: z.string().optional(),
+});
+const fieldUiSchemas = [
+    ...nonReplicatorFieldUiSchemas,
+    replicatorFieldUiSchema,
+    gridFieldUiSchema,
+];
+export const FieldUiSchema = z.discriminatedUnion('kind', fieldUiSchemas);
+export const FieldDefinitionSchema = z.object({
+    name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/),
+    label: z.string().optional(),
+    ui: FieldUiSchema,
+    optional: z.boolean(),
+    default: z.unknown().optional(),
+    validation: FieldValidationSchema,
+});
+export const PreviewDefinitionSchema = z.object({
+    path: z
+        .string()
+        .min(1)
+        .refine((p) => p.startsWith('/'), 'path must start with /')
+        .refine((p) => p.includes('{slug}'), 'path must include {slug}'),
+    rootSelector: z.string().min(1).optional(),
+    live: z.boolean().optional(),
+});
+const BlueprintDefinitionObjectSchema = z.object({
+    handle: z.string().regex(/^[a-z][a-z0-9_-]*$/),
+    label: z.string().min(1),
+    singleton: z.boolean(),
+    tree: z.boolean().optional(),
+    maxDepth: z.number().int().positive().optional(),
+    drafts: z.boolean().optional(),
+    seo: z.boolean().optional(),
+    seoMapping: SeoFieldMappingSchema.optional(),
+    preview: PreviewDefinitionSchema.optional(),
+    fields: z.array(FieldDefinitionSchema).min(1),
+});
+function checkBlueprintConstraints(d, ctx) {
+    if (d.singleton && d.tree) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'A blueprint cannot be both singleton and tree-structured.',
+            path: ['tree'],
+        });
+    }
+    if (d.maxDepth !== undefined && !d.tree) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'maxDepth requires tree: true.',
+            path: ['maxDepth'],
+        });
+    }
+}
+export const BlueprintDefinitionSchema = BlueprintDefinitionObjectSchema.superRefine(checkBlueprintConstraints);
+export const FieldDefinitionWithRenameSchema = FieldDefinitionSchema.extend({
+    previousName: z.string().optional(),
+});
+export const BlueprintDefinitionWithRenamesSchema = BlueprintDefinitionObjectSchema.extend({
+    fields: z.array(FieldDefinitionWithRenameSchema).min(1),
+}).superRefine(checkBlueprintConstraints);

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

@@ -0,0 +1,11 @@
+import { BlueprintRegistry } from './registry.js';
+import type { Blueprint } from './types.js';
+import type { VulseDb } from '../db.js';
+export declare function registryFromDb(db: VulseDb): Promise<BlueprintRegistry>;
+/** Load registry from D1 when available, otherwise code-only blueprints. */
+export declare function registryForRequest(db?: VulseDb): Promise<BlueprintRegistry>;
+export declare function registryFromUserCollections(db?: VulseDb): Promise<BlueprintRegistry>;
+/** For tests: bypass blueprint loading with explicit blueprints. */
+export declare function _seedRegistry(blueprints: Blueprint[]): void;
+export declare function _resetRegistry(): void;
+//# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/load.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAoEvC,wBAAsB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAiC5E;AAED,4EAA4E;AAC5E,wBAAsB,kBAAkB,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAcjF;AAED,wBAAsB,2BAA2B,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAS1F;AAED,oEAAoE;AACpE,wBAAgB,aAAa,CAAC,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,CAG3D;AAED,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/core/blueprints/load.js

@@ -0,0 +1,137 @@
+import { BlueprintRegistry } from './registry.js';
+import { createDb } from '../db.js';
+import { compileBlueprintSchema } from './compile.js';
+import { listBlueprintDefinitions } from './mutations.js';
+import { seedCodeBlueprints } from './seed.js';
+import { loadCompiledSets } from '../sets/service.js';
+import { toPreviewConfig } from './preview-path.js';
+import { applySeoToSchema } from './seo.js';
+let registryCache = null;
+let seededBlueprints = null;
+async function loadBlueprintModules() {
+    if (seededBlueprints)
+        return seededBlueprints;
+    try {
+        const mod = await import('virtual:vulse-blueprints');
+        return mod.default;
+    }
+    catch {
+        return [];
+    }
+}
+function finalizeBlueprint(bp) {
+    const seo = bp.seo === true;
+    if (!seo)
+        return bp;
+    return {
+        ...bp,
+        seo: true,
+        schema: applySeoToSchema(bp.schema),
+    };
+}
+function normalizeSeoMapping(mapping) {
+    if (!mapping)
+        return undefined;
+    const out = {};
+    if (mapping.metaTitle !== undefined)
+        out.metaTitle = mapping.metaTitle;
+    if (mapping.metaDescription !== undefined)
+        out.metaDescription = mapping.metaDescription;
+    if (mapping.ogImage !== undefined)
+        out.ogImage = mapping.ogImage;
+    return Object.keys(out).length ? out : undefined;
+}
+function mergeAdmin(compiled, code) {
+    const admin = code?.admin ?? compiled.admin;
+    const seoMapping = normalizeSeoMapping(code?.admin?.seoMapping ?? compiled.definition?.seoMapping);
+    if (!seoMapping)
+        return admin;
+    return { ...admin, seoMapping };
+}
+function mergeBlueprint(compiled, code) {
+    const rawPreview = code?.preview ?? compiled.preview;
+    const preview = rawPreview ? toPreviewConfig(rawPreview) : undefined;
+    const seo = code?.seo ?? compiled.seo;
+    return finalizeBlueprint({
+        ...compiled,
+        admin: mergeAdmin(compiled, code),
+        ...(code?.access ? { access: code.access } : {}),
+        ...(preview ? { preview } : {}),
+        ...(seo ? { seo: true } : {}),
+    });
+}
+function inferAdmin(def) {
+    const titleField = def?.fields.find((f) => f.ui.kind === 'text')?.name ?? def?.fields[0]?.name ?? 'id';
+    return { titleField, listColumns: [titleField] };
+}
+export async function registryFromDb(db) {
+    const codeBlueprints = await loadBlueprintModules();
+    await seedCodeBlueprints(db, codeBlueprints);
+    const sets = await loadCompiledSets(db);
+    const codeByName = new Map(codeBlueprints.map((bp) => [bp.name, bp]));
+    const reg = new BlueprintRegistry();
+    const definitions = await listBlueprintDefinitions(db);
+    for (const def of definitions) {
+        const schema = compileBlueprintSchema(def, { sets });
+        const code = codeByName.get(def.handle);
+        const bp = mergeBlueprint({
+            name: def.handle,
+            label: def.label,
+            schema,
+            admin: code?.admin ?? inferAdmin(def),
+            singleton: def.singleton,
+            fields: def.fields,
+            definition: def,
+            ...(def.tree !== undefined ? { tree: def.tree } : {}),
+            ...(def.maxDepth !== undefined ? { maxDepth: def.maxDepth } : {}),
+            ...(def.drafts !== undefined ? { drafts: def.drafts } : {}),
+            ...(def.seo !== undefined ? { seo: def.seo } : {}),
+            ...(def.preview ? { preview: toPreviewConfig(def.preview) } : {}),
+        }, code);
+        reg.register(bp);
+    }
+    for (const code of codeBlueprints) {
+        if (!reg.has(code.name))
+            reg.register(finalizeBlueprint(code));
+    }
+    return reg;
+}
+/** Load registry from D1 when available, otherwise code-only blueprints. */
+export async function registryForRequest(db) {
+    if (db) {
+        return registryFromDb(db);
+    }
+    if (registryCache)
+        return registryCache;
+    try {
+        const { getRuntimeEnv } = await import('../../server/env.js');
+        const env = getRuntimeEnv();
+        const conn = createDb(env.DB);
+        registryCache = await registryFromDb(conn);
+        return registryCache;
+    }
+    catch {
+        return registryFromUserCollections();
+    }
+}
+export async function registryFromUserCollections(db) {
+    if (db)
+        return registryFromDb(db);
+    if (registryCache)
+        return registryCache;
+    const reg = new BlueprintRegistry();
+    for (const bp of await loadBlueprintModules()) {
+        reg.register(finalizeBlueprint(bp));
+    }
+    registryCache = reg;
+    return reg;
+}
+/** For tests: bypass blueprint loading with explicit blueprints. */
+export function _seedRegistry(blueprints) {
+    seededBlueprints = blueprints;
+    registryCache = null;
+}
+export function _resetRegistry() {
+    registryCache = null;
+    seededBlueprints = null;
+}

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

@@ -0,0 +1,8 @@
+import type { VulseDb } from '../db.js';
+import { type BlueprintDefinition, type BlueprintDefinitionWithRenames } from './definition.js';
+export declare function createBlueprint(db: VulseDb, input: BlueprintDefinition): Promise<BlueprintDefinition>;
+export declare function updateBlueprint(db: VulseDb, handle: string, input: BlueprintDefinitionWithRenames): Promise<BlueprintDefinition>;
+export declare function deleteBlueprint(db: VulseDb, handle: string): Promise<void>;
+export declare function listBlueprintDefinitions(db: VulseDb): Promise<BlueprintDefinition[]>;
+export declare function getBlueprintDefinition(db: VulseDb, handle: string): Promise<BlueprintDefinition | null>;
+//# sourceMappingURL=mutations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/mutations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAIvC,OAAO,EACL,KAAK,mBAAmB,EAExB,KAAK,8BAA8B,EAKpC,MAAM,iBAAiB,CAAA;AAExB,wBAAsB,eAAe,CACnC,EAAE,EAAE,OAAO,EACX,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAe9B;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,OAAO,EACX,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,8BAA8B,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAyD9B;AAED,wBAAsB,eAAe,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhF;AAED,wBAAsB,wBAAwB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAK1F;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAO7G"}

package/dist/core/blueprints/mutations.js

@@ -0,0 +1,191 @@
+import { asc, eq, sql } from 'drizzle-orm';
+import { vulseCollections } from '../schema.js';
+import { NotFoundError, ValidationError } from '../errors.js';
+import { hashDefinition } from './compile.js';
+import { BlueprintDefinitionSchema, BlueprintDefinitionWithRenamesSchema, } from './definition.js';
+export async function createBlueprint(db, input) {
+    const def = await validateNew(db, input);
+    const now = Date.now();
+    await db.insert(vulseCollections).values({
+        handle: def.handle,
+        label: def.label,
+        definition: def,
+        blueprintHash: hashDefinition(def),
+        singleton: def.singleton,
+        tree: def.tree === true,
+        drafts: def.drafts === true,
+        createdAt: new Date(now),
+        updatedAt: new Date(now),
+    });
+    return def;
+}
+export async function updateBlueprint(db, handle, input) {
+    const existing = await loadDefinition(db, handle);
+    if (!existing)
+        throw new NotFoundError(`blueprint not found: ${handle}`);
+    const incoming = { ...input, handle };
+    const parsed = parseOrThrow(BlueprintDefinitionWithRenamesSchema, incoming);
+    const oldNames = new Set(existing.fields.map((f) => f.name));
+    for (const f of parsed.fields) {
+        if (f.previousName !== undefined && !oldNames.has(f.previousName)) {
+            throw new ValidationError(`previousName '${f.previousName}' was not in the prior definition`, {
+                issues: [{ path: ['fields', parsed.fields.indexOf(f), 'previousName'] }],
+            });
+        }
+    }
+    await ensureValidCrossField(db, parsed, handle);
+    const renames = computeRenames(parsed.fields);
+    const canonical = stripRenames(parsed);
+    for (const [oldName, newName] of renames) {
+        // Per-locale content lives in `vulse_entry_locales`. Rename keys in both
+        // the live `content` and the in-flight `draft_content` when present.
+        await db.run(sql `
+      UPDATE vulse_entry_locales
+      SET content = json_set(
+        json_remove(content, '$.' || ${oldName}),
+        '$.' || ${newName},
+        json_extract(content, '$.' || ${oldName})
+      )
+      WHERE collection = ${handle}
+        AND json_extract(content, '$.' || ${oldName}) IS NOT NULL
+    `);
+        await db.run(sql `
+      UPDATE vulse_entry_locales
+      SET draft_content = json_set(
+        json_remove(draft_content, '$.' || ${oldName}),
+        '$.' || ${newName},
+        json_extract(draft_content, '$.' || ${oldName})
+      )
+      WHERE collection = ${handle}
+        AND draft_content IS NOT NULL
+        AND json_extract(draft_content, '$.' || ${oldName}) IS NOT NULL
+    `);
+    }
+    await db.update(vulseCollections).set({
+        label: canonical.label,
+        definition: canonical,
+        blueprintHash: hashDefinition(canonical),
+        singleton: canonical.singleton,
+        tree: canonical.tree === true,
+        drafts: canonical.drafts === true,
+        updatedAt: new Date(),
+    }).where(eq(vulseCollections.handle, handle));
+    return canonical;
+}
+export async function deleteBlueprint(db, handle) {
+    const existing = await db.select({ handle: vulseCollections.handle })
+        .from(vulseCollections)
+        .where(eq(vulseCollections.handle, handle))
+        .get();
+    if (!existing)
+        throw new NotFoundError(`blueprint not found: ${handle}`);
+    await db.delete(vulseCollections).where(eq(vulseCollections.handle, handle));
+}
+export async function listBlueprintDefinitions(db) {
+    const rows = await db.select({ definition: vulseCollections.definition })
+        .from(vulseCollections)
+        .orderBy(asc(vulseCollections.createdAt));
+    return rows.map((r) => BlueprintDefinitionSchema.parse(r.definition));
+}
+export async function getBlueprintDefinition(db, handle) {
+    const row = await db.select({ definition: vulseCollections.definition })
+        .from(vulseCollections)
+        .where(eq(vulseCollections.handle, handle))
+        .get();
+    if (!row)
+        return null;
+    return BlueprintDefinitionSchema.parse(row.definition);
+}
+async function validateNew(db, input) {
+    const def = parseOrThrow(BlueprintDefinitionSchema, input);
+    const dup = await db.select({ handle: vulseCollections.handle })
+        .from(vulseCollections)
+        .where(eq(vulseCollections.handle, def.handle))
+        .get();
+    if (dup) {
+        throw new ValidationError(`handle '${def.handle}' already exists`, { issues: [{ path: ['handle'] }] });
+    }
+    await ensureValidCrossField(db, def, null);
+    return def;
+}
+async function ensureValidCrossField(db, def, selfHandle) {
+    await ensureValidFieldList(db, def.fields, ['fields'], selfHandle ?? def.handle);
+}
+async function ensureValidFieldList(db, fields, path, currentHandle) {
+    const seen = new Set();
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (seen.has(f.name)) {
+            throw new ValidationError(`duplicate field name '${f.name}'`, { issues: [{ path: [...path, i, 'name'] }] });
+        }
+        seen.add(f.name);
+    }
+    for (let i = 0; i < fields.length; i++) {
+        const f = fields[i];
+        if (f.ui.kind === 'relationship' && 'to' in f.ui) {
+            if (f.ui.to === currentHandle)
+                continue;
+            const target = await db.select({ handle: vulseCollections.handle })
+                .from(vulseCollections)
+                .where(eq(vulseCollections.handle, f.ui.to))
+                .get();
+            if (!target) {
+                throw new ValidationError(`relationship target '${f.ui.to}' does not exist`, {
+                    issues: [{ path: [...path, i, 'ui', 'to'] }],
+                });
+            }
+        }
+        if (f.ui.kind === 'replicator' && 'sets' in f.ui) {
+            const seenSets = new Set();
+            for (let j = 0; j < f.ui.sets.length; j++) {
+                const set = f.ui.sets[j];
+                if (seenSets.has(set.name)) {
+                    throw new ValidationError(`duplicate set name '${set.name}'`, {
+                        issues: [{ path: [...path, i, 'ui', 'sets', j, 'name'] }],
+                    });
+                }
+                seenSets.add(set.name);
+                await ensureValidFieldList(db, set.fields, [...path, i, 'ui', 'sets', j, 'fields'], currentHandle);
+            }
+        }
+    }
+}
+function computeRenames(fields) {
+    const out = [];
+    for (const f of fields) {
+        if (f.previousName !== undefined && f.previousName !== f.name) {
+            out.push([f.previousName, f.name]);
+        }
+    }
+    return out;
+}
+function stripRenames(def) {
+    return {
+        handle: def.handle,
+        label: def.label,
+        singleton: def.singleton,
+        ...(def.tree !== undefined ? { tree: def.tree } : {}),
+        ...(def.maxDepth !== undefined ? { maxDepth: def.maxDepth } : {}),
+        ...(def.drafts !== undefined ? { drafts: def.drafts } : {}),
+        ...(def.seo !== undefined ? { seo: def.seo } : {}),
+        ...(def.seoMapping !== undefined ? { seoMapping: def.seoMapping } : {}),
+        ...(def.preview !== undefined ? { preview: def.preview } : {}),
+        fields: def.fields.map(({ previousName: _previousName, ...rest }) => rest),
+    };
+}
+async function loadDefinition(db, handle) {
+    const row = await db.select({ definition: vulseCollections.definition })
+        .from(vulseCollections)
+        .where(eq(vulseCollections.handle, handle))
+        .get();
+    if (!row)
+        return null;
+    return BlueprintDefinitionSchema.parse(row.definition);
+}
+function parseOrThrow(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new ValidationError('Validation failed', { issues: result.error.issues });
+    }
+    return result.data;
+}

package/dist/core/blueprints/preview-path.d.ts

@@ -0,0 +1,15 @@
+import type { PreviewDefinition } from './definition.js';
+import type { PreviewConfig } from './types.js';
+/** Normalize preview config for Blueprint types (`exactOptionalPropertyTypes`). */
+export declare function toPreviewConfig(preview: PreviewDefinition | PreviewConfig): PreviewConfig;
+/** Default public URL template for a collection's entry pages. */
+export declare function defaultPreviewPath(collectionHandle: string): string;
+export declare function resolvePreviewPath(bp: {
+    name: string;
+    preview?: PreviewConfig | null;
+}): string;
+export declare function resolvePreviewConfig(bp: {
+    name: string;
+    preview?: PreviewConfig | null;
+}): PreviewConfig;
+//# sourceMappingURL=preview-path.d.ts.map

package/dist/core/blueprints/preview-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-path.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/preview-path.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,aAAa,GAAG,aAAa,CAMzF;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;CAAE,GAAG,MAAM,CAE/F;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;CAC/B,GAAG,aAAa,CAOhB"}

package/dist/core/blueprints/preview-path.js

@@ -0,0 +1,25 @@
+/** Normalize preview config for Blueprint types (`exactOptionalPropertyTypes`). */
+export function toPreviewConfig(preview) {
+    return {
+        path: preview.path,
+        ...(preview.rootSelector !== undefined ? { rootSelector: preview.rootSelector } : {}),
+        ...(preview.live !== undefined ? { live: preview.live } : {}),
+    };
+}
+/** Default public URL template for a collection's entry pages. */
+export function defaultPreviewPath(collectionHandle) {
+    if (!collectionHandle || collectionHandle === 'page')
+        return '/{slug}';
+    return `/${collectionHandle}/{slug}`;
+}
+export function resolvePreviewPath(bp) {
+    return bp.preview?.path ?? defaultPreviewPath(bp.name);
+}
+export function resolvePreviewConfig(bp) {
+    const path = resolvePreviewPath(bp);
+    return {
+        path,
+        ...(bp.preview?.rootSelector ? { rootSelector: bp.preview.rootSelector } : {}),
+        ...(bp.preview?.live === false ? { live: false } : {}),
+    };
+}

package/dist/core/blueprints/reflect-fields.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'astro/zod';
+import type { Blueprint } from './types.js';
+import type { FieldDefinition, ReplicatorSetDefinition } from './definition.js';
+export type Widget = 'text' | 'textarea' | 'number' | 'bool' | 'date' | 'enum' | 'ref' | 'entry' | 'entries' | 'link' | 'media' | 'blocks' | 'object' | 'repeater' | 'grid' | 'replicator';
+export interface FieldDescriptor {
+    path: string;
+    widget: Widget;
+    required: boolean;
+    description?: string;
+    blocksSets?: string[];
+    replicatorSets?: ReplicatorSetDefinition[];
+    label?: string;
+    options?: string[];
+    selectOptions?: {
+        key: string;
+        label: string;
+    }[];
+    selectMultiple?: boolean;
+    selectPlaceholder?: string;
+    selectClearable?: boolean;
+    refTarget?: string;
+    entryCollections?: string[];
+    entriesCollections?: string[];
+    entriesMax?: number;
+    linkCollections?: string[];
+    gridMinRows?: number;
+    gridMaxRows?: number;
+    gridMode?: 'table' | 'stacked';
+    gridAddLabel?: string;
+    children?: FieldDescriptor[];
+    itemFields?: FieldDescriptor[];
+}
+export declare function reflectFields(schema: z.ZodObject<any>): FieldDescriptor[];
+export declare function fieldDescriptorsFromDefinitions(fields: FieldDefinition[]): FieldDescriptor[];
+export declare function fieldDescriptorsFromBlueprint(bp: Blueprint): FieldDescriptor[];
+//# sourceMappingURL=reflect-fields.d.ts.map

package/dist/core/blueprints/reflect-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflect-fields.d.ts","sourceRoot":"","sources":["../../../src/core/blueprints/reflect-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAmB,MAAM,WAAW,CAAA;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EACV,eAAe,EAGf,uBAAuB,EAExB,MAAM,iBAAiB,CAAA;AAIxB,MAAM,MAAM,MAAM,GACd,MAAM,GACN,UAAU,GACV,QAAQ,GACR,MAAM,GACN,MAAM,GACN,MAAM,GACN,KAAK,GACL,OAAO,GACP,SAAS,GACT,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,MAAM,GACN,YAAY,CAAA;AAEhB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,cAAc,CAAC,EAAE,uBAAuB,EAAE,CAAA;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,aAAa,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAChD,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;IAC5B,UAAU,CAAC,EAAE,eAAe,EAAE,CAAA;CAC/B;AAgDD,wBAAgB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,eAAe,EAAE,CAGzE;AAmGD,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAE5F;AAED,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,SAAS,GAAG,eAAe,EAAE,CAK9E"}