@builder-builder/builder 0.0.1

package/dist/core/option/graph.d.ts

@@ -0,0 +1,11 @@
+import type { GraphPath, GraphPaths } from '../graph';
+import { BuilderOption } from './option.js';
+export type BuilderOptionGraphs = ReadonlyArray<BuilderOptionGraph>;
+export declare class BuilderOptionGraph {
+    readonly paths: GraphPaths;
+    constructor(paths?: GraphPaths);
+    static merge(...graphs: BuilderOptionGraphs): BuilderOptionGraph;
+    has(name: string): boolean;
+    get(name: string): GraphPath;
+    add(option: BuilderOption): BuilderOptionGraph;
+}

package/dist/core/option/graph.js

@@ -0,0 +1,78 @@
+import * as v from 'valibot';
+import { invariant } from '../../invariant.js';
+import { BuilderOption } from './option.js';
+import { BuilderSelectType } from './select.js';
+export class BuilderOptionGraph {
+    paths;
+    constructor(paths = []) {
+        this.paths = paths;
+    }
+    static merge(...graphs) {
+        return new BuilderOptionGraph(graphs.flatMap((graph) => graph.paths));
+    }
+    has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
+    get(name) {
+        const graphPath = this.paths.find((graphPath) => graphPath.name === name);
+        invariant(graphPath, `Option '${name}' not found in graph! ❌`);
+        return graphPath;
+    }
+    add(option) {
+        const dependencyKeys = option.dependencyKeys();
+        if (dependencyKeys.length === 0) {
+            const values = optionValues(option);
+            return new BuilderOptionGraph([
+                ...this.paths,
+                {
+                    name: option.name,
+                    keys: new Set(),
+                    models: values.map((value) => ({ [option.name]: value }))
+                }
+            ]);
+        }
+        const merged = mergePaths(new Set(dependencyKeys), this.paths);
+        const finalModels = [];
+        merged.models.forEach((model) => {
+            const result = option.resolve(model);
+            if (result) {
+                optionValues(result).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 }
+        ]);
+    }
+}
+function mergePaths(dependencyKeys, graphPaths) {
+    const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
+        const dependencyPath = graphPaths.find((graphPath) => graphPath.name === dependencyKey);
+        invariant(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 = next.models.flatMap((nextModel) => merged.models.map((mergedModel) => ({ ...nextModel, ...mergedModel })));
+        return { keys, models };
+    }, { keys: new Set([...first.keys, first.name]), models: first.models });
+}
+function optionValues(option) {
+    const values = option.values;
+    if (v.is(v.instance(BuilderSelectType), values)) {
+        return [...values.options];
+    }
+    if (values.valueSchema.expects.includes('boolean')) {
+        return values.isOptional ? [true, false, null] : [true, false];
+    }
+    if (values.valueSchema.expects.includes('string')) {
+        return values.isOptional ? [option.name, null] : [option.name];
+    }
+    return values.isOptional ? [1, null] : [1];
+}

package/dist/core/option/index.d.ts

