@builder-builder/builder 0.0.8 → 0.0.10

package/dist/mappers/index.js

@@ -1,4 +1,5 @@
 export { createInstance } from './instance/index.js';
 export { createModels } from './models/index.js';
 export { order } from './order/index.js';
+export { refs } from './refs.js';
 export { ordinal, render } from './render/index.js';

package/dist/mappers/refs.d.ts

@@ -0,0 +1,12 @@
+import type { BuilderEntityKind, BuilderUISerialised } from '../entities/index';
+import * as v from 'valibot';
+import { entitiesByKind } from '../entities/index.js';
+export type BuilderRefEntity = {
+    readonly [Kind in BuilderEntityKind]: {
+        readonly kind: Kind;
+        readonly id: string;
+        readonly data: v.InferOutput<(typeof entitiesByKind)[Kind]['serialised']>;
+    };
+}[BuilderEntityKind];
+export type BuilderRefEntities = ReadonlyArray<BuilderRefEntity>;
+export declare function refs(ui: BuilderUISerialised, entities: BuilderRefEntities): BuilderUISerialised;

package/dist/mappers/refs.js

@@ -0,0 +1,36 @@
+import * as v from 'valibot';
+import { BuilderSchema, BuilderUISchema, deserialise, entitiesByKind, serialise } from '../entities/index.js';
+import { walk } from '../walker/walker.js';
+export function refs(ui, entities) {
+    const entityMap = new Map();
+    entities.forEach((entity) => {
+        const instance = deserialise[entity.kind](entity.data);
+        entityMap.set(entity.id, isBindable(instance) ? bind(instance, entitiesByKind[entity.kind].serialised) : instance);
+    });
+    const root = bind(deserialise.ui(ui), entitiesByKind.ui.serialised);
+    return serialise.ui(root);
+    function bind(instance, schema) {
+        const references = collectReferences(instance, schema);
+        if (references.length === 0) {
+            return instance;
+        }
+        const bindings = Object.fromEntries(references.map((reference) => [reference.parameter, entityMap.get(reference.id)]));
+        return instance.bind(bindings);
+    }
+}
+function isBindable(entity) {
+    return v.is(BuilderSchema, entity) || v.is(BuilderUISchema, entity);
+}
+function collectReferences(instance, schema) {
+    const references = [];
+    walk(schema, instance, {
+        walkEntity: ({ record }) => {
+            const maybeReferences = record.references;
+            if (Array.isArray(maybeReferences)) {
+                references.push(...maybeReferences);
+            }
+            return record;
+        }
+    });
+    return references;
+}

package/dist/mappers/render/render.js

@@ -15,9 +15,9 @@ export function render(ui, rootModel) {
     function walk(builder, model, collectionPath, labelContext, items) {
         function composeLabel(label) {
             if (labelContext.length === 0) {
-                return label.label;
+                return label;
             }
-            return `${labelContext.join(', ')}, ${label.label}`;
+            return `${labelContext.join(', ')}, ${label}`;
         }
         items.forEach((item) => {
             if (item.type === 'pages') {
@@ -27,7 +27,7 @@ export function render(ui, rootModel) {
                 }
                 const models = model[collection.name];
                 models.forEach((collectionModel, itemIndex) => {
-                    const labelSegment = `${ordinal(itemIndex)} ${item.label.label}`;
+                    const labelSegment = `${ordinal(itemIndex)} ${item.label}`;
                     walk(collection.payload.builder, collectionModel, [...collectionPath, item.name, itemIndex], [...labelContext, labelSegment], item.items);
                 });
                 return;

package/dist/model.d.ts

@@ -1,14 +1,35 @@
-import type { BuilderPrimitive } from './primitive';
+import * as v from 'valibot';
+import { type BuilderPrimitive } from './primitive.js';
 export type BuilderModel = {
     readonly [key: string]: BuilderPrimitive | BuilderModels;
 };
-export type BuilderModels = ReadonlyArray<BuilderModel>;
+export declare const BuilderModelSchema: v.GenericSchema<BuilderModel>;
+export declare const BuilderModelsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderModel>, undefined>, v.ReadonlyAction<BuilderModel[]>]>;
+export type BuilderModels = v.InferOutput<typeof BuilderModelsSchema>;
 export type BuilderModelInput = Readonly<Record<string, unknown>>;
-export type BuilderVariant = Readonly<{
+export declare const BuilderVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly model: v.GenericSchema<BuilderModel>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
     model: BuilderModel;
-    price?: string;
-    image?: string;
-    details?: Readonly<Record<string, string>>;
-}>;
-export type BuilderVariants = ReadonlyArray<BuilderVariant>;
+    details?: {
+        [x: string]: string;
+    } | undefined;
+}>]>;
+export type BuilderVariant = v.InferOutput<typeof BuilderVariantSchema>;
+export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly model: v.GenericSchema<BuilderModel>;
+    readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    model: BuilderModel;
+    details?: {
+        [x: string]: string;
+    } | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    model: BuilderModel;
+    details?: {
+        [x: string]: string;
+    } | undefined;
+}>[]>]>;
+export type BuilderVariants = v.InferOutput<typeof BuilderVariantsSchema>;
 export type BuilderData = Readonly<Record<string, BuilderVariants>>;

