@builder-builder/builder 0.0.3 → 0.0.5

package/dist/core/graph.d.ts

@@ -1,4 +1,4 @@
-import type { BuilderModels } from '../config';
+import type { BuilderModels } from '../model';
 export type GraphKeys = ReadonlySet<string>;
 export type GraphPath = {
     name: string;
@@ -6,3 +6,4 @@ export type GraphPath = {
     models: BuilderModels;
 };
 export type GraphPaths = ReadonlyArray<GraphPath>;
+export declare function crossProduct(left: BuilderModels, right: BuilderModels): BuilderModels;

package/dist/core/graph.js

@@ -1 +1,3 @@
-export {};
+export function crossProduct(left, right) {
+    return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));
+}

package/dist/core/index.d.ts

@@ -1,8 +1,12 @@
-export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig, BuilderTupleOf } from './collection/index';
+export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './collection/index';
 export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentMethod, BuilderComponentNamesOf } from './component/index';
-export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionGraphs, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionValuesMap, BuilderOptionWhenConfig, BuilderSelectTypeGeneric, BuilderSelectTypeLabels, BuilderSelectTypeValues, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option/index';
-export type { BuilderStateMerge, BuilderFactory, BuilderGeneric, BuilderModelOf, BuilderPart, BuilderParts, BuilderState, BuilderStateEmpty, BuilderStateOf, BuilderSelectMap, BuilderSelectMapGeneric } from './builder';
+export type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAsserted } from './expectation';
+export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionValuesMap, BuilderOptionWhenConfig, BuilderSelectTypeLabels, BuilderSelectTypeValues } from './option/index';
+export type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig } from './when/index';
+export type { BuilderMerge, BuilderGeneric, BuilderModelOf, Builders, BuilderState, BuilderStateEmpty, BuilderStateOf } from './builder';
+export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
+export { BuilderExpectation, component, option } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
-export { Builder, builder } from './builder.js';
+export { BuilderParameter, BuilderParameterSchema } from './parameter.js';

package/dist/core/index.js

@@ -1,4 +1,6 @@
+export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
+export { BuilderExpectation, component, option } from './expectation.js';
 export { BuilderOption, BuilderOptionGraph, select, BuilderSelectType, BuilderToggleType, toggleBoolean, toggleNumber, toggleString, enable, match, unless } from './option/index.js';
-export { Builder, builder } from './builder.js';
+export { BuilderParameter, BuilderParameterSchema } from './parameter.js';

package/dist/core/option/graph.js

@@ -1,6 +1,7 @@
+import { crossProduct } from '../graph.js';
 import * as v from 'valibot';