@@ -0,0 +1,9 @@
+export type { BuilderOptionEnableConfig, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionWhenConfig } from './method';
+export type { BuilderOptionGraphs } from './graph';
+export type { BuilderOptionEntries, BuilderOptionValues, BuilderSelectTypeGeneric, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option';
+export type { BuilderSelectTypeLabels, BuilderSelectTypeValues } from './select';
+export { enable, match, unless } from './method.js';
+export { BuilderOptionGraph } from './graph.js';
+export { BuilderOption } from './option.js';
+export { select, BuilderSelectType } from './select.js';
+export { BuilderToggleType, toggleBoolean, toggleNumber, toggleString } from './toggle.js';

package/dist/core/option/index.js

@@ -0,0 +1,5 @@
+export { enable, match, unless } from './method.js';
+export { BuilderOptionGraph } from './graph.js';
+export { BuilderOption } from './option.js';
+export { select, BuilderSelectType } from './select.js';
+export { BuilderToggleType, toggleBoolean, toggleNumber, toggleString } from './toggle.js';

package/dist/core/option/method.d.ts

@@ -0,0 +1,52 @@
+import type { BuilderPrimitive } from '../../config';
+import type { BuilderPath, BuilderPaths, BuilderResolvePath, BuilderValidPath } from '../../paths';
+import type { BuilderStateMerge, BuilderState } from '../builder';
+import type { Builder } from '../builder';
+import type { BuilderOptionValues } from './option';
+import type { BuilderOption } from './option';
+export type BuilderOptionEnableConfig<Values extends BuilderOptionValues = BuilderOptionValues> = {
+    readonly type: 'enable';
+    readonly values: Values;
+};
+export type BuilderOptionMatchConfig<SelectMap extends Record<string, BuilderOptionValues | null> = Record<string, BuilderOptionValues | null>, MatchPath extends BuilderPath = BuilderPath> = {
+    readonly type: 'match';
+    readonly matchPath: MatchPath;
+    readonly selectMap: SelectMap;
+};
+export type BuilderOptionUnlessConfig<Values extends BuilderOptionValues = BuilderOptionValues, UnlessPath extends BuilderPath = BuilderPath> = {
+    readonly type: 'unless';
+    readonly unlessPath: UnlessPath;
+    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
+    readonly values: Values;
+};
+export type BuilderOptionWhenConfig = BuilderOptionEnableConfig<BuilderOptionValues> | BuilderOptionMatchConfig<Record<string, BuilderOptionValues | null>> | BuilderOptionUnlessConfig<BuilderOptionValues>;
+export type BuilderOptionWhenConfigValues<Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionEnableConfig<infer Values> ? Values : Config extends BuilderOptionUnlessConfig<infer Values> ? Values : Config extends BuilderOptionMatchConfig<infer SelectMapType> ? NonNullable<SelectMapType[keyof SelectMapType]> & BuilderOptionValues : never;
+export type BuilderOptionMethod<State extends BuilderState> = {
+    <const Name extends string, const Values extends BuilderOptionValues>(name: Name, values: Values): Builder<BuilderStateMerge<State, {
+        model: State['model'] & {
+            [K in Name]: Values['value'];
+        };
+        options: [...State['options'], BuilderOption<Name, Values>];
+    }>>;
+    when: <const GatePaths extends ReadonlyArray<BuilderValidPath<State['model']>>, const Name extends string, const Config extends BuilderOptionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & WhenConfigConstrained<State['model'], Config>) => Builder<BuilderStateMerge<State, {
+        model: State['model'] & {
+            [K in Name]: BuilderOptionWhenConfigValues<Config>['value'] | OptionWhenNullability<State['model'], GatePaths, Config>;
+        };
+        options: [...State['options'], BuilderOption<Name, BuilderOptionWhenConfigValues<Config>>];
+    }>>;
+};
+export declare function enable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
+export declare function match<const MatchPath extends BuilderPath, const SelectMap extends Record<string, BuilderOptionValues | null>>(matchPath: MatchPath, selectMap: SelectMap): BuilderOptionMatchConfig<SelectMap, MatchPath>;
+export declare function unless<const Values extends BuilderOptionValues, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, values: Values): BuilderOptionUnlessConfig<Values, UnlessPath>;
+type OptionConfigNullable<Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionUnlessConfig ? null : Config extends BuilderOptionMatchConfig<infer SelectMapType> ? null extends SelectMapType[keyof SelectMapType] ? null : never : never;
+type OptionGatePathNullable<Model, Path extends BuilderPath> = null extends BuilderResolvePath<Model, Path> ? null : never;
+type OptionGatePathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
+    infer Head extends BuilderPath,
+    ...infer Tail extends BuilderPaths
+] ? OptionGatePathNullable<Model, Head> | OptionGatePathsNullable<Model, Tail> : never;
+type OptionWhenNullability<Model, GatePaths extends BuilderPaths, Config extends BuilderOptionWhenConfig> = OptionGatePathsNullable<Model, GatePaths> | OptionConfigNullable<Config>;
+type MatchKeyOfConfig<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<any, infer MatchPath> ? BuilderResolvePath<Model, MatchPath> & string : string;
+type WhenConfigConstrained<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<any, infer MatchPath> ? BuilderOptionMatchConfig<Record<MatchKeyOfConfig<Model, Config>, BuilderOptionValues | null>, MatchPath & Readonly<BuilderValidPath<Model>>> : Config extends BuilderOptionUnlessConfig ? Config & {
+    readonly unlessPath: Readonly<BuilderValidPath<Model>>;
+} : Config;
+export {};