package/dist/model.js

@@ -1 +1,9 @@
-export {};
+import * as v from 'valibot';
+import { BuilderPrimitiveSchema } from './primitive.js';
+export const BuilderModelSchema = v.pipe(v.record(v.string(), v.union([BuilderPrimitiveSchema, v.lazy(() => BuilderModelsSchema)])), v.readonly());
+export const BuilderModelsSchema = v.pipe(v.array(BuilderModelSchema), v.readonly());
+export const BuilderVariantSchema = v.pipe(v.object({
+    model: BuilderModelSchema,
+    details: v.optional(v.record(v.string(), v.string()))
+}), v.readonly());
+export const BuilderVariantsSchema = v.pipe(v.array(BuilderVariantSchema), v.readonly());

package/dist/references.d.ts

@@ -1,60 +1,86 @@
 import * as v from 'valibot';
-export type Refable<Value> = Value | BuilderRef;
-export type RefableSerialised<Value> = Value | BuilderRefSerialised;
-export type RefableMetadata = {
-    readonly refable?: v.GenericSchema;
+export type Paramable<Value> = Value | BuilderParameter;
+export type ParamableSerialised<Value> = Value | BuilderParameterSerialised;
+export type ParamableMetadata = {
+    readonly paramable?: v.GenericSchema;
 };
-export declare class BuilderRef {
+export declare class BuilderParameter<const Name extends string = string> {
     readonly id: string;
-    readonly name: string;
-    constructor(name: string, id?: string);
+    readonly name: Name;
+    constructor(name: Name, id?: string);
 }
-export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
-export declare const BuilderRefsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderRef, undefined>, undefined>, v.ReadonlyAction<BuilderRef[]>]>;
-export type BuilderRefs = v.InferOutput<typeof BuilderRefsSchema>;
-export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
+export declare const BuilderParametersSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderParameter, undefined>, undefined>, v.ReadonlyAction<BuilderParameter<string>[]>]>;
+export type BuilderParameters = v.InferOutput<typeof BuilderParametersSchema>;
+export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
 }>]>;
-export type BuilderRefSerialised = v.InferOutput<typeof BuilderRefSerialisedSchema>;
-export declare const BuilderRefsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+export type BuilderParameterSerialised = v.InferOutput<typeof BuilderParameterSerialisedSchema>;
+export declare const BuilderParametersSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
 }>[]>]>;
-export type BuilderRefsSerialised = v.InferOutput<typeof BuilderRefsSerialisedSchema>;
+export type BuilderParametersSerialised = v.InferOutput<typeof BuilderParametersSerialisedSchema>;
+export declare class BuilderRef {
+    readonly id: string;
+    constructor(id: string);
+}
+export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
+export declare const BuilderReferenceSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly parameter: v.StringSchema<undefined>;
+    readonly id: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    parameter: string;
+    id: string;
+}>]>;
+export type BuilderReference = v.InferOutput<typeof BuilderReferenceSchema>;
+export declare const BuilderReferencesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly parameter: v.StringSchema<undefined>;
+    readonly id: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    parameter: string;
+    id: string;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    parameter: string;
+    id: string;
+}>[]>]>;
+export type BuilderReferences = v.InferOutput<typeof BuilderReferencesSchema>;
+export declare function isParameter(value: unknown): value is BuilderParameter;
+export declare function isSerialisedParameter(value: unknown): value is BuilderParameterSerialised;
 export declare function isRef(value: unknown): value is BuilderRef;
