@builder-builder/builder 0.0.7 → 0.0.8

package/dist/mappers/render/render.js

@@ -0,0 +1,124 @@
+import * as v from 'valibot';
+import { assertModel, assertUI } from '../assert/index.js';
+import { check } from '../../check.js';
+import { readPath } from '../../paths.js';
+import { resolveCollection, resolveOption } from '../resolve.js';
+import { ordinal } from './ordinal.js';
+export function render(ui, rootModel) {
+    assertUI(ui);
+    const rootBuilder = ui.builder;
+    assertModel(rootBuilder, rootModel);
+    const layout = [];
+    const description = [];
+    walk(rootBuilder, rootModel, [], [], ui.items);
+    return { layout, description };
+    function walk(builder, model, collectionPath, labelContext, items) {
+        function composeLabel(label) {
+            if (labelContext.length === 0) {
+                return label.label;
+            }
+            return `${labelContext.join(', ')}, ${label.label}`;
+        }
+        items.forEach((item) => {
+            if (item.type === 'pages') {
+                const collection = findCollection(builder, model, item.name);
+                if (!collection) {
+                    return;
+                }
+                const models = model[collection.name];
+                models.forEach((collectionModel, itemIndex) => {
+                    const labelSegment = `${ordinal(itemIndex)} ${item.label.label}`;
+                    walk(collection.payload.builder, collectionModel, [...collectionPath, item.name, itemIndex], [...labelContext, labelSegment], item.items);
+                });
+                return;
+            }
+            if (item.type === 'page') {
+                const options = item.paths.flatMap((path) => {
+                    const option = findResolvedOption(builder, model, path);
+                    if (!option) {
+                        return [];
+                    }
+                    const fullPath = [...collectionPath, ...path];
+                    return [
+                        {
+                            option: option.payload,
+                            value: readPath(model, fullPath),
+                            update: (updateModel, updateValue) => setPath(updateModel, fullPath, updateValue)
+                        }
+                    ];
+                });
+                if (options.length === 0) {
+                    return;
+                }
+                layout.push({ label: composeLabel(item.label), options });
+                return;
+            }
+            if (item.type === 'describe') {
+                const composedLabel = composeLabel(item.label);
+                const values = item.paths.flatMap((path) => {
+                    const option = findResolvedOption(builder, model, path);
+                    if (!option) {
+                        return [];
+                    }
+                    const fullPath = [...collectionPath, ...path];
+                    const value = readPath(model, fullPath);
+                    if (value == null) {
+                        return [];
+                    }
+                    return [value];
+                });
+                if (values.length === 0) {
+                    return;
+                }
+                description.push([composedLabel, values.join(' ')]);
+            }
+        });
+    }
+    function findResolvedOption(builder, model, path) {
+        const optionName = path.at(-1);
+        check.assert(v.string(), optionName);
+        const collectionPairs = path.slice(0, -1);
+        const resolved = descendPairs(builder, model, collectionPairs);
+        if (!resolved) {
+            return null;
+        }
+        return (resolved.builder.options
+            .map((entry) => resolveOption(entry, resolved.model))
+            .find((entry) => entry?.name === optionName) ?? null);
+    }
+    function descendPairs(currentBuilder, currentModel, remaining) {
+        if (remaining.length === 0) {
+            return { builder: currentBuilder, model: currentModel };
+        }
+        const [collectionName, modelIndex, ...rest] = remaining;
+        check.assert(v.string(), collectionName);
+        check.assert(v.number(), modelIndex);
+        const collection = findCollection(currentBuilder, currentModel, collectionName);
+        if (!collection) {
+            return null;
+        }
+        const nextModel = currentModel[collection.name].at(modelIndex);
+        if (!nextModel) {
+            return null;
+        }
+        return descendPairs(collection.payload.builder, nextModel, rest);
+    }
+    function findCollection(builder, model, collectionName) {
+        return (builder.collections
+            .map((entry) => resolveCollection(entry, model))
+            .find((collection) => collection?.name === collectionName) ?? null);
+    }
+}
+function setPath(container, path, value) {
+    const [head, ...tail] = path;
+    if (typeof head === 'number') {
+        const arrayContainer = container ? [...container] : [];
+        arrayContainer[head] = tail.length === 0 ? value : setPath(arrayContainer[head], tail, value);
+        return arrayContainer;
+    }
+    const objectContainer = container ? container : {};
+    return {
+        ...objectContainer,
+        [head]: tail.length === 0 ? value : setPath(objectContainer[head], tail, value)
+    };
+}

