@shoppexio/builder-contracts 0.1.0

package/dist/legacy-manifest.d.ts

@@ -0,0 +1,172 @@
+import * as z from 'zod/v4';
+import { type ThemeManifest } from './theme-manifest.ts';
+export declare const LegacyBuilderFieldSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+    placeholder: z.ZodOptional<z.ZodString>;
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$loose>>>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type LegacyBuilderField = z.infer<typeof LegacyBuilderFieldSchema>;
+export declare const LegacyBuilderListSchema: z.ZodObject<{
+    path: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type LegacyBuilderList = z.infer<typeof LegacyBuilderListSchema>;
+export declare const LegacyBuilderBlockSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+    maxInstances: z.ZodOptional<z.ZodNumber>;
+    mountable: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        placeholder: z.ZodOptional<z.ZodString>;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$loose>>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        step: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type LegacyBuilderBlock = z.infer<typeof LegacyBuilderBlockSchema>;
+export declare const LegacyBuilderPageSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    previewPath: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
+        label: z.ZodString;
+        placeholder: z.ZodOptional<z.ZodString>;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$loose>>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        step: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type LegacyBuilderPage = z.infer<typeof LegacyBuilderPageSchema>;
+declare const LegacyThemePresetSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    overrides: z.ZodOptional<z.ZodObject<{
+        content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        style_slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        styleSlots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type LegacyThemePreset = z.infer<typeof LegacyThemePresetSchema>;
+export declare const LegacyThemeManifestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    presets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        overrides: z.ZodOptional<z.ZodObject<{
+            content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            layout: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            style_slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            styleSlots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    builder: z.ZodObject<{
+        pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            previewPath: z.ZodOptional<z.ZodString>;
+            blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodOptional<z.ZodString>;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                defaultValue: z.ZodOptional<z.ZodUnknown>;
+                description: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodString;
+                }, z.core.$loose>>>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                step: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>>;
+            lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>;
+        blocks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            label: z.ZodString;
+            maxInstances: z.ZodOptional<z.ZodNumber>;
+            mountable: z.ZodOptional<z.ZodBoolean>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                type: z.ZodOptional<z.ZodString>;
+                label: z.ZodString;
+                placeholder: z.ZodOptional<z.ZodString>;
+                defaultValue: z.ZodOptional<z.ZodUnknown>;
+                description: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodString;
+                }, z.core.$loose>>>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                step: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>>;
+            lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>>;
+        presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type LegacyThemeManifest = z.infer<typeof LegacyThemeManifestSchema>;
+export declare function convertLegacyThemeManifest(input: unknown): ThemeManifest;
+export {};
+//# sourceMappingURL=legacy-manifest.d.ts.map

package/dist/legacy-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-manifest.d.ts","sourceRoot":"","sources":["../src/legacy-manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAS9E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAarB,CAAC;AACjB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB;;;;;iBAOpB,CAAC;AACjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;iBASrB,CAAC;AACjB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpB,CAAC;AACjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,QAAA,MAAM,uBAAuB;;;;;;;;;;;iBAgBb,CAAC;AACjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBActB,CAAC;AACjB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAkExE"}

package/dist/legacy-manifest.js

@@ -0,0 +1,272 @@
+import * as z from 'zod/v4';
+import { BuilderFieldSchema } from "./fields.js";
+import { ThemeManifestSchema } from "./theme-manifest.js";
+const LegacyFieldOptionSchema = z
+    .object({
+    label: z.string().min(1),
+    value: z.string().min(1),
+})
+    .passthrough();
+export const LegacyBuilderFieldSchema = z
+    .object({
+    path: z.string().min(1),
+    type: z.string().min(1).optional(),
+    label: z.string().min(1),
+    placeholder: z.string().optional(),
+    defaultValue: z.unknown().optional(),
+    description: z.string().optional(),
+    options: z.array(LegacyFieldOptionSchema).optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    step: z.number().positive().optional(),
+})
+    .passthrough();
+export const LegacyBuilderListSchema = z
+    .object({
+    path: z.string().min(1),
+    label: z.string().min(1),
+    kind: z.string().min(1),
+    description: z.string().optional(),
+})
+    .passthrough();
+export const LegacyBuilderBlockSchema = z
+    .object({
+    id: z.string().min(1).optional(),
+    label: z.string().min(1),
+    maxInstances: z.number().int().positive().optional(),
+    mountable: z.boolean().optional(),
+    fields: z.array(LegacyBuilderFieldSchema).optional(),
+    lists: z.array(LegacyBuilderListSchema).optional(),
+})
+    .passthrough();
+export const LegacyBuilderPageSchema = z
+    .object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    previewPath: z.string().min(1).optional(),
+    blocks: z.array(z.string().min(1)).default([]),
+    fields: z.array(LegacyBuilderFieldSchema).optional(),
+    lists: z.array(LegacyBuilderListSchema).optional(),
+})
+    .passthrough();
+const LegacyThemePresetSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1).optional(),
+    label: z.string().min(1).optional(),
+    description: z.string().optional(),
+    overrides: z
+        .object({
+        content: z.record(z.string().min(1), z.unknown()).optional(),
+        layout: z.record(z.string().min(1), z.unknown()).optional(),
+        style_slots: z.record(z.string().min(1), z.unknown()).optional(),
+        styleSlots: z.record(z.string().min(1), z.unknown()).optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+export const LegacyThemeManifestSchema = z
+    .object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    version: z.string().min(1),
+    presets: z.array(LegacyThemePresetSchema).optional(),
+    builder: z
+        .object({
+        pages: z.array(LegacyBuilderPageSchema).default([]),
+        blocks: z.record(z.string().min(1), LegacyBuilderBlockSchema).default({}),
+        presets: z.record(z.string().min(1), z.unknown()).optional(),
+    })
+        .passthrough(),
+})
+    .passthrough();
+export function convertLegacyThemeManifest(input) {
+    const legacy = LegacyThemeManifestSchema.parse(input);
+    const blocks = Object.fromEntries(Object.entries(legacy.builder.blocks).map(([blockType, block]) => [
+        blockType,
+        {
+            label: block.label,
+            maxInstances: block.maxInstances,
+            variants: [],
+            settings: convertLegacyFields(block.fields ?? [], block.lists ?? []),
+            exposedStyleSlots: [],
+            presets: [],
+        },
+    ]));
+    for (const page of legacy.builder.pages) {
+        const syntheticBlockType = createSyntheticPageBlockType(page.id);
+        if ((page.fields?.length ?? 0) === 0 && (page.lists?.length ?? 0) === 0) {
+            continue;
+        }
+        blocks[syntheticBlockType] = {
+            label: page.label,
+            maxInstances: 1,
+            variants: [],
+            settings: convertLegacyFields(page.fields ?? [], page.lists ?? []),
+            exposedStyleSlots: [],
+            presets: [],
+        };
+    }
+    const converted = {
+        id: normalizeLegacyThemeId(legacy.id),
+        name: legacy.name,
+        version: legacy.version,
+        pages: Object.fromEntries(legacy.builder.pages.map((page) => {
+            const syntheticBlockType = createSyntheticPageBlockType(page.id);
+            const hasSyntheticBlock = blocks[syntheticBlockType] !== undefined;
+            const allowedBlocks = page.blocks.length > 0
+                ? page.blocks
+                : (hasSyntheticBlock ? [syntheticBlockType] : []);
+            // Seed synthetic page-level blocks as defaults so pages that
+            // only surface page.fields/lists still open with an editable
+            // block instance instead of an empty editor.
+            const defaultBlocks = page.blocks.length > 0
+                ? page.blocks.map((type) => ({ type }))
+                : (hasSyntheticBlock ? [{ type: syntheticBlockType }] : []);
+            return [
+                page.id,
+                {
+                    label: page.label,
+                    previewPath: page.previewPath,
+                    allowedBlocks,
+                    defaultBlocks,
+                },
+            ];
+        })),
+        blocks,
+        styleSlots: {},
+        presets: convertLegacyThemePresets(legacy.presets ?? []),
+    };
+    return ThemeManifestSchema.parse(converted);
+}
+function normalizeLegacyThemeId(rawId) {
+    const lowered = rawId.toLowerCase().replace(/[^a-z0-9\-_.]+/g, '-').replace(/^[-_.]+/, '');
+    if (lowered.length > 0 && /^[a-z0-9]/.test(lowered)) {
+        return lowered;
+    }
+    return `legacy-${lowered || 'theme'}`;
+}
+function createSyntheticPageBlockType(pageId) {
+    const normalizedPageId = pageId.toLowerCase().replace(/[^a-z0-9\-_.]+/g, '-').replace(/^[-_.]+/, '');
+    return `page-${normalizedPageId || 'custom'}`;
+}
+function convertLegacyThemePresets(presets) {
+    return Object.fromEntries(presets.map((preset) => [
+        preset.id,
+        {
+            label: preset.name ?? preset.label ?? preset.id,
+            description: preset.description,
+            content: flattenContentRecord(preset.overrides?.content ?? {}),
+            layout: preset.overrides?.layout ?? {},
+            style_slots: preset.overrides?.style_slots ?? preset.overrides?.styleSlots ?? {},
+        },
+    ]));
+}
+function flattenContentRecord(content, prefix = '') {
+    const flattened = {};
+    for (const [key, value] of Object.entries(content)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject(value)) {
+            Object.assign(flattened, flattenContentRecord(value, path));
+        }
+        else {
+            flattened[path] = value;
+        }
+    }
+    return flattened;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function convertLegacyFields(fields, lists) {
+    const convertedFields = Object.fromEntries(fields.map((field) => [field.path, convertLegacyField(field)]));
+    const convertedLists = Object.fromEntries(lists.map((list) => [
+        list.path,
+        {
+            type: 'list',
+            label: list.label,
+            description: list.description,
+            itemShape: createListItemShape(list.kind),
+        },
+    ]));
+    return {
+        ...convertedFields,
+        ...convertedLists,
+    };
+}
+function convertLegacyField(field) {
+    const type = normalizeLegacyFieldType(field.type);
+    const base = {
+        label: field.label,
+        description: field.description,
+        defaultValue: field.defaultValue,
+    };
+    const candidate = type === 'select'
+        ? {
+            ...base,
+            type,
+            options: (field.options ?? []).map((option) => ({
+                label: option.label,
+                value: option.value,
+            })),
+        }
+        : type === 'range'
+            ? {
+                ...base,
+                type,
+                min: field.min ?? 0,
+                max: field.max ?? 100,
+                step: field.step,
+            }
+            : type === 'text'
+                ? {
+                    ...base,
+                    type,
+                    placeholder: field.placeholder,
+                }
+                : {
+                    ...base,
+                    type,
+                };
+    return BuilderFieldSchema.parse(candidate);
+}
+function normalizeLegacyFieldType(type) {
+    if (type === 'richtext' ||
+        type === 'image' ||
+        type === 'link' ||
+        type === 'boolean' ||
+        type === 'number' ||
+        type === 'range' ||
+        type === 'select' ||
+        type === 'color' ||
+        type === 'product' ||
+        type === 'products') {
+        return type;
+    }
+    return 'text';
+}
+function createListItemShape(kind) {
+    if (kind === 'faqItems') {
+        return {
+            question: { type: 'text', label: 'Question' },
+            answer: { type: 'richtext', label: 'Answer' },
+        };
+    }
+    if (kind === 'galleryItems') {
+        return {
+            image: { type: 'image', label: 'Image' },
+            alt: { type: 'text', label: 'Alt Text' },
+        };
+    }
+    if (kind === 'reviewItems') {
+        return {
+            quote: { type: 'richtext', label: 'Quote' },
+            author: { type: 'text', label: 'Author' },
+        };
+    }
+    return {
+        title: { type: 'text', label: 'Title' },
+        body: { type: 'richtext', label: 'Body' },
+    };
+}