package/dist/core/option/method.js

@@ -0,0 +1,9 @@
+export function enable(values) {
+    return { type: 'enable', values };
+}
+export function match(matchPath, selectMap) {
+    return { type: 'match', matchPath, selectMap };
+}
+export function unless(unlessPath, disabledValues, values) {
+    return { type: 'unless', unlessPath, disabledValues, values };
+}

package/dist/core/option/option.d.ts

@@ -0,0 +1,22 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderOptionWhenConfig } from './method';
+import type { BuilderSelectType, BuilderSelectTypeValues } from './select';
+import type { BuilderToggleType } from './toggle';
+import * as v from 'valibot';
+export type BuilderOptionValueSchema = v.GenericSchema<string | number | boolean | null>;
+export type BuilderSelectTypeGeneric = BuilderSelectType<BuilderSelectTypeValues, BuilderOptionValueSchema>;
+export type BuilderToggleTypeGeneric = BuilderToggleType<BuilderOptionValueSchema>;
+export type BuilderOptionValues = BuilderSelectTypeGeneric | BuilderToggleTypeGeneric;
+export type BuilderOptionEntries = ReadonlyArray<BuilderOption>;
+export declare class BuilderOption<const Name extends string = string, const Values extends BuilderOptionValues = BuilderOptionValues> {
+    readonly model: {
+        [K in Name]: Values['value'];
+    };
+    readonly name: Name;
+    readonly values: Values;
+    readonly gatePaths: BuilderPaths;
+    readonly config: BuilderOptionWhenConfig | null;
+    constructor(name: Name, values: Values, gatePaths?: BuilderPaths, config?: BuilderOptionWhenConfig | null);
+    resolve(model: unknown): BuilderOption<Name> | null;
+    dependencyKeys(): ReadonlyArray<string>;
+}

package/dist/core/option/option.js

@@ -0,0 +1,49 @@
+import * as v from 'valibot';
+import { readPath } from '../../paths.js';
+export class BuilderOption {
+    name;
+    values;
+    gatePaths;
+    config;
+    constructor(name, values, gatePaths = [], config = null) {
+        this.name = name;
+        this.values = values;
+        this.gatePaths = gatePaths;
+        this.config = config;
+    }
+    resolve(model) {
+        if (this.config === null) {
+            return this;
+        }
+        if (!this.gatePaths.every((path) => !!readPath(model, path))) {
+            return null;
+        }
+        switch (this.config.type) {
+            case 'enable': {
+                return this;
+            }
+            case 'match': {
+                const matchPath = this.config.matchPath;
+                const entry = this.config.selectMap[String(readPath(model, matchPath))];
+                return entry ? new BuilderOption(this.name, entry) : null;
+            }
+            case 'unless': {
+                const value = readPath(model, this.config.unlessPath);
+                return !this.config.disabledValues.includes(value)
+                    ? this
+                    : null;
+            }
+        }
+    }
+    dependencyKeys() {
+        const keys = new Set(this.gatePaths.map((path) => String(path[0])));
+        if (this.config?.type === 'match') {
+            const matchPath = this.config.matchPath;
+            keys.add(String(matchPath[0]));
+        }
+        else if (this.config?.type === 'unless') {
+            keys.add(String(this.config.unlessPath[0]));
+        }
+        return Array.from(keys);
+    }
+}

package/dist/core/option/select.d.ts

@@ -0,0 +1,17 @@
+import type { BuilderOptionValueSchema } from './option';
+import * as v from 'valibot';
+export type BuilderSelectTypeValues = readonly [string, ...ReadonlyArray<string>];
+export type BuilderSelectTypeLabels<Values extends BuilderSelectTypeValues> = Partial<Record<Values[number], string>>;
+export declare class BuilderSelectType<const Values extends BuilderSelectTypeValues = BuilderSelectTypeValues, const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly options: Values;
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    readonly optionLabels: BuilderSelectTypeLabels<Values>;
+    constructor(values: Values, valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectType<Values, ValueSchema>;
+    optional(): BuilderSelectType<Values, v.NullableSchema<ValueSchema, undefined>>;
+    labels(optionLabels: BuilderSelectTypeLabels<Values>): BuilderSelectType<Values, ValueSchema>;
+}
+export declare function select<const Values extends BuilderSelectTypeValues>(values: Values): BuilderSelectType<Values, v.UnionSchema<v.LiteralSchema<Values[number], undefined>[], undefined>>;

