@builder-builder/builder 0.0.10 → 0.0.11

package/dist/mappers/assert/ui.js

@@ -1,22 +0,0 @@
-import { BuilderUISerialisedSchema } from '../../entities/index.js';
-import { BuilderException } from '../../exception.js';
-import { isParameter } from '../../references.js';
-import { createWalkerValidation } from '../../walker/index.js';
-import { collectExpectationErrors } from './expectation.js';
-export function assertUI(ui) {
-    const errors = collectUIErrors(ui);
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-function collectUIErrors(ui) {
-    const parameterErrors = [];
-    const walkValidate = createWalkerValidation((parameter) => {
-        parameterErrors.push({ kind: 'unbound-parameter', name: parameter.name });
-    });
-    walkValidate(BuilderUISerialisedSchema, ui);
-    const expectationErrors = isParameter(ui.builder)
-        ? []
-        : collectExpectationErrors(ui.builder, ui.expectations);
-    return [...parameterErrors, ...expectationErrors];
-}

package/dist/mappers/instance/index.d.ts

@@ -1 +0,0 @@
-export { createInstance } from './instance.js';

package/dist/mappers/instance/index.js

@@ -1 +0,0 @@
-export { createInstance } from './instance.js';

package/dist/mappers/instance/instance.d.ts

@@ -1,4 +0,0 @@
-import type { BuilderGeneric, BuilderInstanceOf } from '../../entities/index';
-import type { Prettify } from '../../prettify';
-import type { BuilderModelInput } from '../../model';
-export declare function createInstance<const Input extends BuilderGeneric>(builder: Input, partial?: BuilderModelInput): Prettify<BuilderInstanceOf<Input>>;

package/dist/mappers/instance/instance.js

@@ -1,33 +0,0 @@
-import * as v from 'valibot';
-import { resolveCollection, resolveOption } from '../resolve.js';
-import { assertBuilder } from '../assert/index.js';
-export function createInstance(builder, partial = {}) {
-    assertBuilder(builder);
-    return createInstanceInternal(builder, partial);
-}
-function createInstanceInternal(builder, partial = {}) {
-    const { options, collections } = builder;
-    const withOptions = options.reduce((current, entry) => {
-        const option = resolveOption(entry, current);
-        if (!option) {
-            return current;
-        }
-        if (v.is(option.payload.valueSchema, current[option.name])) {
-            return current;
-        }
-        return { ...current, [option.name]: option.payload.defaultValue };
-    }, partial);
-    const withCollections = collections.reduce((current, entry) => {
-        const collection = resolveCollection(entry, current);
-        if (!collection) {
-            return current;
-        }
-        const existing = current[collection.name];
-        const collectionModels = Array.isArray(existing) ? existing : [];
-        const nestedBuilder = collection.payload.builder;
-        const desiredLength = Math.max(collectionModels.length, collection.payload.min);
-        const items = Array.from({ length: desiredLength }).map((_, index) => createInstanceInternal(nestedBuilder, collectionModels[index] ?? {}));
-        return { ...current, [collection.name]: items };
-    }, withOptions);
-    return withCollections;
-}

package/dist/mappers/models/component-graph.d.ts

@@ -1,9 +0,0 @@
-import type { BuilderComponentValidated } from '../../entities/index';
-import type { GraphPaths } from './graph';
-import type { BuilderOptionGraph } from './option-graph';
-export declare class BuilderComponentGraph {
-    #private;
-    readonly paths: GraphPaths;
-    constructor(paths?: GraphPaths);
-    add(component: BuilderComponentValidated, options: BuilderOptionGraph): BuilderComponentGraph;
-}

package/dist/mappers/models/component-graph.js

@@ -1,51 +0,0 @@
-import { check } from '../../check.js';
-import { crossProduct, dependencyKeys } from './graph.js';
-export class BuilderComponentGraph {
-    paths;
-    constructor(paths = []) {
-        this.paths = paths;
-    }
-    add(component, options) {
-        check.falsy(this.#has(component.name), `Duplicate component name '${component.name}'! ❌`);
-        const { gatePaths, payload } = component;
-        const keys = new Set(dependencyKeys(payload, gatePaths));
-        const models = this.#mergeModels(keys, options);
-        const newPath = { name: component.name, keys, models };
-        return new BuilderComponentGraph([...this.paths, newPath]);
-    }
-    #has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
-    #mergeModels(keys, options) {
-        const graphPaths = Array.from(keys)
-            .map((key) => options.get(key))
-            .sort((pathA, pathB) => pathB.keys.size - pathA.keys.size);
-        const handledKeys = new Set();
-        let models = [{}];
-        graphPaths.forEach((graphPath) => {
-            const isHandled = handledKeys.has(graphPath.name) &&
-                Array.from(graphPath.keys).every((key) => handledKeys.has(key));
-            if (!isHandled) {
-                const componentModels = this.#createModels(graphPath, keys);
-                models = crossProduct(models, componentModels);
-                handledKeys.add(graphPath.name);
-                graphPath.keys.forEach((key) => handledKeys.add(key));
-            }
-        });
-        return models;
-    }
-    #createModels(graphPath, keys) {
-        const seen = new Set();
-        const models = [];
-        graphPath.models.forEach((model) => {
-            const picked = Object.fromEntries(Object.entries(model).filter(([key, value]) => keys.has(key) && value != null));
-            const identity = JSON.stringify(picked);
-            if (identity !== EMPTY_MODEL && !seen.has(identity)) {
-                seen.add(identity);
-                models.push(picked);
-            }
-        });
-        return models;
-    }
-}
-const EMPTY_MODEL = '{}';