package/dist/mappers/resolve.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderCollectionConfig, BuilderCollectionValidated, BuilderComponentDetails, BuilderComponentValidated, BuilderExpectations, BuilderOptionValidated, BuilderOptionValues, BuilderValidated } from '../entities/index';
+import type { BuilderPaths } from '../paths';
+import { BuilderCollection, BuilderComponent, BuilderOption } from '../entities/index.js';
+export type BuilderOptionResolved = BuilderOption<string, BuilderOptionValues, BuilderPaths>;
+export type BuilderComponentResolved = BuilderComponent<string, BuilderComponentDetails<BuilderExpectations>, BuilderPaths>;
+export type BuilderCollectionResolved = BuilderCollection<string, BuilderCollectionConfig<BuilderValidated, number, number>, BuilderPaths>;
+export declare function resolveOption(option: BuilderOptionValidated, model: unknown): BuilderOptionResolved | null;
+export declare function resolveComponent(component: BuilderComponentValidated, model: unknown): BuilderComponentResolved | null;
+export declare function resolveCollection(collection: BuilderCollectionValidated, model: unknown): BuilderCollectionResolved | null;

package/dist/mappers/resolve.js

@@ -0,0 +1,57 @@
+import { check } from '../check.js';
+import { BuilderCollection, BuilderCollectionConfigSchema, BuilderComponent, BuilderComponentDetailsSchema, BuilderOption, BuilderOptionValuesSchema } from '../entities/index.js';
+import { BuilderPathsSchema, readPath } from '../paths.js';
+export function resolveOption(option, model) {
+    if (check.is(BuilderOptionValuesSchema, option.payload)) {
+        return new BuilderOption(option.name, option.payload);
+    }
+    check.assert(BuilderPathsSchema, option.gatePaths);
+    const result = resolveWhen(option.gatePaths, option.payload, model);
+    if (!result) {
+        return null;
+    }
+    return new BuilderOption(option.name, result);
+}
+export function resolveComponent(component, model) {
+    if (check.is(BuilderComponentDetailsSchema, component.payload)) {
+        return new BuilderComponent(component.name, component.payload);
+    }
+    check.assert(BuilderPathsSchema, component.gatePaths);
+    const result = resolveWhen(component.gatePaths, component.payload, model);
+    if (!result) {
+        return null;
+    }
+    return new BuilderComponent(component.name, result);
+}
+export function resolveCollection(collection, model) {
+    if (check.is(BuilderCollectionConfigSchema, collection.payload)) {
+        return new BuilderCollection(collection.name, collection.payload);
+    }
+    check.assert(BuilderPathsSchema, collection.gatePaths);
+    const result = resolveWhen(collection.gatePaths, collection.payload, model);
+    if (!result) {
+        return null;
+    }
+    return new BuilderCollection(collection.name, result);
+}
+function resolveWhen(gatePaths, config, model) {
+    if (!gatePaths.every((path) => !!readPath(model, path))) {
+        return null;
+    }
+    switch (config.type) {
+        case 'enable': {
+            return config.payload;
+        }
+        case 'match': {
+            const selectMap = config.selectMap;
+            return selectMap[`${readPath(model, config.matchPath)}`];
+        }
+        case 'unless': {
+            const value = readPath(model, config.unlessPath);
+            if (config.disabledValues.includes(value)) {
+                return null;
+            }
+            return config.payload;
+        }
+    }
+}

package/dist/model.d.ts

@@ -1,14 +1,14 @@
-import type { BuilderPrimitive } from './schemas/index';
-export type { BuilderPrimitive, BuilderPrimitives } from './schemas/index';
+import type { BuilderPrimitive } from './primitive';
 export type BuilderModel = {
     readonly [key: string]: BuilderPrimitive | BuilderModels;
 };
-export type BuilderModelInput = Record<string, unknown>;
 export type BuilderModels = ReadonlyArray<BuilderModel>;
-export type BuilderVariant = {
-    readonly model: BuilderModel;
-    readonly price?: string;
-    readonly image?: string;
-};
+export type BuilderModelInput = Readonly<Record<string, unknown>>;
+export type BuilderVariant = Readonly<{
+    model: BuilderModel;
+    price?: string;
+    image?: string;
+    details?: Readonly<Record<string, string>>;
+}>;
 export type BuilderVariants = ReadonlyArray<BuilderVariant>;
 export type BuilderData = Readonly<Record<string, BuilderVariants>>;