-export declare function isSerialisedRef(value: unknown): value is BuilderRefSerialised;
-export declare function parameter(name: string): BuilderRef;
-export declare function refable<Schema extends v.GenericSchema>(refable: Schema): v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+export declare function parameter<const Name extends string>(name: Name): BuilderParameter<Name>;
+export declare function ref(id: string): BuilderRef;
+export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
-}>]>, v.InstanceSchema<typeof BuilderRef, undefined>, Schema], undefined>, v.MetadataAction<v.InferOutput<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"ref", undefined>;
+}>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, Schema], undefined>, v.MetadataAction<v.InferOutput<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "ref";
+    type: "parameter";
     id: string;
     name: string;
-}>]> | v.InstanceSchema<typeof BuilderRef, undefined> | Schema>, {
-    readonly refable: Schema;
+}>]> | v.InstanceSchema<typeof BuilderParameter, undefined> | Schema>, {
+    readonly paramable: Schema;
 }>]>;

package/dist/references.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { check } from './check.js';
-export class BuilderRef {
+export class BuilderParameter {
     id;
     name;
     constructor(name, id = crypto.randomUUID()) {
@@ -8,19 +8,34 @@ export class BuilderRef {
         this.id = id;
     }
 }
+export const BuilderParameterSchema = v.instance(BuilderParameter);
+export const BuilderParametersSchema = v.pipe(v.array(BuilderParameterSchema), v.readonly());
+export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
+export const BuilderParametersSerialisedSchema = v.pipe(v.array(BuilderParameterSerialisedSchema), v.readonly());
+export class BuilderRef {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderRefsSchema = v.pipe(v.array(BuilderRefSchema), v.readonly());
-export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string(), name: v.string() }), v.readonly());
-export const BuilderRefsSerialisedSchema = v.pipe(v.array(BuilderRefSerialisedSchema), v.readonly());
+export const BuilderReferenceSchema = v.pipe(v.object({ parameter: v.string(), id: v.string() }), v.readonly());
+export const BuilderReferencesSchema = v.pipe(v.array(BuilderReferenceSchema), v.readonly());
+export function isParameter(value) {
+    return check.is(BuilderParameterSchema, value);
+}
+export function isSerialisedParameter(value) {
+    return check.is(BuilderParameterSerialisedSchema, value);
+}
 export function isRef(value) {
     return check.is(BuilderRefSchema, value);
 }
-export function isSerialisedRef(value) {
-    return check.is(BuilderRefSerialisedSchema, value);
-}
 export function parameter(name) {
-    return new BuilderRef(name);
+    return new BuilderParameter(name);
+}
+export function ref(id) {
+    return new BuilderRef(id);
 }
-export function refable(refable) {
-    return v.pipe(v.union([BuilderRefSerialisedSchema, BuilderRefSchema, refable]), v.metadata({ refable }));
+export function paramable(paramable) {
+    return v.pipe(v.union([BuilderParameterSerialisedSchema, BuilderParameterSchema, paramable]), v.metadata({ paramable }));
 }

package/dist/walker/walker.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderRef, BuilderRefSerialised } from '../references';
+import type { BuilderParameter, BuilderParameterSerialised } from '../references';
 import type { SerialisableClass } from '../serialisable';
 import * as v from 'valibot';
 export type Walker = (schema: v.GenericSchema, data: unknown) => unknown;
@@ -9,10 +9,18 @@ export type WalkerField = {
     } | null;
 };
 export type WalkerFields = ReadonlyArray<WalkerField>;
+export type WalkerObjectArgs = {
+    readonly fields: WalkerFields;
+    readonly walked: Record<string, unknown>;
+    readonly record: Record<string, unknown>;
+};
+export type WalkerEntityArgs = WalkerObjectArgs & {
+    readonly serialisable: SerialisableClass;
+};
 export type WalkerConfig = {
-    readonly onRef?: (ref: BuilderRef) => unknown;
-    readonly onSerialisedRef?: (data: BuilderRefSerialised) => unknown;
-    readonly walkObject?: (fields: WalkerFields, walked: Record<string, unknown>, record: Record<string, unknown>) => unknown;
-    readonly walkEntity?: (serialisable: SerialisableClass, fields: WalkerFields, walked: Record<string, unknown>, record: Record<string, unknown>) => unknown;
+    readonly onParameter?: (parameter: BuilderParameter, paramableSchema: v.GenericSchema) => unknown;
+    readonly onSerialisedParameter?: (data: BuilderParameterSerialised, paramableSchema: v.GenericSchema) => unknown;
+    readonly walkObject?: (args: WalkerObjectArgs) => unknown;
+    readonly walkEntity?: (args: WalkerEntityArgs) => unknown;
 };
 export declare function walk(schema: v.GenericSchema, value: unknown, config: WalkerConfig): unknown;