package/dist/mappers/models/graph.d.ts

@@ -1,12 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-import type { BuilderWhen } from '../../entities/index';
-import type { BuilderModels } from '../../model';
-export type GraphKeys = ReadonlySet<string>;
-export type GraphPath = {
-    name: string;
-    keys: GraphKeys;
-    models: BuilderModels;
-};
-export type GraphPaths = ReadonlyArray<GraphPath>;
-export declare function crossProduct(left: BuilderModels, right: BuilderModels): BuilderModels;
-export declare function dependencyKeys(payload: unknown | BuilderWhen, gatePaths?: BuilderPaths): ReadonlyArray<string>;

package/dist/mappers/models/graph.js

@@ -1,17 +0,0 @@
-import * as v from 'valibot';
-import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
-export function crossProduct(left, right) {
-    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
-}
-export function dependencyKeys(payload, gatePaths = []) {
-    const keys = new Set(gatePaths.map(([first]) => String(first)));
-    if (v.is(BuilderWhenMatchSchema, payload)) {
-        const [firstMatchSegment] = payload.matchPath;
-        keys.add(String(firstMatchSegment));
-    }
-    else if (v.is(BuilderWhenUnlessSchema, payload)) {
-        const [firstUnlessSegment] = payload.unlessPath;
-        keys.add(String(firstUnlessSegment));
-    }
-    return Array.from(keys);
-}

package/dist/mappers/models/index.d.ts

@@ -1 +0,0 @@
-export { createModels } from './models.js';

package/dist/mappers/models/index.js

@@ -1 +0,0 @@
-export { createModels } from './models.js';

package/dist/mappers/models/models.d.ts

@@ -1,3 +0,0 @@
-import type { BuilderGeneric } from '../../entities/index';
-import type { BuilderData } from '../../model';
-export declare function createModels(builder: BuilderGeneric): BuilderData;

package/dist/mappers/models/models.js

@@ -1,37 +0,0 @@
-import * as v from 'valibot';
-import { BuilderCollectionConfigSchema } from '../../entities/index.js';
-import { assertBuilder } from '../assert/index.js';
-import { BuilderComponentGraph } from './component-graph.js';
-import { BuilderOptionGraph } from './option-graph.js';
-export function createModels(builder) {
-    assertBuilder(builder);
-    return models(builder.options, builder.components, builder.collections);
-}
-function models(options, components, collections) {
-    const collectionModels = collections.flatMap((entry) => {
-        return collectionBuilders(entry).map((nestedBuilder) => models(nestedBuilder.options, nestedBuilder.components, nestedBuilder.collections));
-    });
-    return {
-        ...collectionModels.reduce((merged, component) => ({ ...merged, ...component }), {}),
-        ...Object.fromEntries(componentGraph(components, options).paths.map((path) => [
-            path.name,
-            path.models.map((model) => ({ model }))
-        ]))
-    };
-}
-function optionGraph(options) {
-    return options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
-}
-function componentGraph(components, options) {
-    return components.reduce((graph, component) => graph.add(component, optionGraph(options)), new BuilderComponentGraph());
-}
-function collectionBuilders(entry) {
-    const { payload } = entry;
-    if (v.is(BuilderCollectionConfigSchema, payload)) {
-        return [payload.builder];
-    }
-    if (payload.type === 'match') {
-        return Object.values(payload.selectMap).flatMap((value) => (value ? [value.builder] : []));
-    }
-    return [payload.payload.builder];
-}

package/dist/mappers/models/option-graph.d.ts

@@ -1,9 +0,0 @@
-import type { BuilderOptionValidated } from '../../entities/index';
-import type { GraphPath, GraphPaths } from './graph';
-export declare class BuilderOptionGraph {
-    #private;
-    readonly paths: GraphPaths;
-    constructor(paths?: GraphPaths);
-    get(name: string): GraphPath;
-    add(option: BuilderOptionValidated): BuilderOptionGraph;
-}

package/dist/mappers/order/index.d.ts

@@ -1,2 +0,0 @@
-export type { BuilderOrder } from './order';
-export { order } from './order.js';

package/dist/mappers/order/index.js

@@ -1 +0,0 @@
-export { order } from './order.js';

package/dist/mappers/order/order.d.ts

