@builder-builder/builder 0.0.9 → 0.0.11

package/dist/mappers/assert/models.js

@@ -1,74 +0,0 @@
-import { check } from '../../check.js';
-import { BuilderComponentDetailsSchema } from '../../entities/index.js';
-import { BuilderException } from '../../exception.js';
-import { createModels } from '../models/index.js';
-export function assertModels(builder, builderData) {
-    const expected = createModels(builder);
-    const errors = [];
-    Object.entries(expected).forEach(([component, expectedModels]) => {
-        const componentModels = builderData[component];
-        if (!componentModels) {
-            errors.push({ kind: 'missing-component', component });
-            return;
-        }
-        const expectedKeys = new Map(expectedModels.map((variant) => [sortedKey(variant.model), variant.model]));
-        const actualKeys = new Set();
-        componentModels.forEach((variant) => {
-            const key = sortedKey(variant.model);
-            actualKeys.add(key);
-            if (!expectedKeys.has(key)) {
-                errors.push({ kind: 'invalid-variant', component, model: variant.model });
-            }
-        });
-        expectedKeys.forEach((model, key) => {
-            if (!actualKeys.has(key)) {
-                errors.push({ kind: 'missing-variant', component, model });
-            }
-        });
-    });
-    Object.keys(builderData).forEach((component) => {
-        if (!expected[component]) {
-            errors.push({ kind: 'unexpected-component', component });
-        }
-    });
-    const detailExpectations = new Map(builder.components.map((entry) => {
-        const details = componentDetailNames(entry);
-        return [entry.name, new Set(details)];
-    }));
-    Object.entries(builderData).forEach(([component, variants]) => {
-        const expectedDetails = detailExpectations.get(component);
-        if (!expectedDetails || expectedDetails.size === 0) {
-            return;
-        }
-        variants.forEach((variant) => {
-            const actualDetails = new Set(Object.keys(variant.details ?? {}));
-            expectedDetails.forEach((detail) => {
-                if (!actualDetails.has(detail)) {
-                    errors.push({ kind: 'missing-detail', component, detail, model: variant.model });
-                }
-            });
-            actualDetails.forEach((detail) => {
-                if (!expectedDetails.has(detail)) {
-                    errors.push({ kind: 'unexpected-detail', component, detail, model: variant.model });
-                }
-            });
-        });
-    });
-    if (errors.length > 0) {
-        throw new BuilderException(errors);
-    }
-}
-function componentDetailNames(component) {
-    const { payload } = component;
-    if (check.is(BuilderComponentDetailsSchema, payload)) {
-        return payload.expectations.map((expectation) => expectation.name);
-    }
-    if (payload.type === 'match') {
-        return [];
-    }
-    return payload.payload.expectations.map((expectation) => expectation.name);
-}
-function sortedKey(model) {
-    const entries = Object.entries(model).filter(([, value]) => value != null);
-    return JSON.stringify(entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
-}

package/dist/mappers/assert/ui.d.ts

@@ -1,2 +0,0 @@
-import type { BuilderUIGeneric, Strip } from '../../entities/index';
-export declare function assertUI<UI extends BuilderUIGeneric>(ui: UI): asserts ui is UI & Strip<UI>;

package/dist/mappers/assert/ui.js

@@ -1,22 +0,0 @@
-import { BuilderUISerialisedSchema } from '../../entities/index.js';
-import { BuilderException } from '../../exception.js';
-import { isRef } 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((ref) => {
-        parameterErrors.push({ kind: 'unbound-parameter', name: ref.name });
-    });
-    walkValidate(BuilderUISerialisedSchema, ui);
-    const expectationErrors = isRef(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/model.d.ts

@@ -1,14 +0,0 @@
-import type { BuilderPrimitive } from './primitive';
-export type BuilderModel = {
-    readonly [key: string]: BuilderPrimitive | BuilderModels;
-};
-export type BuilderModels = ReadonlyArray<BuilderModel>;
-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/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,18 +0,0 @@
-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

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

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

@@ -1,51 +0,0 @@
-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) };
-}