package/dist/walker/walker.js

@@ -1,10 +1,10 @@
 import * as v from 'valibot';
-import { isRef, isSerialisedRef } from '../references.js';
+import { isParameter, isSerialisedParameter } from '../references.js';
 import { isWalkable } from './walkable.js';
 export function walk(schema, value, config) {
     const meta = v.getMetadata(schema);
-    if (meta.refable != null) {
-        return walkRefable(meta.refable, value, config);
+    if (meta.paramable != null) {
+        return walkParamable(meta.paramable, value, config);
     }
     const inner = unwrapPipe(schema);
     if (!isWalkable(inner)) {
@@ -32,37 +32,49 @@ export function walk(schema, value, config) {
 function isLiteral(schema) {
     return schema.type === 'literal';
 }
-function walkRefable(inner, value, config) {
+function walkParamable(inner, value, config) {
     if (value == null) {
         return value;
     }
-    const resolved = isRef(value) && config.onRef
-        ? config.onRef(value)
-        : isSerialisedRef(value) && config.onSerialisedRef
-            ? config.onSerialisedRef(value)
+    const resolved = isParameter(value) && config.onParameter
+        ? config.onParameter(value, inner)
+        : isSerialisedParameter(value) && config.onSerialisedParameter
+            ? config.onSerialisedParameter(value, inner)
             : value;
-    if (isRef(resolved) || isSerialisedRef(resolved)) {
+    if (isParameter(resolved) || isSerialisedParameter(resolved)) {
         return resolved;
     }
     return walk(inner, resolved, config);
 }
 function walkArray(item, value, config) {
-    return value.flatMap((element) => {
-        const walked = walk(item, element, config);
-        if (!isAnyRef(element) || !Array.isArray(walked)) {
-            return [walked];
-        }
-        return walked.flatMap((nested) => {
-            const walkedNested = walk(item, nested, config);
-            if (isAnyRef(nested) && Array.isArray(walkedNested)) {
-                return walkedNested;
-            }
-            return [walkedNested];
-        });
-    });
+    const walked = value.flatMap((element) => walkArrayElement(item, element, config));
+    return walked.length === value.length &&
+        walked.every((element, index) => element === value[index])
+        ? value
+        : walked;
+}
+function walkArrayElement(item, element, config) {
+    const walked = walk(item, element, config);
+    if (!isAnyParameter(element) || !Array.isArray(walked)) {
+        return [walked];
+    }
+    return walked.flatMap((nested) => walkArrayElement(item, nested, config));
 }
 function walkRecord(valueSchema, record, config) {
-    return Object.fromEntries(Object.entries(record).map(([key, entry]) => entry === null ? [key, null] : [key, walk(valueSchema, entry, config)]));
+    let changed = false;
+    const walked = {};
+    Object.entries(record).forEach(([key, entry]) => {
+        if (entry === null) {
+            walked[key] = null;
+            return;
+        }
+        const walkedEntry = walk(valueSchema, entry, config);
+        if (walkedEntry !== entry) {
+            changed = true;
+        }
+        walked[key] = walkedEntry;
+    });
+    return changed ? walked : record;
 }
 function walkObject(schema, record, serialisable, config) {
     const fields = fieldsOf(schema);
@@ -74,9 +86,9 @@ function walkObject(schema, record, serialisable, config) {
         walked[field.name] = walk(schema.entries[field.name], record[field.name], config);
     });
     if (serialisable != null && config.walkEntity) {
-        return config.walkEntity(serialisable, fields, walked, record);
+        return config.walkEntity({ serialisable, fields, walked, record });
     }
-    return config.walkObject ? config.walkObject(fields, walked, record) : record;
+    return config.walkObject ? config.walkObject({ fields, walked, record }) : record;
 }
 function fieldsOf(schema) {
     return Object.entries(schema.entries).map(([name, fieldSchema]) => {
@@ -91,8 +103,8 @@ function matches(schema, value) {
     }
     return v.is(schema, value);
 }
-function isAnyRef(value) {
-    return isRef(value) || isSerialisedRef(value);
+function isAnyParameter(value) {
+    return isParameter(value) || isSerialisedParameter(value);
 }
 function unwrapPipe(schema) {
     if ('pipe' in schema && Array.isArray(schema.pipe)) {

package/dist/walker/walkers.d.ts

@@ -1,8 +1,9 @@
 import type { Walker } from './walker';
-import { BuilderRef } from '../references.js';
+import type * as v from 'valibot';
+import { BuilderParameter } from '../references.js';
 export declare function createWalkerSerialise(): Walker;
 export declare function createWalkerDeserialise(): Walker;
-export declare function createWalkerValidation(onUnbound: (ref: BuilderRef) => void): Walker;
+export declare function createWalkerValidation(onUnbound: (parameter: BuilderParameter) => void): Walker;
 export declare function createWalkerBinding(config: {
-    readonly lookupBinding: (ref: BuilderRef) => unknown;
+    readonly lookupBinding: (parameter: BuilderParameter, paramableSchema: v.GenericSchema) => unknown;
 }): Walker;

package/dist/walker/walkers.js

@@ -1,34 +1,38 @@
-import { BuilderRef } from '../references.js';
+import { BuilderParameter } from '../references.js';
 import { walk } from './walker.js';
 export function createWalkerSerialise() {
     return (schema, data) => walk(schema, data, {
-        onRef: (ref) => ({ type: 'ref', id: ref.id, name: ref.name }),
-        walkObject: (fields, walked) => rebuild(fields, walked)
+        onParameter: (parameter) => ({
+            type: 'parameter',
+            id: parameter.id,
+            name: parameter.name
+        }),
+        walkObject: ({ fields, walked }) => rebuild(fields, walked)
     });
 }
 export function createWalkerDeserialise() {
     return (schema, data) => walk(schema, data, {
-        onSerialisedRef: (serialised) => new BuilderRef(serialised.name, serialised.id),
-        walkObject: (fields, walked) => rebuild(fields, walked),
-        walkEntity: (serialisable, fields, walked) => construct(serialisable, fields, rebuild(fields, walked))
+        onSerialisedParameter: (serialised) => new BuilderParameter(serialised.name, serialised.id),
+        walkObject: ({ fields, walked }) => rebuild(fields, walked),
+        walkEntity: ({ serialisable, fields, walked }) => construct(serialisable, fields, rebuild(fields, walked))
     });
 }
 export function createWalkerValidation(onUnbound) {
     return (schema, data) => walk(schema, data, {
-        onRef: (ref) => {
-            onUnbound(ref);
-            return ref;
+        onParameter: (parameter) => {
+            onUnbound(parameter);
+            return parameter;
         }
     });
 }
 export function createWalkerBinding(config) {
     return (schema, data) => walk(schema, data, {
-        onRef: (ref) => {
-            const value = config.lookupBinding(ref);
-            return value != null ? value : ref;
+        onParameter: (parameter, paramableSchema) => {
+            const value = config.lookupBinding(parameter, paramableSchema);
+            return value != null ? value : parameter;
         },
-        walkObject: (_fields, walked, record) => applyPatches(record, walked),
-        walkEntity: (serialisable, fields, walked, record) => {
+        walkObject: ({ walked, record }) => applyPatches(record, walked),
+        walkEntity: ({ serialisable, fields, walked, record }) => {
             const merged = applyPatches(record, walked);
             return merged === record ? record : construct(serialisable, fields, merged);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "exports": {
     ".": {
@@ -23,13 +23,14 @@
     "build": "vite build",
     "package": "svelte-kit sync && svelte-package --input src/lib/builder",
     "preview": "vite preview",
-    "prepare": "svelte-kit sync || echo ''",
+    "prepare": "svelte-kit sync && npm run messages || echo ''",
     "prepublishOnly": "npm run test && npm run package",
-    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "messages": "paraglide-js compile --project ./project.inlang --outdir ./src/lib/i18n",
+    "check": "npm run messages && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "npm run messages && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
-    "test:unit": "vitest",
+    "test:unit": "npm run messages && vitest",
     "test": "npm run test:unit -- --run",
     "verify": "npm run test && npm run check && npm run format && npm run lint",
     "types:db": "dotenv -e .env.development.local -- supabase gen types typescript --project-id \"$SUPABASE_PROJECT_ID\" --schema public > ./src/lib/db/database.types.ts"
@@ -37,6 +38,7 @@
   "devDependencies": {
     "@eslint/compat": "^1.2.5",
     "@eslint/js": "^9.18.0",
+    "@inlang/paraglide-js": "^2.16.0",
     "@sveltejs/adapter-auto": "^6.0.0",
     "@sveltejs/adapter-vercel": "^5.7.2",
     "@sveltejs/kit": "^2.16.0",
@@ -54,7 +56,7 @@
     "jsdom": "^26.0.0",
     "prettier": "^3.4.2",
     "prettier-plugin-svelte": "^3.3.3",
-    "supabase": "^2.33.9",
+    "supabase": "^2.93.0",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "typescript": "^5.0.0",
@@ -65,7 +67,7 @@
   "dependencies": {
     "@floating-ui/dom": "^1.7.2",
     "@lucide/svelte": "^0.525.0",
-    "@supabase/supabase-js": "^2.49.8",
+    "@supabase/supabase-js": "^2.104.0",
     "@upstash/ratelimit": "^2.0.5",
     "@upstash/redis": "^1.35.0",
     "@vercel/kv": "^3.0.0",
@@ -74,4 +76,4 @@
     "svelte-clerk": "^1.1.1",
     "valibot": "^1.1.0"
   }
-}
+}

package/dist/entities/builder/parameter.d.ts

@@ -1,61 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderRef, Refable } from '../../references';
-import type { BuilderCollectionPayload } from '../collection/index';
-import type { BuilderComponentPayload } from '../component/index';
-import type { BuilderOptionPayload } from '../option/index';
-import type { BuilderWhenConfig, BuilderWhenConstrained, WhenConfigNullable } from '../when';
-import type { BuilderState, BuilderStateAppend } from './state';
-import { Builder } from './builder.js';
-export type BuilderBindings<State extends BuilderState> = EntryStateBindings<State, State['options'], BuilderOptionPayload> & EntryStateBindings<State, State['collections'], BuilderCollectionPayload> & EntryStateBindings<State, State['components'], BuilderComponentPayload>;
-export declare function bindBuilder<State extends BuilderState, Bindings extends BuilderBindings<State>>(builder: Builder<State>, bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
-export type BuilderBoundState<State extends BuilderState, Bindings extends BuilderBindings<State>> = BuilderStateAppend<State, {
-    options: EntryBound<State['options'], Extract<keyof Bindings, string>>;
-    collections: EntryBound<State['collections'], Extract<keyof Bindings, string>>;
-    components: EntryBound<State['components'], Extract<keyof Bindings, string>>;
-    model: Omit<State['model'], keyof Bindings> & {
-        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
-    };
-}>;
-export type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
-type BindingValueType<Binding> = Binding extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap extends Record<string, unknown>;
-} ? NonNullable<SelectMap[keyof SelectMap]> extends {
-    readonly value: infer Value;
-} ? Value : string : Binding extends {
-    readonly payload: {
-        readonly value: infer Value;
-    };
-} ? Value : Binding extends {
-    readonly value: infer Value;
-} ? Value : string;
-type BindingConfigNullable<Binding> = Binding extends BuilderWhenConfig ? WhenConfigNullable<Binding> : never;
-type EntryLike = {
-    readonly name: string;
-    readonly payload: unknown;
-    readonly gatePaths?: Refable<BuilderPaths>;
-};
-type EntryStateBindings<State extends BuilderState, Entries extends ReadonlyArray<EntryLike>, PayloadType> = {
-    readonly [Parameter in EntryParameters<Entries> as Parameter['name']]: BuilderWhenConstrained<State, PayloadType>;
-};
-type EntryBound<Entries extends ReadonlyArray<EntryLike>, BoundNames extends string> = Entries extends readonly [
-    infer Head extends EntryLike,
-    ...infer Tail extends ReadonlyArray<EntryLike>
-] ? Head extends {
-    readonly payload: infer Payload;
-} ? Payload extends BuilderRef ? Head['name'] extends BoundNames ? [...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [];
-type EntryParameters<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
-    readonly payload: infer Payload;
-} ? PayloadParameters<Payload> : never : never;
-type PayloadParameters<Payload> = ParameterOf<Payload> | (Payload extends {
-    readonly type: 'match';
-    readonly selectMap: infer SelectMap;
-} ? ParameterOf<SelectMap[keyof SelectMap]> : never) | (Payload extends {
-    readonly type: 'enable' | 'unless';
-    readonly payload: infer Inner;
-} ? ParameterOf<Inner> : never);
-type ParameterOf<Value> = Extract<Value, BuilderRef> extends infer Ref extends BuilderRef ? {
-    readonly name: Ref['name'];
-    readonly payload: Ref;
-} : never;
-export {};