package/dist/paths.d.ts

@@ -1,17 +1,6 @@
-import type { BuilderGeneric, BuilderModelOf } from './core/index';
-import type { BuilderPath, BuilderPrimitive } from './schemas/index';
-export type { BuilderPath, BuilderPaths } from './schemas/index';
-export type BuilderValidPath<Model, Depth extends ReadonlyArray<never> = []> = Depth['length'] extends 10 ? never : Model extends BuilderPrimitive | null ? never : Model extends ReadonlyArray<infer Item> ? [number] | [number, ...BuilderValidPath<Item, [...Depth, never]>] : {
-    [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...BuilderValidPath<Model[Key], [...Depth, never]>]);
-}[keyof Model & string];
-export type BuilderValidPaths<Model> = ReadonlyArray<BuilderValidPath<Model>>;
-export type BuilderModelPaths<Builder extends BuilderGeneric | null> = [Builder] extends [
-    BuilderGeneric
-] ? BuilderValidPaths<BuilderModelOf<Builder>> : ReadonlyArray<never>;
-export type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
-    infer Head extends keyof Model & string
-] ? Model[Head] : Path extends readonly [
-    infer Head extends keyof Model & string,
-    ...infer Tail extends BuilderPath
-] ? Model[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Model[Head], Tail> : never;
+import * as v from 'valibot';
+export declare const BuilderPathSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+export type BuilderPath = v.InferOutput<typeof BuilderPathSchema>;
+export declare const BuilderPathsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+export type BuilderPaths = v.InferOutput<typeof BuilderPathsSchema>;
 export declare function readPath(model: unknown, path: BuilderPath): unknown;

package/dist/paths.js

@@ -1,3 +1,6 @@
+import * as v from 'valibot';
+export const BuilderPathSchema = v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly());
+export const BuilderPathsSchema = v.pipe(v.array(BuilderPathSchema), v.readonly());
 export function readPath(model, path) {
     return path.reduce((current, segment) => {
         if (current == null) {

package/dist/primitive.d.ts

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export declare const BuilderPrimitiveSchema: v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+export type BuilderPrimitive = v.InferOutput<typeof BuilderPrimitiveSchema>;
+export declare const BuilderPrimitivesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, v.ReadonlyAction<(string | number | boolean | null)[]>]>;
+export type BuilderPrimitives = v.InferOutput<typeof BuilderPrimitivesSchema>;

package/dist/{schemas/primitives.js → primitive.js}

@@ -1,5 +1,3 @@
 import * as v from 'valibot';
 export const BuilderPrimitiveSchema = v.nullable(v.union([v.string(), v.boolean(), v.number()]));
 export const BuilderPrimitivesSchema = v.pipe(v.array(BuilderPrimitiveSchema), v.readonly());
-export const BuilderPathSchema = v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly());
-export const BuilderPathsSchema = v.pipe(v.array(BuilderPathSchema), v.readonly());

package/dist/references.d.ts

@@ -0,0 +1,60 @@
+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 declare class BuilderRef {
+    readonly id: string;
+    readonly name: string;
+    constructor(name: string, 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>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "ref";
+    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>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "ref";
+    id: string;
+    name: string;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    type: "ref";
+    id: string;
+    name: string;
+}>[]>]>;
+export type BuilderRefsSerialised = v.InferOutput<typeof BuilderRefsSerialisedSchema>;
+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>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "ref";
+    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>;
+    readonly id: v.StringSchema<undefined>;
+    readonly name: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "ref";
+    id: string;
+    name: string;
+}>]> | v.InstanceSchema<typeof BuilderRef, undefined> | Schema>, {
+    readonly refable: Schema;
+}>]>;

package/dist/references.js

@@ -0,0 +1,26 @@
+import * as v from 'valibot';
+import { check } from './check.js';
+export class BuilderRef {
+    id;
+    name;
+    constructor(name, id = crypto.randomUUID()) {
+        this.name = name;
+        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 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);
+}
+export function refable(refable) {
+    return v.pipe(v.union([BuilderRefSerialisedSchema, BuilderRefSchema, refable]), v.metadata({ refable }));
+}