@@ -1,14 +0,0 @@
-import type { BuilderCollection, BuilderCollectionConfig, BuilderCollections, BuilderComponents, BuilderGeneric, BuilderStateOf, CollectionShape } from '../../entities/index';
-import type { Prettify } from '../../prettify';
-import type { BuilderData, BuilderModel, BuilderVariant } from '../../model';
-export type BuilderOrder<Builder extends BuilderGeneric> = Prettify<ComponentsOrder<BuilderStateOf<Builder>['components']> & CollectionsOrder<BuilderStateOf<Builder>['collections']>>;
-export declare function order<const Builder extends BuilderGeneric>(builder: Builder, model: BuilderModel, componentModels: BuilderData): BuilderOrder<Builder>;
-type ComponentsOrder<Components extends BuilderComponents> = {
-    readonly [Name in Components[number]['name']]: BuilderVariant | null;
-};
-type CollectionsOrder<Collections extends BuilderCollections> = Collections extends readonly [
-    infer Head extends BuilderCollection,
-    ...infer Tail extends BuilderCollections
-] ? Record<Head['name'], CollectionOrderOf<Head>> & CollectionsOrder<Tail> : {};
-type CollectionOrderOf<Collection extends BuilderCollection> = Collection['payload'] extends BuilderCollectionConfig ? CollectionShape<Collection, BuilderOrder<Collection['payload']['builder'] & BuilderGeneric>> : ReadonlyArray<unknown>;
-export {};

package/dist/mappers/order/order.js

@@ -1,31 +0,0 @@
-import { assertBuilder, assertModel, assertModels } from '../assert/index.js';
-import { resolveCollection, resolveComponent } from '../resolve.js';
-export function order(builder, model, componentModels) {
-    assertBuilder(builder);
-    assertModel(builder, model);
-    assertModels(builder, componentModels);
-    const { collections, components } = builder;
-    return orderInternal(collections, components, model, componentModels);
-}
-function orderInternal(collections, components, model, componentModels) {
-    const result = {};
-    components.forEach((component) => {
-        const resolved = resolveComponent(component, model);
-        if (!resolved) {
-            return;
-        }
-        const variants = componentModels[component.name] ?? [];
-        result[component.name] =
-            variants.find((variant) => Object.entries(variant.model).every(([key, value]) => model[key] === value)) ?? null;
-    });
-    collections.forEach((entry) => {
-        const collection = resolveCollection(entry, model);
-        if (!collection) {
-            return;
-        }
-        const itemModels = model[collection.name];
-        const { collections, components } = collection.payload.builder;
-        result[collection.name] = itemModels.map((itemModel) => orderInternal(collections, components, itemModel, componentModels));
-    });
-    return result;
-}

package/dist/mappers/refs.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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/model.d.ts

@@ -1,35 +0,0 @@
-import * as v from 'valibot';
-import { type BuilderPrimitive } from './primitive.js';
-export type BuilderModel = {
-    readonly [key: string]: BuilderPrimitive | BuilderModels;
-};
-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 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;
-    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,9 +0,0 @@
-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/walker/index.d.ts

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

package/dist/walker/index.js

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

package/dist/walker/walkable.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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;
-export type WalkerField = {
-    readonly name: string;
-    readonly literal: {
-        readonly value: unknown;
-    } | 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 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,115 +0,0 @@
-import * as v from 'valibot';
-import { isParameter, isSerialisedParameter } from '../references.js';
-import { isWalkable } from './walkable.js';
-export function walk(schema, value, config) {
-    const meta = v.getMetadata(schema);
-    if (meta.paramable != null) {
-        return walkParamable(meta.paramable, 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 walkParamable(inner, value, config) {
-    if (value == null) {
-        return value;
-    }
-    const resolved = isParameter(value) && config.onParameter
-        ? config.onParameter(value, inner)
-        : isSerialisedParameter(value) && config.onSerialisedParameter
-            ? config.onSerialisedParameter(value, inner)
-            : value;
-    if (isParameter(resolved) || isSerialisedParameter(resolved)) {
-        return resolved;
-    }
-    return walk(inner, resolved, config);
-}
-function walkArray(item, value, config) {
-    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) {
-    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);
-    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 isAnyParameter(value) {
-    return isParameter(value) || isSerialisedParameter(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

@@ -1,9 +0,0 @@
-import type { Walker } from './walker';
-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: (parameter: BuilderParameter) => void): Walker;
-export declare function createWalkerBinding(config: {
-    readonly lookupBinding: (parameter: BuilderParameter, paramableSchema: v.GenericSchema) => unknown;
-}): Walker;

package/dist/walker/walkers.js

@@ -1,55 +0,0 @@
-import { BuilderParameter } from '../references.js';
-import { walk } from './walker.js';
-export function createWalkerSerialise() {
-    return (schema, data) => walk(schema, data, {
-        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, {
-        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, {
-        onParameter: (parameter) => {
-            onUnbound(parameter);
-            return parameter;
-        }
-    });
-}
-export function createWalkerBinding(config) {
-    return (schema, data) => walk(schema, data, {
-        onParameter: (parameter, paramableSchema) => {
-            const value = config.lookupBinding(parameter, paramableSchema);
-            return value != null ? value : parameter;
-        },
-        walkObject: ({ 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) };
-}