package/dist/core/option/select.js

@@ -0,0 +1,30 @@
+import * as v from 'valibot';
+export class BuilderSelectType {
+    options;
+    valueSchema;
+    defaultValue;
+    isOptional;
+    optionLabels;
+    constructor(values, valueSchema, defaultValue, optional = false, optionLabels = {}) {
+        this.options = values;
+        this.valueSchema = valueSchema;
+        this.defaultValue = defaultValue;
+        this.isOptional = optional;
+        this.optionLabels = optionLabels;
+    }
+    default(newDefault) {
+        return new BuilderSelectType(this.options, this.valueSchema, newDefault, this.isOptional, this.optionLabels);
+    }
+    optional() {
+        const { options, defaultValue } = this;
+        return new BuilderSelectType(options, v.nullable(this.valueSchema), defaultValue, true, this.optionLabels);
+    }
+    labels(optionLabels) {
+        return new BuilderSelectType(this.options, this.valueSchema, this.defaultValue, this.isOptional, optionLabels);
+    }
+}
+export function select(values) {
+    const [defaultValue] = values;
+    const valueSchema = v.union(values.map((value) => v.literal(value)));
+    return new BuilderSelectType(values, valueSchema, defaultValue, false);
+}

package/dist/core/option/toggle.d.ts