package/dist/serialisable.d.ts

@@ -0,0 +1,10 @@
+import * as v from 'valibot';
+export type SerialisableClass = new (...args: ReadonlyArray<never>) => object;
+export type SerialisableMetadata = {
+    readonly serialisable?: SerialisableClass;
+    readonly instance?: v.GenericSchema;
+};
+export declare function serialisable<Serialisable extends SerialisableClass, Schema extends v.GenericSchema>(serialisable: Serialisable, schema: Schema): v.SchemaWithPipe<readonly [Schema, v.MetadataAction<v.InferOutput<Schema>, {
+    readonly serialisable: Serialisable;
+    readonly instance: v.InstanceSchema<Serialisable, undefined>;
+}>, v.ReadonlyAction<v.InferOutput<Schema>>]>;

package/dist/serialisable.js

@@ -0,0 +1,5 @@
+import * as v from 'valibot';
+export function serialisable(serialisable, schema) {
+    const instance = v.instance(serialisable);
+    return v.pipe(schema, v.metadata({ serialisable, instance }), v.readonly());
+}

package/dist/walker/index.d.ts

@@ -0,0 +1,2 @@
+export type { Walker } from './walker';
+export { createWalkerBinding, createWalkerDeserialise, createWalkerSerialise, createWalkerValidation } from './walkers.js';

package/dist/walker/index.js

@@ -0,0 +1 @@
+export { createWalkerBinding, createWalkerDeserialise, createWalkerSerialise, createWalkerValidation } from './walkers.js';

package/dist/walker/walkable.d.ts

@@ -0,0 +1,4 @@
+import type * as v from 'valibot';
+type WalkableSchema = v.LazySchema<v.GenericSchema> | v.OptionalSchema<v.GenericSchema, unknown> | v.NullableSchema<v.GenericSchema, unknown> | v.ArraySchema<v.GenericSchema, undefined> | v.RecordSchema<v.GenericSchema<string>, v.GenericSchema, undefined> | v.ObjectSchema<v.ObjectEntries, undefined> | v.UnionSchema<ReadonlyArray<v.GenericSchema>, undefined> | v.VariantSchema<string, v.VariantOptions<string>, undefined>;
+export declare function isWalkable(schema: v.GenericSchema): schema is WalkableSchema;
+export {};

package/dist/walker/walkable.js

@@ -0,0 +1,4 @@
+const WALKABLE = ['lazy', 'optional', 'nullable', 'array', 'record', 'object', 'union', 'variant'];
+export function isWalkable(schema) {
+    return WALKABLE.includes(schema.type);
+}

package/dist/walker/walker.d.ts

@@ -0,0 +1,18 @@
+import type { BuilderRef, BuilderRefSerialised } from '../references';
+import type { SerialisableClass } from '../serialisable';
+import * as v from 'valibot';
+export type Walker = (schema: v.GenericSchema, data: unknown) => unknown;
+export type WalkerField = {
+    readonly name: string;
+    readonly literal: {
+        readonly value: unknown;
+    } | null;
+};
+export type WalkerFields = ReadonlyArray<WalkerField>;
+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;
+};
+export declare function walk(schema: v.GenericSchema, value: unknown, config: WalkerConfig): unknown;

package/dist/walker/walker.js