package/dist/migrations.d.ts

@@ -0,0 +1,31 @@
+import { type BlockInstance, type BuilderSettings, type PageLayout } from './builder-settings.ts';
+import type { StyleSlots } from './style-slots.ts';
+import type { ThemeManifest } from './theme-manifest.ts';
+export type LegacyBuilderSettingsInput = {
+    theme?: {
+        content?: Record<string, unknown>;
+        layout?: Record<string, unknown>;
+        tokens_override?: Record<string, unknown>;
+        style_slots?: Record<string, unknown>;
+    };
+};
+export type LegacyRedisOverride = {
+    target?: string;
+    property?: string;
+    value?: unknown;
+    className?: string;
+};
+export declare function createEmptyBuilderSettings(revision?: number): BuilderSettings;
+export declare function createBlockInstance(input: {
+    id: string;
+    type: string;
+    variant?: string;
+    visible?: boolean;
+    settings?: Record<string, unknown>;
+    style_overrides?: StyleSlots;
+}): BlockInstance;
+export declare function createPageLayoutFromBlocks(blocks: BlockInstance[]): PageLayout;
+export declare function migrateLegacyBuilderSettings(input: LegacyBuilderSettingsInput, revision?: number): BuilderSettings;
+export declare function applyManifestDefaultLayout(settings: BuilderSettings, manifest: ThemeManifest): BuilderSettings;
+export declare function mapLegacyTokenOverridesToStyleSlots(tokens: Record<string, unknown>): StyleSlots;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../src/migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EAEpB,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,QAAQ,SAAI,GAAG,eAAe,CAYxE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,UAAU,CAAC;CAC9B,GAAG,aAAa,CAShB;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,UAAU,CAE9E;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,0BAA0B,EAAE,QAAQ,SAAI,GAAG,eAAe,CAkB7G;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,eAAe,EAAE,QAAQ,EAAE,aAAa,GAAG,eAAe,CAwB9G;AAED,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,CAa/F"}