@@ -0,0 +1,14 @@
+import type { BuilderOptionValueSchema } from './option';
+import * as v from 'valibot';
+export declare class BuilderToggleType<const ValueSchema extends BuilderOptionValueSchema = BuilderOptionValueSchema> {
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    constructor(valueSchema: ValueSchema, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
+    optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
+}
+export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
+export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
+export declare function toggleNumber(): BuilderToggleType<v.NumberSchema<undefined>>;

package/dist/core/option/toggle.js

@@ -0,0 +1,27 @@
+import * as v from 'valibot';
+export class BuilderToggleType {
+    valueSchema;
+    defaultValue;
+    isOptional;
+    constructor(valueSchema, defaultValue, optional) {
+        this.valueSchema = valueSchema;
+        this.defaultValue = defaultValue;
+        this.isOptional = optional || false;
+    }
+    default(newDefault) {
+        return new BuilderToggleType(this.valueSchema, newDefault, this.isOptional);
+    }
+    optional() {
+        const { valueSchema, defaultValue } = this;
+        return new BuilderToggleType(v.nullable(valueSchema), defaultValue, true);
+    }
+}
+export function toggleString() {
+    return new BuilderToggleType(v.string(), '');
+}
+export function toggleBoolean() {
+    return new BuilderToggleType(v.boolean(), false);
+}
+export function toggleNumber() {
+    return new BuilderToggleType(v.number(), 0);
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { BuilderModelAsserted, BuilderUIModelAsserted } from './assert/assert';
+export type { BuilderExpectations } from './assert/index';
+export type { BuilderData, BuilderModel, BuilderModelMutable, BuilderModels, BuilderPrimitive, BuilderPrimitives, BuilderVariant, BuilderVariants } from './config';
+export type { Builder, BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderComponentEntries, BuilderComponentNamesOf, BuilderFactory, BuilderGeneric, BuilderModelOf, BuilderOptionEntries, BuilderOptionValues, BuilderPart, BuilderParts, BuilderSelectTypeLabels, BuilderSelectTypeValues, BuilderState, BuilderStateOf } from './core/index';
+export type { BuilderModelPaths, BuilderResolvePath, BuilderValidPath } from './paths';
+export type { BuilderPath, BuilderPaths } from './schemas/index';
+export type { BuilderDataValidated, BuilderDescription, BuilderDescriptionItem, BuilderErrorComponentMissing, BuilderErrorComponentUnexpected, BuilderErrorsValidate, BuilderErrorValidate, BuilderErrorVariantInvalid, BuilderErrorVariantMissing, BuilderLayout, BuilderLayoutOption, BuilderLayoutOptions, BuilderLayoutPage, BuilderOrder, BuilderRenderLayoutOption, BuilderRenderLayoutOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderValidateResult } from './resolve/index';
+export type { BuilderUICollection, BuilderUIDescribe, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './schemas/index';
+export type { BuilderUI, BuilderUIFactory, BuilderUIPart, BuilderUIParts } from './ui';
+export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
+export { BuilderExpectation } from './assert/expectation.js';
+export { assert, component, option } from './assert/index.js';
+export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
+export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
+export { deserialise, serialise } from './serialise/index.js';
+export { ui } from './ui.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { BuilderExpectation } from './assert/expectation.js';
+export { assert, component, option } from './assert/index.js';
+export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
+export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
+export { deserialise, serialise } from './serialise/index.js';
+export { ui } from './ui.js';

package/dist/invariant.d.ts

@@ -0,0 +1 @@
+export declare function invariant<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;

package/dist/invariant.js

@@ -0,0 +1,6 @@
+const DEFAULT_INVARIANT_MESSAGE = 'Unexpected falsy value! ❌';
+export function invariant(input, message = DEFAULT_INVARIANT_MESSAGE) {
+    if (!input) {
+        throw new Error(message);
+    }
+}

package/dist/paths.d.ts

@@ -0,0 +1,14 @@
+export type { BuilderPath, BuilderPaths } from './schemas/index';
+import type { BuilderGeneric, BuilderModelOf } from './core/index';
+import type { BuilderPath, BuilderPrimitive } 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]>] : {
+    [K in keyof Model & string]: [K] | (Model[K] extends BuilderPrimitive | null ? never : [K, ...BuilderValidPath<Model[K], [...Depth, never]>]);
+}[keyof Model & string];
+export type BuilderModelPaths<B extends BuilderGeneric> = ReadonlyArray<BuilderValidPath<BuilderModelOf<B>>>;
+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;
+export declare function readPath(model: unknown, path: BuilderPath): unknown;

package/dist/paths.js

@@ -0,0 +1,8 @@
+export function readPath(model, path) {
+    return path.reduce((current, segment) => {
+        if (current == null) {
+            return null;
+        }
+        return current[segment];
+    }, model);
+}

package/dist/prettify.d.ts

@@ -0,0 +1,3 @@
+export type Prettify<Input> = {
+    [Key in keyof Input]: Input[Key];
+} & {};

package/dist/prettify.js

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

package/dist/resolve/index.d.ts

@@ -0,0 +1,9 @@
+export type { BuilderOrder } from './order';
+export type { BuilderRenderLayoutOption, BuilderRenderLayoutOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render';
+export type { BuilderDataValidated, BuilderErrorVariantInvalid, BuilderErrorComponentMissing, BuilderErrorVariantMissing, BuilderErrorComponentUnexpected, BuilderErrorValidate, BuilderErrorsValidate, BuilderValidateResult } from './validate';
+export type { BuilderDescription, BuilderDescriptionItem, BuilderLayout, BuilderLayoutOption, BuilderLayoutOptions, BuilderLayoutPage } from '../schemas/index';
+export { instance } from './instance.js';
+export { models } from './models.js';
+export { order } from './order.js';
+export { ordinal, render } from './render.js';
+export { validate } from './validate.js';

package/dist/resolve/index.js

@@ -0,0 +1,5 @@
+export { instance } from './instance.js';
+export { models } from './models.js';
+export { order } from './order.js';
+export { ordinal, render } from './render.js';
+export { validate } from './validate.js';

package/dist/resolve/instance.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderGeneric, BuilderModelOf } from '../core/index';
+import type { BuilderModelMutable } from '../config';
+export declare function instance<const B extends BuilderGeneric>(builder: B, partial?: BuilderModelMutable): BuilderModelOf<B>;

package/dist/resolve/instance.js

@@ -0,0 +1,26 @@
+import * as v from 'valibot';
+import { resolveCollectionModels } from '../core/index.js';
+export function instance(builder, partial = {}) {
+    const model = partial;
+    builder.options.forEach((entry) => {
+        const option = entry.resolve(model);
+        if (!option) {
+            return;
+        }
+        if (!v.is(option.values.valueSchema, model[option.name])) {
+            model[option.name] = option.values.defaultValue;
+        }
+    });
+    builder.collections.forEach((entry) => {
+        const collection = entry.resolve(model);
+        if (!collection) {
+            return;
+        }
+        const existing = model[collection.name];
+        const collectionModels = existing != null ? resolveCollectionModels(model, collection.name) : [];
+        model[collection.name] = Array.from({
+            length: Math.max(collectionModels.length, collection.min)
+        }).map((_, index) => instance(collection.builder, collectionModels[index] || {}));
+    });
+    return model;
+}

package/dist/resolve/models.d.ts

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

package/dist/resolve/models.js

@@ -0,0 +1,10 @@
+export function models(builder) {
+    const collectionModels = builder.collections.flatMap((entry) => {
+        return [models(entry.builder)];
+    });
+    const wrapped = Object.fromEntries(builder.componentGraph.paths.map((path) => [path.name, path.models.map((model) => ({ model }))]));
+    return {
+        ...collectionModels.reduce((merged, component) => ({ ...merged, ...component }), {}),
+        ...wrapped
+    };
+}

package/dist/resolve/order.d.ts

@@ -0,0 +1,18 @@
+import type { BuilderModel, BuilderVariant } from '../config';
+import type { BuilderCollection, BuilderCollectionEntries, BuilderComponentEntries, BuilderComponentNamesOf, BuilderGeneric, BuilderTupleOf } from '../core/index';
+import type { BuilderDataValidated } from './validate';
+export type BuilderOrder<B extends BuilderGeneric> = B extends {
+    readonly _components: infer Components extends BuilderComponentEntries;
+    readonly _collections: infer Collections extends BuilderCollectionEntries;
+} ? Prettify<ComponentsOrder<Components> & CollectionsOrder<Collections>> : Record<string, unknown>;
+export declare function order<const B extends BuilderGeneric>(builder: B, model: BuilderModel, componentModels: BuilderDataValidated): BuilderOrder<B>;
+import type { Prettify } from '../prettify';
+type ComponentsOrder<Components extends BuilderComponentEntries> = {
+    readonly [Name in BuilderComponentNamesOf<Components>]: BuilderVariant | null;
+};
+type CollectionsOrder<Collections extends BuilderCollectionEntries> = Collections extends readonly [
+    infer Head extends BuilderCollection,
+    ...infer Tail extends BuilderCollectionEntries
+] ? Record<Head['name'], CollectionOrderOf<Head>> & CollectionsOrder<Tail> : {};
+type CollectionOrderOf<Input extends BuilderCollection> = Input extends BuilderCollection<any, infer CollectionRecipe extends BuilderGeneric, infer Min, infer Max> ? number extends Min ? ReadonlyArray<BuilderOrder<CollectionRecipe>> : number extends Max ? ReadonlyArray<BuilderOrder<CollectionRecipe>> : Min extends Max ? BuilderTupleOf<BuilderOrder<CollectionRecipe>, Min> : ReadonlyArray<BuilderOrder<CollectionRecipe>> : ReadonlyArray<Record<string, unknown>>;
+export {};

package/dist/resolve/order.js

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

package/dist/resolve/render.d.ts

@@ -0,0 +1,21 @@
+import type { BuilderGeneric, BuilderOption } from '../core/index';
+import type { BuilderModel } from '../config';
+import type { BuilderDescription, BuilderUIItems, BuilderPrimitive } from '../schemas/index';
+import { BuilderUI } from '../ui.js';
+export type BuilderRenderLayoutOption = {
+    readonly value: BuilderPrimitive | null;
+    update(model: BuilderModel, value: BuilderPrimitive | null): BuilderModel;
+    readonly option: BuilderOption;
+};
+export type BuilderRenderLayoutOptions = ReadonlyArray<BuilderRenderLayoutOption>;
+export type BuilderRenderPage = {
+    readonly label: string | null;
+    readonly options: BuilderRenderLayoutOptions;
+};
+export type BuilderRenderPages = ReadonlyArray<BuilderRenderPage>;
+export type BuilderRenderResult = {
+    readonly layout: BuilderRenderPages;
+    readonly description: BuilderDescription;
+};
+export declare function render(rootBuilder: BuilderGeneric, rootModel: BuilderModel, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
+export declare function ordinal(index: number): string;