@builder-builder/builder 0.0.6 → 0.0.8

package/dist/mappers/assert/model.js

@@ -0,0 +1,47 @@
+import * as v from 'valibot';
+import { BuilderException } from '../../exception.js';
+import { resolveCollection, resolveOption } from '../resolve.js';
+export function assertModel(builder, model) {
+    const errors = collectModelErrors(builder.options, builder.collections, model);
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+}
+function collectModelErrors(options, collections, model) {
+    const optionErrors = options.flatMap((entry) => {
+        const option = resolveOption(entry, model);
+        if (!option) {
+            return [];
+        }
+        const value = model[option.name];
+        if (!v.is(option.payload.valueSchema, value)) {
+            return [{ kind: 'invalid-option', name: option.name, value }];
+        }
+        return [];
+    });
+    const collectionErrors = collections.flatMap((entry) => {
+        const collection = resolveCollection(entry, model);
+        if (!collection) {
+            return [];
+        }
+        const existing = model[collection.name];
+        if (!Array.isArray(existing)) {
+            return [
+                {
+                    kind: 'invalid-collection',
+                    name: collection.name,
+                    detail: 'expected an array'
+                }
+            ];
+        }
+        const nestedBuilder = collection.payload.builder;
+        return existing.flatMap((itemModel, index) => {
+            const nestedErrors = collectModelErrors(nestedBuilder.options, nestedBuilder.collections, itemModel);
+            return nestedErrors.map((error) => ({
+                ...error,
+                name: `${collection.name}[${String(index)}].${error.name}`
+            }));
+        });
+    });
+    return [...optionErrors, ...collectionErrors];
+}

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

@@ -0,0 +1,33 @@
+import type { BuilderValidated } from '../../entities/index';
+import type { BuilderData, BuilderModel } from '../../model';
+export type BuilderErrorMissingComponent = {
+    readonly kind: 'missing-component';
+    readonly component: string;
+};
+export type BuilderErrorUnexpectedComponent = {
+    readonly kind: 'unexpected-component';
+    readonly component: string;
+};
+export type BuilderErrorMissingVariant = {
+    readonly kind: 'missing-variant';
+    readonly component: string;
+    readonly model: BuilderModel;
+};
+export type BuilderErrorInvalidVariant = {
+    readonly kind: 'invalid-variant';
+    readonly component: string;
+    readonly model: BuilderModel;
+};
+export type BuilderErrorMissingDetail = {
+    readonly kind: 'missing-detail';
+    readonly component: string;
+    readonly detail: string;
+    readonly model: BuilderModel;
+};
+export type BuilderErrorUnexpectedDetail = {
+    readonly kind: 'unexpected-detail';
+    readonly component: string;
+    readonly detail: string;
+    readonly model: BuilderModel;
+};
+export declare function assertModels(builder: BuilderValidated, builderData: BuilderData): void;

package/dist/mappers/assert/models.js

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

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

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

@@ -0,0 +1,7 @@
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './assert/index';
+export type { BuilderOrder } from './order/index';
+export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './render/index';
+export { createInstance } from './instance/index.js';
+export { createModels } from './models/index.js';
+export { order } from './order/index.js';
+export { ordinal, render } from './render/index.js';

package/dist/mappers/index.js

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

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

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

package/dist/mappers/instance/index.js

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

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

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

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

@@ -0,0 +1,9 @@
+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/{core/component/graph.js → mappers/models/component-graph.js}

@@ -1,6 +1,5 @@
 import { check } from '../../check.js';