-import { invariant } from '../../invariant.js';
-import { BuilderOption } from './option.js';
+import { check } from '../../check.js';
+import { BuilderOption, BuilderOptionValuesSchema } from './option.js';
 import { BuilderSelectType } from './select.js';
 export class BuilderOptionGraph {
     paths;
@@ -15,7 +16,7 @@ export class BuilderOptionGraph {
     }
     get(name) {
         const graphPath = this.paths.find((graphPath) => graphPath.name === name);
-        invariant(graphPath, `Option '${name}' not found in graph! ❌`);
+        check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
         return graphPath;
     }
     add(option) {
@@ -53,18 +54,19 @@ export class BuilderOptionGraph {
 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! ❌`);
+        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 = next.models.flatMap((nextModel) => merged.models.map((mergedModel) => ({ ...nextModel, ...mergedModel })));
+        const models = crossProduct(next.models, merged.models);
         return { keys, models };
     }, { keys: new Set([...first.keys, first.name]), models: first.models });
 }
 function optionValues(option) {
     const values = option.values;
+    check.assert(BuilderOptionValuesSchema, values);
     if (v.is(v.instance(BuilderSelectType), values)) {
         return [...values.options];
     }

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

@@ -1,52 +1,70 @@
-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, BuilderOptionValuesMap } 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 BuilderOptionValuesMap = BuilderOptionValuesMap, 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<BuilderOptionValuesMap> | 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;
+import type { BuilderPrimitive } from '../../model';
+import type { BuilderPath, BuilderResolvePath, BuilderValidPath, BuilderValidPaths } from '../../paths';
+import type { BuilderMerge, BuilderState } from '../builder';
+import type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig, WhenNullability, WhenPathsNullable } from '../when/index';
+import type { BuilderOption, BuilderOptionValueType, BuilderOptionValues, BuilderOptionValuesMap } from './option';
+import { BuilderParameter } from '../parameter.js';
+export type BuilderOptionEnableConfig<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> = BuilderWhenEnableConfig<OptionPayload<Values>>;
+export type BuilderOptionMatchConfig<SelectMap extends BuilderOptionValuesMap | BuilderParameter = BuilderOptionValuesMap | BuilderParameter, MatchPath extends BuilderPath = BuilderPath> = BuilderWhenMatchConfig<SelectMap, MatchPath>;
+export type BuilderOptionUnlessConfig<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter, UnlessPath extends BuilderPath = BuilderPath> = BuilderWhenUnlessConfig<OptionPayload<Values>, UnlessPath>;
+export type BuilderOptionWhenConfig = BuilderOptionEnableConfig | BuilderOptionMatchConfig | BuilderOptionUnlessConfig;
+export type BuilderOptionWhenConfigValues<Config extends BuilderOptionWhenConfig> = Config extends {
+    readonly values: infer Values;
+} ? Values extends BuilderOptionValues ? Values : never : Config extends BuilderOptionMatchConfig<infer SelectMapType> ? SelectMapType extends BuilderOptionValuesMap ? NonNullable<SelectMapType[keyof SelectMapType]> & BuilderOptionValues : never : never;
 export type BuilderOptionMethod<State extends BuilderState> = {
-    <const Name extends string, const Values extends BuilderOptionValues>(name: Name, values: Values): Builder<BuilderStateMerge<State, {
+    <const Name extends string, const Values extends BuilderOptionValues>(name: Name, values: Values): BuilderMerge<State, {
         model: State['model'] & {
-            [K in Name]: Values['value'];
+            [K in Name]: BuilderOptionValueType<Values>;
         };
         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, {
+    }>;
+    <const Name extends string>(name: Name, values: BuilderParameter): BuilderMerge<State, {
         model: State['model'] & {
-            [K in Name]: BuilderOptionWhenConfigValues<Config>['value'] | OptionWhenNullability<State['model'], GatePaths, Config>;
+            [K in Name]: string;
         };
-        options: [...State['options'], BuilderOption<Name, BuilderOptionWhenConfigValues<Config>>];
-    }>>;
+        options: [...State['options'], BuilderOption<Name, BuilderParameter>];
+    }>;
+    when: {
+        <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string>(gatePaths: GatePaths, name: Name, config: BuilderParameter): BuilderMerge<State, {
+            model: State['model'] & {
+                [K in Name]: string | WhenPathsNullable<State['model'], GatePaths>;
+            };
+            options: [...State['options'], BuilderOption<Name, BuilderParameter>];
+        }>;
+        <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string, const Config extends BuilderOptionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & ValidOptionWhenConfig<State['model'], Config>): BuilderMerge<State, OptionWhenResult<State, GatePaths, Name, Config>>;
+    };
+};
+export declare const enable: typeof createEnable & {
+    parameter: () => BuilderParameter;
+};
+export declare const match: typeof createMatch & {
+    parameter: () => BuilderParameter;
+};
+export declare const unless: typeof createUnless & {
+    parameter: () => BuilderParameter;
+};
+type OptionPayload<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> = {
+    readonly values: Values;
+};
+type WhenParameterOf<Config extends BuilderOptionWhenConfig> = Config extends {
+    readonly values: infer Values;
+} ? Values extends BuilderParameter ? Values : never : never;
+type OptionWhenResult<State extends BuilderState, GatePaths extends BuilderValidPaths<State['model']>, Name extends string, Config extends BuilderOptionWhenConfig> = WhenParameterOf<Config> extends never ? {
+    model: State['model'] & {
+        [K in Name]: BuilderOptionValueType<BuilderOptionWhenConfigValues<Config>> | WhenNullability<State['model'], GatePaths, Config>;
+    };
+    options: [...State['options'], BuilderOption<Name, BuilderOptionWhenConfigValues<Config>>];
+} : {
+    model: State['model'] & {
+        [K in Name]: string | null;
+    };
+    options: [...State['options'], BuilderOption<Name, WhenParameterOf<Config>>];
 };
-export declare function enable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
-export declare function match<const MatchPath extends BuilderPath, const SelectMap extends BuilderOptionValuesMap>(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>, BuilderOptionValuesMap[string]>, MatchPath & Readonly<BuilderValidPath<Model>>> : Config extends BuilderOptionUnlessConfig ? Config & {
+type WhenMatchKeyOf<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<any, infer MatchPath> ? BuilderResolvePath<Model, MatchPath> & string : string;
+type ValidOptionWhenConfig<Model, Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionMatchConfig<infer SelectMap, infer MatchPath> ? SelectMap extends BuilderParameter ? BuilderOptionMatchConfig<SelectMap, MatchPath & Readonly<BuilderValidPath<Model>>> : BuilderOptionMatchConfig<Record<WhenMatchKeyOf<Model, Config>, BuilderOptionValuesMap[string]>, MatchPath & Readonly<BuilderValidPath<Model>>> : Config extends BuilderOptionUnlessConfig<infer Values, infer UnlessPath> ? Values extends BuilderParameter ? BuilderOptionUnlessConfig<Values, UnlessPath & Readonly<BuilderValidPath<Model>>> : Config & {
     readonly unlessPath: Readonly<BuilderValidPath<Model>>;
 } : Config;
+declare function createEnable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
+declare function createMatch<const MatchPath extends BuilderPath, const SelectMap extends BuilderOptionValuesMap>(matchPath: MatchPath, selectMap: SelectMap): BuilderOptionMatchConfig<SelectMap, MatchPath>;
+declare function createUnless<const Values extends BuilderOptionValues, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, values: Values): BuilderOptionUnlessConfig<Values, UnlessPath>;
 export {};

package/dist/core/option/method.js

@@ -1,9 +1,13 @@
-export function enable(values) {
+import { BuilderParameter } from '../parameter.js';
+export const enable = Object.assign(createEnable, { parameter: () => new BuilderParameter() });
+export const match = Object.assign(createMatch, { parameter: () => new BuilderParameter() });
+export const unless = Object.assign(createUnless, { parameter: () => new BuilderParameter() });
+function createEnable(values) {
     return { type: 'enable', values };
 }
-export function match(matchPath, selectMap) {
+function createMatch(matchPath, selectMap) {
     return { type: 'match', matchPath, selectMap };
 }
-export function unless(unlessPath, disabledValues, values) {
+function createUnless(unlessPath, disabledValues, values) {
     return { type: 'unless', unlessPath, disabledValues, values };
 }

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

@@ -1,23 +1,30 @@
 import type { BuilderPaths } from '../../paths';
+import type { BuilderParameter } from '../parameter';
 import type { BuilderOptionWhenConfig } from './method';
-import type { BuilderSelectType, BuilderSelectTypeValues } from './select';
-import type { BuilderToggleType } from './toggle';
+import type { BuilderSelectTypeValues } from './select';
 import * as v from 'valibot';
+import { BuilderSelectType } from './select.js';
+import { BuilderToggleType } from './toggle.js';
+export declare const BuilderOptionValuesSchema: v.UnionSchema<[v.InstanceSchema<typeof BuilderSelectType, undefined>, v.InstanceSchema<typeof BuilderToggleType, undefined>], undefined>;
+export type BuilderOptionValues = v.InferOutput<typeof BuilderOptionValuesSchema>;
+export declare const BuilderOptionValuesMapSchema: v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.InstanceSchema<typeof BuilderSelectType, undefined>, v.InstanceSchema<typeof BuilderToggleType, undefined>], undefined>, undefined>, undefined>;
+export type BuilderOptionValuesMap = v.InferOutput<typeof BuilderOptionValuesMapSchema>;
 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 BuilderOptionValuesMap = Record<string, BuilderOptionValues | null>;
+export type BuilderOptionValueType<Values> = Values extends BuilderParameter ? string : Values extends {
+    readonly value: infer Value;
+} ? Value : never;
 export type BuilderOptionEntries = ReadonlyArray<BuilderOption>;
-export declare class BuilderOption<const Name extends string = string, const Values extends BuilderOptionValues = BuilderOptionValues> {
+export declare class BuilderOption<const Name extends string = string, const Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> {
     readonly model: {
-        [K in Name]: Values['value'];
+        [K in Name]: BuilderOptionValueType<Values>;
     };
     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;
+    resolve(model: unknown): BuilderOption<Name, BuilderOptionValues> | null;
     dependencyKeys(): ReadonlyArray<string>;
 }

package/dist/core/option/option.js

@@ -1,5 +1,13 @@
 import * as v from 'valibot';
-import { readPath } from '../../paths.js';
+import { check } from '../../check.js';
+import { resolve } from '../when/index.js';
+import { BuilderSelectType } from './select.js';
+import { BuilderToggleType } from './toggle.js';
+export const BuilderOptionValuesSchema = v.union([
+    v.instance(BuilderSelectType),
+    v.instance(BuilderToggleType)
+]);
+export const BuilderOptionValuesMapSchema = v.record(v.string(), v.nullable(BuilderOptionValuesSchema));
 export class BuilderOption {
     name;
     values;
@@ -12,28 +20,12 @@ export class BuilderOption {
         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;
-            }
-        }
+        check.assert(BuilderOptionValuesSchema, this.values);
+        return resolve(this, model, (selectMap, matchValue) => {
+            check.assert(BuilderOptionValuesMapSchema, selectMap);
+            const entry = selectMap[matchValue];
+            return entry ? new BuilderOption(this.name, entry) : null;
+        });
     }
     dependencyKeys() {
         const keys = new Set(this.gatePaths.map((path) => String(path[0])));

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

@@ -1,5 +1,6 @@
 import type { BuilderOptionValueSchema } from './option';
 import * as v from 'valibot';
+import { BuilderParameter } from '../parameter.js';
 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> {
@@ -14,4 +15,8 @@ export declare class BuilderSelectType<const Values extends BuilderSelectTypeVal
     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>>;
+declare function createSelect<const Values extends BuilderSelectTypeValues>(values: Values): BuilderSelectType<Values, v.UnionSchema<v.LiteralSchema<Values[number], undefined>[], undefined>>;
+export declare const select: typeof createSelect & {
+    parameter: () => BuilderParameter;
+};
+export {};

package/dist/core/option/select.js

@@ -1,4 +1,5 @@
 import * as v from 'valibot';
+import { BuilderParameter } from '../parameter.js';
 export class BuilderSelectType {
     options;
     valueSchema;
@@ -23,8 +24,11 @@ export class BuilderSelectType {
         return new BuilderSelectType(this.options, this.valueSchema, this.defaultValue, this.isOptional, optionLabels);
     }
 }
-export function select(values) {
+function createSelect(values) {
     const [defaultValue] = values;
     const valueSchema = v.union(values.map((value) => v.literal(value)));
     return new BuilderSelectType(values, valueSchema, defaultValue, false);
 }
+export const select = Object.assign(createSelect, {
+    parameter: () => new BuilderParameter()
+});

package/dist/core/parameter.d.ts

@@ -0,0 +1,48 @@
+import type { BuilderValidPath } from '../paths';
+import type { BuilderState, BuilderStateMerge } from './builder';
+import type { BuilderOption, BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionMatchConfig, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionWhenConfig } from './option/index';
+import type { WhenConfigNullable } from './when/index';
+import * as v from 'valibot';
+export declare class BuilderParameter {
+    readonly parameter: true;
+}
+export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
+export type ParameterisedOptions<Options extends BuilderOptionEntries> = {
+    [K in keyof Options]: Options[K] extends BuilderOption<infer Name, infer Values> ? Values extends BuilderParameter ? BuilderOption<Name, Values> : never : never;
+}[number];
+export type BuilderBindings<State extends BuilderState> = {
+    readonly [P in ParameterisedOptions<State['options']> as P['name']]?: ValidBinding<State['model']>;
+};
+export type ReplaceOption<Options extends BuilderOptionEntries, BoundNames extends string> = Options extends readonly [
+    infer Head extends BuilderOption,
+    ...infer Tail extends BuilderOptionEntries
+] ? Head extends BuilderOption<infer Name, infer Values> ? Values extends BuilderParameter ? Name extends BoundNames ? [...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [Head, ...ReplaceOption<Tail, BoundNames>] : [];
+export type BuilderBoundState<State extends BuilderState, Bindings extends Record<string, unknown>> = BuilderStateMerge<State, {
+    options: ReplaceOption<State['options'], Extract<keyof Bindings, string>>;
+    model: Omit<State['model'], keyof Bindings> & {
+        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
+    };
+}>;
+export declare function extractValues(config: BuilderOptionWhenConfig): BuilderOptionValues;
+export declare function bindOptions<Bindings extends Record<string, unknown>>(options: BuilderOptionEntries, bindings: Bindings): BuilderOptionEntries;
+type ValidEnableConfig = BuilderOptionEnableConfig<BuilderOptionEnableConfig['values']>;
+type ValidMatchConfig<Model> = BuilderOptionMatchConfig<BuilderOptionMatchConfig['selectMap'], Readonly<BuilderValidPath<Model>>>;
+type ValidUnlessConfig<Model> = BuilderOptionUnlessConfig<BuilderOptionUnlessConfig['values'], Readonly<BuilderValidPath<Model>>>;
+type ValidBinding<Model> = BuilderOptionValues | ValidEnableConfig | ValidMatchConfig<Model> | ValidUnlessConfig<Model>;
+type BindingConfigNullable<Binding> = Binding extends {
+    readonly type: string;
+} ? WhenConfigNullable<Binding> : never;
+type BindingValueType<Binding> = Binding extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap extends Record<string, unknown>;
+} ? NonNullable<SelectMap[keyof SelectMap]> extends {
+    readonly value: infer Value;
+} ? Value : string : Binding extends {
+    readonly values: infer Values;
+} ? Values extends {
+    readonly value: infer Value;
+} ? Value : string : Binding extends {
+    readonly value: infer Value;
+} ? Value : string;
+type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
+export {};

package/dist/core/parameter.js

@@ -0,0 +1,31 @@
+import * as v from 'valibot';
+import { BuilderWhenConfigSchema } from './when/index.js';
+export class BuilderParameter {
+    parameter = true;
+}
+export const BuilderParameterSchema = v.instance(BuilderParameter);
+export function extractValues(config) {
+    if (config.type === 'match') {
+        return Object.values(config.selectMap).find((value) => value !== null);
+    }
+    return config.values;
+}
+export function bindOptions(options, bindings) {
+    return options.map((option) => {
+        const binding = bindings[option.name];
+        if (binding == null) {
+            return option;
+        }
+        return bindOption(option, binding);
+    });
+}
+function createOption(option, values, config) {
+    const OptionConstructor = option.constructor;
+    return new OptionConstructor(option.name, values, option.gatePaths, config);
+}
+function bindOption(option, binding) {
+    if (v.is(BuilderWhenConfigSchema, binding)) {
+        return createOption(option, extractValues(binding), binding);
+    }
+    return createOption(option, binding, option.config);
+}

package/dist/core/when/config.d.ts

@@ -0,0 +1,20 @@
+import type { BuilderPrimitive } from '../../model';
+import type { BuilderPath } from '../../paths';
+import * as v from 'valibot';
+export declare const BuilderWhenConfigSchema: v.ObjectSchema<{
+    readonly type: v.PicklistSchema<["enable", "match", "unless"], undefined>;
+}, undefined>;
+export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
+export type BuilderWhenEnableConfig<Payload> = {
+    readonly type: 'enable';
+} & Payload;
+export type BuilderWhenMatchConfig<SelectMap = Record<string, unknown>, MatchPath extends BuilderPath = BuilderPath> = {
+    readonly type: 'match';
+    readonly matchPath: MatchPath;
+    readonly selectMap: SelectMap;
+};
+export type BuilderWhenUnlessConfig<Payload, UnlessPath extends BuilderPath = BuilderPath> = {
+    readonly type: 'unless';
+    readonly unlessPath: UnlessPath;
+    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
+} & Payload;

package/dist/core/when/config.js

@@ -0,0 +1,4 @@
+import * as v from 'valibot';
+export const BuilderWhenConfigSchema = v.object({
+    type: v.picklist(['enable', 'match', 'unless'])
+});

package/dist/core/when/constrain.d.ts

@@ -0,0 +1,14 @@
+import type { BuilderValidPath } from '../../paths';
+export type WhenConfigConstrained<Model, Config extends {
+    readonly type: string;
+}> = Config extends {
+    readonly type: 'match';
+    readonly matchPath: infer MatchPath;
+} ? Config & {
+    readonly matchPath: MatchPath & Readonly<BuilderValidPath<Model>>;
+} : Config extends {
+    readonly type: 'unless';
+    readonly unlessPath: infer UnlessPath;
+} ? Config & {
+    readonly unlessPath: UnlessPath & Readonly<BuilderValidPath<Model>>;
+} : Config;

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

@@ -0,0 +1,5 @@
+export type { BuilderWhenConfig, BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig } from './config';
+export { BuilderWhenConfigSchema } from './config.js';
+export type { WhenConfigNullable, WhenNullability, WhenPathsNullable } from './nullability';
+export type { WhenConfigConstrained } from './constrain';
+export { resolve } from './resolve.js';

package/dist/core/when/index.js

@@ -0,0 +1,2 @@
+export { BuilderWhenConfigSchema } from './config.js';
+export { resolve } from './resolve.js';

package/dist/core/when/nullability.d.ts

@@ -0,0 +1,18 @@
+import type { BuilderPath, BuilderPaths, BuilderResolvePath } from '../../paths';
+export type WhenConfigNullable<Config extends {
+    readonly type: string;
+}> = Config extends {
+    readonly type: 'unless';
+} ? null : Config extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? null extends SelectMap[keyof SelectMap] ? null : never : never;
+export type WhenPathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
+    infer Head extends BuilderPath,
+    ...infer Tail extends BuilderPaths
+] ? WhenPathNullable<Model, Head> | WhenPathsNullable<Model, Tail> : never;
+export type WhenNullability<Model, GatePaths extends BuilderPaths, Config extends {
+    readonly type: string;
+}> = WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config>;
+type WhenPathNullable<Model, Path extends BuilderPath> = null extends BuilderResolvePath<Model, Path> ? null : never;
+export {};

package/dist/core/when/nullability.js

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

package/dist/core/when/resolve.d.ts

@@ -0,0 +1,18 @@
+import type { BuilderPath, BuilderPaths } from '../../paths';
+export declare function resolve<Entry extends Resolvable>(entry: Entry, model: unknown, onMatch: (selectMap: unknown, matchValue: string) => Entry | null): Entry | null;
+type ResolvableConfig = {
+    readonly type: 'enable';
+} | {
+    readonly type: 'match';
+    readonly matchPath: BuilderPath;
+    readonly selectMap: unknown;
+} | {
+    readonly type: 'unless';
+    readonly unlessPath: BuilderPath;
+    readonly disabledValues: ReadonlyArray<unknown>;
+};
+interface Resolvable {
+    readonly gatePaths: BuilderPaths;
+    readonly config: ResolvableConfig | null;
+}
+export {};

package/dist/core/when/resolve.js

@@ -0,0 +1,22 @@
+import { readPath } from '../../paths.js';
+export function resolve(entry, model, onMatch) {
+    if (entry.config === null) {
+        return entry;
+    }
+    if (!entry.gatePaths.every((path) => !!readPath(model, path))) {
+        return null;
+    }
+    switch (entry.config.type) {
+        case 'enable': {
+            return entry;
+        }
+        case 'match': {
+            const matchValue = String(readPath(model, entry.config.matchPath));
+            return onMatch(entry.config.selectMap, matchValue);
+        }
+        case 'unless': {
+            const value = readPath(model, entry.config.unlessPath);
+            return !entry.config.disabledValues.includes(value) ? entry : null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,16 +1,13 @@
-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, BuilderOptionValuesMap, BuilderPart, BuilderParts, BuilderSelectTypeLabels, BuilderSelectTypeValues, BuilderState, BuilderStateOf } from './core/index';
+export type { BuilderData, BuilderModel, BuilderModels, BuilderPrimitive, BuilderPrimitives, BuilderVariant, BuilderVariants } from './model';
+export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries } 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 { BuilderDataValidated, BuilderDescription, BuilderDescriptionItem, BuilderErrorComponentMissing, BuilderErrorComponentUnexpected, BuilderErrorsValidate, BuilderErrorValidate, BuilderErrorVariantInvalid, BuilderErrorVariantMissing, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, 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 type { BuilderUI, BuilderUIFactory, BuilderUIs } from './ui';
+export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
+export { BuilderExpectation, component, option } from './core/index.js';
+export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, 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

@@ -1,6 +1,5 @@
-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 { BuilderExpectation, component, option } from './core/index.js';
+export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, 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/{config.d.ts → model.d.ts}

@@ -3,7 +3,7 @@ export type { BuilderPrimitive, BuilderPrimitives } from './schemas/index';
 export type BuilderModel = {
     readonly [key: string]: BuilderPrimitive | BuilderModels;
 };
-export type BuilderModelMutable = Record<string, unknown>;
+export type BuilderModelInput = Record<string, unknown>;
 export type BuilderModels = ReadonlyArray<BuilderModel>;
 export type BuilderVariant = {
     readonly model: BuilderModel;

package/dist/model.js

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