package/dist/migrations.js

@@ -0,0 +1,175 @@
+import { BUILDER_SETTINGS_VERSION, BuilderSettingsSchema, } from "./builder-settings.js";
+export function createEmptyBuilderSettings(revision = 0) {
+    return {
+        version: BUILDER_SETTINGS_VERSION,
+        revision,
+        theme: {
+            content: {},
+            layout: {},
+            style_slots: {},
+            pages: [],
+            terms: {},
+        },
+    };
+}
+export function createBlockInstance(input) {
+    return {
+        id: input.id,
+        type: input.type,
+        variant: input.variant,
+        visible: input.visible ?? true,
+        settings: input.settings ?? {},
+        style_overrides: input.style_overrides,
+    };
+}
+export function createPageLayoutFromBlocks(blocks) {
+    return { blocks };
+}
+export function migrateLegacyBuilderSettings(input, revision = 0) {
+    const tokensOverride = input.theme?.tokens_override ?? {};
+    const styleSlots = {
+        ...mapLegacyTokenOverridesToStyleSlots(tokensOverride),
+        ...(input.theme?.style_slots ?? {}),
+    };
+    return BuilderSettingsSchema.parse({
+        version: BUILDER_SETTINGS_VERSION,
+        revision,
+        theme: {
+            content: input.theme?.content ?? {},
+            layout: normalizeLegacyLayout(input.theme?.layout ?? {}),
+            style_slots: styleSlots,
+            pages: [],
+            terms: {},
+        },
+    });
+}
+export function applyManifestDefaultLayout(settings, manifest) {
+    const next = cloneBuilderSettings(settings);
+    for (const [pageId, page] of Object.entries(manifest.pages)) {
+        // Only seed defaults when the page has never been initialized
+        // (no layout entry at all). An explicit empty layout means the
+        // merchant intentionally removed all sections and must be
+        // preserved across reloads.
+        const hasPageLayoutEntry = Object.prototype.hasOwnProperty.call(next.theme.layout, pageId);
+        if (hasPageLayoutEntry || page.defaultBlocks.length === 0) {
+            continue;
+        }
+        next.theme.layout[pageId] = {
+            blocks: page.defaultBlocks.map((block, index) => createBlockInstance({
+                id: createDefaultBlockId(pageId, block.type, index),
+                type: block.type,
+                variant: block.variant,
+                settings: block.settings ?? {},
+            })),
+        };
+    }
+    return BuilderSettingsSchema.parse(next);
+}
+export function mapLegacyTokenOverridesToStyleSlots(tokens) {
+    const slots = {};
+    assignResponsiveNumber(tokens, slots, 'buttons.borderRadius', 'button.radius');
+    assignResponsiveNumber(tokens, slots, 'inputs.borderRadius', 'input.radius');
+    assignResponsiveNumber(tokens, slots, 'inputs.height', 'input.height');
+    assignColor(tokens, slots, 'colors.primary', 'color.primary');
+    assignColor(tokens, slots, 'colors.accent', 'color.accent');
+    assignColor(tokens, slots, 'colors.background', 'color.background');
+    assignColor(tokens, slots, 'colors.foreground', 'color.foreground');
+    assignColor(tokens, slots, 'colors.muted', 'color.muted');
+    return slots;
+}
+function normalizeLegacyLayout(layout) {
+    const normalized = {};
+    for (const [pageId, value] of Object.entries(layout)) {
+        if (isPageLayout(value)) {
+            normalized[pageId] = value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            normalized[pageId] = {
+                blocks: value.filter(isBlockInstance),
+            };
+            continue;
+        }
+        // Pre-v2 editor shape: { sections: [...] } with entries that
+        // commonly only carry { id, visible } (no type field). Use id as
+        // the type fallback so merchant layout/visibility survives the
+        // migration instead of being dropped by the stricter
+        // isBlockInstance check.
+        if (value && typeof value === 'object') {
+            const record = value;
+            const sections = Array.isArray(record.sections) ? record.sections : null;
+            if (sections) {
+                normalized[pageId] = {
+                    blocks: sections.flatMap(normalizeLegacySection),
+                };
+            }
+        }
+    }
+    return normalized;
+}
+function normalizeLegacySection(entry) {
+    if (!entry || typeof entry !== 'object')
+        return [];
+    const record = entry;
+    const rawType = typeof record.type === 'string' ? record.type.trim() : '';
+    const rawId = typeof record.id === 'string' ? record.id.trim() : '';
+    const type = rawType || rawId;
+    if (!type)
+        return [];
+    return [{
+            id: rawId || type,
+            type,
+            variant: typeof record.variant === 'string' ? record.variant : undefined,
+            visible: typeof record.visible === 'boolean' ? record.visible : true,
+            settings: isRecord(record.settings) ? record.settings : {},
+        }];
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assignResponsiveNumber(tokens, slots, tokenPath, slotId) {
+    const value = tokens[tokenPath];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        slots[slotId] = { base: value };
+        return;
+    }
+    if (isResponsiveNumber(value)) {
+        slots[slotId] = value;
+    }
+}
+function assignColor(tokens, slots, tokenPath, slotId) {
+    const value = tokens[tokenPath];
+    if (typeof value === 'string') {
+        slots[slotId] = value;
+    }
+}
+function isResponsiveNumber(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.base === 'number' && Number.isFinite(candidate.base);
+}
+function isBlockInstance(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === 'string' && typeof candidate.type === 'string';
+}
+function isPageLayout(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return Array.isArray(candidate.blocks) && candidate.blocks.every(isBlockInstance);
+}
+function cloneBuilderSettings(settings) {
+    if (typeof structuredClone === 'function') {
+        return structuredClone(settings);
+    }
+    return JSON.parse(JSON.stringify(settings));
+}
+function createDefaultBlockId(pageId, blockType, index) {
+    return `${pageId}-${blockType}-${index + 1}`;
+}