@@ -0,0 +1,103 @@
+import * as v from 'valibot';
+import { isRef, isSerialisedRef } 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);
+    }
+    const inner = unwrapPipe(schema);
+    if (!isWalkable(inner)) {
+        return value;
+    }
+    switch (inner.type) {
+        case 'lazy':
+            return walk(inner.getter(value), value, config);
+        case 'optional':
+        case 'nullable':
+            return walk(inner.wrapped, value, config);
+        case 'array':
+            return walkArray(inner.item, value, config);
+        case 'record':
+            return walkRecord(inner.value, value, config);
+        case 'object':
+            return walkObject(inner, value, meta.serialisable, config);
+        case 'union':
+        case 'variant': {
+            const matched = inner.options.find((option) => matches(option, value));
+            return matched ? walk(matched, value, config) : value;
+        }
+    }
+}
+function isLiteral(schema) {
+    return schema.type === 'literal';
+}
+function walkRefable(inner, value, config) {
+    if (value == null) {
+        return value;
+    }
+    const resolved = isRef(value) && config.onRef
+        ? config.onRef(value)
+        : isSerialisedRef(value) && config.onSerialisedRef
+            ? config.onSerialisedRef(value)
+            : value;
+    if (isRef(resolved) || isSerialisedRef(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];
+        });
+    });
+}
+function walkRecord(valueSchema, record, config) {
+    return Object.fromEntries(Object.entries(record).map(([key, entry]) => entry === null ? [key, null] : [key, walk(valueSchema, entry, config)]));
+}
+function walkObject(schema, record, serialisable, config) {
+    const fields = fieldsOf(schema);
+    const walked = {};
+    fields.forEach((field) => {
+        if (field.literal) {
+            return;
+        }
+        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.walkObject ? config.walkObject(fields, walked, record) : record;
+}
+function fieldsOf(schema) {
+    return Object.entries(schema.entries).map(([name, fieldSchema]) => {
+        const inner = unwrapPipe(fieldSchema);
+        return isLiteral(inner) ? { name, literal: { value: inner.literal } } : { name, literal: null };
+    });
+}
+function matches(schema, value) {
+    const { instance } = v.getMetadata(schema);
+    if (instance != null && v.is(instance, value)) {
+        return true;
+    }
+    return v.is(schema, value);
+}
+function isAnyRef(value) {
+    return isRef(value) || isSerialisedRef(value);
+}
+function unwrapPipe(schema) {
+    if ('pipe' in schema && Array.isArray(schema.pipe)) {
+        const [first] = schema.pipe;
+        return first;
+    }
+    return schema;
+}

package/dist/walker/walkers.d.ts

@@ -0,0 +1,8 @@
+import type { Walker } from './walker';
+import { BuilderRef } 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 createWalkerBinding(config: {
+    readonly lookupBinding: (ref: BuilderRef) => unknown;
+}): Walker;

package/dist/walker/walkers.js

@@ -0,0 +1,51 @@
+import { BuilderRef } 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)
+    });
+}
+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))
+    });
+}
+export function createWalkerValidation(onUnbound) {
+    return (schema, data) => walk(schema, data, {
+        onRef: (ref) => {
+            onUnbound(ref);
+            return ref;
+        }
+    });
+}
+export function createWalkerBinding(config) {
+    return (schema, data) => walk(schema, data, {
+        onRef: (ref) => {
+            const value = config.lookupBinding(ref);
+            return value != null ? value : ref;
+        },
+        walkObject: (_fields, walked, record) => applyPatches(record, walked),
+        walkEntity: (serialisable, fields, walked, record) => {
+            const merged = applyPatches(record, walked);
+            return merged === record ? record : construct(serialisable, fields, merged);
+        }
+    });
+}
+function rebuild(fields, walked) {
+    return Object.fromEntries(fields.map((field) => [
+        field.name,
+        field.literal !== null ? field.literal.value : walked[field.name]
+    ]));
+}
+function construct(serialisable, fields, entries) {
+    const args = fields.filter((field) => field.literal === null).map((field) => entries[field.name]);
+    const callable = serialisable;
+    return new callable(...args);
+}
+function applyPatches(record, walked) {
+    const patches = Object.entries(walked).filter(([name, value]) => value !== record[name]);
+    return patches.length === 0 ? record : { ...record, ...Object.fromEntries(patches) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "exports": {
     ".": {
@@ -13,6 +13,9 @@
   ],
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "dev": "vite dev",
     "predev": "npm run types:db",
@@ -21,12 +24,14 @@
     "package": "svelte-kit sync && svelte-package --input src/lib/builder",
     "preview": "vite preview",
     "prepare": "svelte-kit sync || 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",
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint .",
     "test:unit": "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"
   },
   "devDependencies": {
@@ -43,6 +48,7 @@
     "dotenv-cli": "^8.0.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-import-x": "^4.16.2",
     "eslint-plugin-svelte": "^3.0.0",
     "globals": "^16.0.0",
     "jsdom": "^26.0.0",
@@ -52,7 +58,7 @@
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "typescript": "^5.0.0",
-    "typescript-eslint": "^8.20.0",
+    "typescript-eslint": "^8.58.2",
     "vite": "^6.2.6",
     "vitest": "^3.0.0"
   },
@@ -68,4 +74,4 @@
     "svelte-clerk": "^1.1.1",
     "valibot": "^1.1.0"
   }
-}
+}