-import { crossProduct } from '../graph.js';
-import { BuilderComponent } from './component.js';
+import { crossProduct, dependencyKeys } from './graph.js';
 export class BuilderComponentGraph {
     paths;
     constructor(paths = []) {
@@ -8,7 +7,8 @@ export class BuilderComponentGraph {
     }
     add(component, options) {
         check.falsy(this.#has(component.name), `Duplicate component name '${component.name}'! ❌`);
-        const keys = new Set(component.paths.map(([first]) => String(first)));
+        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]);

package/dist/{core → mappers/models}/graph.d.ts

@@ -1,4 +1,6 @@
-import type { BuilderModels } from '../model';
+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;
@@ -7,3 +9,4 @@ export type GraphPath = {
 };
 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

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

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

package/dist/mappers/models/index.js

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

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

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

package/dist/mappers/models/models.js

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

@@ -0,0 +1,9 @@
+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/models/option-graph.js

@@ -0,0 +1,77 @@
+import { check } from '../../check.js';
+import { resolveOption } from '../resolve.js';
+import { crossProduct, dependencyKeys } from './graph.js';
+export class BuilderOptionGraph {
+    paths;
+    constructor(paths = []) {
+        this.paths = paths;
+    }
+    get(name) {
+        const graphPath = this.paths.find((graphPath) => graphPath.name === name);
+        check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
+        return graphPath;
+    }
+    add(option) {
+        check.falsy(this.#has(option.name), `Duplicate option name '${option.name}'! ❌`);
+        const { gatePaths, payload } = option;
+        const optionDependencyKeys = dependencyKeys(payload, gatePaths);
+        if (optionDependencyKeys.length === 0) {
+            const resolved = resolveOption(option, {});
+            check.truthy(resolved, `Option '${option.name}' without dependencies must resolve! ❌`);
+            const values = this.#optionValues(resolved.name, resolved.payload);
+            return new BuilderOptionGraph([
+                ...this.paths,
+                {
+                    name: option.name,
+                    keys: new Set(),
+                    models: values.map((value) => ({ [option.name]: value }))
+                }
+            ]);
+        }
+        const merged = this.#mergePaths(new Set(optionDependencyKeys), this.paths);
+        const finalModels = [];
+        merged.models.forEach((model) => {
+            const result = resolveOption(option, model);
+            if (result) {
+                this.#optionValues(result.name, result.payload).forEach((value) => {
+                    finalModels.push({ ...model, [result.name]: value });
+                });
+            }
+            else {
+                finalModels.push({ ...model });
+            }
+        });
+        return new BuilderOptionGraph([
+            ...this.paths,
+            { name: option.name, keys: merged.keys, models: finalModels }
+        ]);
+    }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
+    #mergePaths(dependencyKeys, graphPaths) {
+        const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
+            const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
+            check.truthy(dependencyPath, `Option dependency '${dependencyKey}' not found in graph! ❌`);
+            return dependencyPath;
+        });
+        const [first, ...rest] = dependencyPaths;
+        return rest.reduce((merged, next) => {
+            const keys = new Set([...merged.keys, ...next.keys, next.name]);
+            const models = crossProduct(next.models, merged.models);
+            return { keys, models };
+        }, { keys: new Set([...first.keys, first.name]), models: first.models });
+    }
+    #optionValues(name, values) {
+        if (values.type === 'select') {
+            return [...values.options];
+        }
+        if (values.valueType === 'boolean') {
+            return values.isOptional ? [true, false, null] : [true, false];
+        }
+        if (values.valueType === 'string') {
+            return values.isOptional ? [name, null] : [name];
+        }
+        return values.isOptional ? [1, null] : [1];
+    }
+}

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

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

package/dist/mappers/order/index.js

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

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

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

@@ -0,0 +1,31 @@
+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/render/index.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderUpdate } from './pages';
+export type { BuilderRenderResult } from './render';
+export { render } from './render.js';
+export { ordinal } from './ordinal.js';

package/dist/mappers/render/index.js

@@ -0,0 +1,2 @@
+export { render } from './render.js';
+export { ordinal } from './ordinal.js';

package/dist/mappers/render/ordinal.d.ts

@@ -0,0 +1 @@
+export declare function ordinal(index: number): string;

package/dist/mappers/render/ordinal.js

@@ -0,0 +1,20 @@
+export function ordinal(index) {
+    return ordinals[index] ?? `${index + 1}`;
+}
+const ordinals = [
+    'First',
+    'Second',
+    'Third',
+    'Fourth',
+    'Fifth',
+    'Sixth',
+    'Seventh',
+    'Eighth',
+    'Ninth',
+    'Tenth',
+    'Eleventh',
+    'Twelfth',
+    'Thirteenth',
+    'Fourteenth',
+    'Fifteenth'
+];

package/dist/mappers/render/pages.d.ts

@@ -0,0 +1,15 @@
+import type { BuilderOptionValues } from '../../entities/index';
+import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderModel } from '../../model';
+export type BuilderRenderUpdate = (model: BuilderModel, primitive: BuilderPrimitive) => BuilderModel;
+export type BuilderRenderOption = Readonly<{
+    value: BuilderPrimitive;
+    update: BuilderRenderUpdate;
+    option: BuilderOptionValues;
+}>;
+export type BuilderRenderOptions = ReadonlyArray<BuilderRenderOption>;
+export type BuilderRenderPage = Readonly<{
+    label: string;
+    options: BuilderRenderOptions;
+}>;
+export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;

package/dist/mappers/render/pages.js

@@ -0,0 +1 @@
+export {};

package/dist/mappers/render/render.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderDescription, BuilderUIGeneric } from '../../entities/index';
+import type { BuilderModel } from '../../model';
+import type { BuilderRenderPages } from './pages';
+export type BuilderRenderResult = Readonly<{
+    layout: BuilderRenderPages;
+    description: BuilderDescription;
+}>;
+export declare function render(ui: BuilderUIGeneric, rootModel: BuilderModel): BuilderRenderResult;