@builder-builder/builder 0.0.4 → 0.0.6

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

@@ -2,10 +2,9 @@ import type { GraphPath, GraphPaths } from '../graph';
 import { BuilderOption } from './option.js';
 export type BuilderOptionGraphs = ReadonlyArray<BuilderOptionGraph>;
 export declare class BuilderOptionGraph {
+    #private;
     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

@@ -1,3 +1,4 @@
+import { crossProduct } from '../graph.js';
 import * as v from 'valibot';
 import { check } from '../../check.js';
 import { BuilderOption, BuilderOptionValuesSchema } from './option.js';
@@ -7,18 +8,13 @@ export class BuilderOptionGraph {
     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);
         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 dependencyKeys = option.dependencyKeys();
         if (dependencyKeys.length === 0) {
             const values = optionValues(option);
@@ -49,6 +45,9 @@ export class BuilderOptionGraph {
             { name: option.name, keys: merged.keys, models: finalModels }
         ]);
     }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
 }
 function mergePaths(dependencyKeys, graphPaths) {
     const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {
@@ -59,7 +58,7 @@ function mergePaths(dependencyKeys, graphPaths) {
     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 });
 }

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

@@ -1,97 +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 { BuilderOptionValueType, BuilderOptionValues, BuilderOptionValuesMap } from './option';
-import type { BuilderOption } from './option';
+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> = {
-    readonly type: 'enable';
-    readonly values: Values;
-};
-export type BuilderOptionMatchConfig<SelectMap extends BuilderOptionValuesMap | BuilderParameter = BuilderOptionValuesMap | BuilderParameter, MatchPath extends BuilderPath = BuilderPath, Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter> = {
-    readonly type: 'match';
-    readonly matchPath: MatchPath;
-    readonly selectMap: SelectMap;
-    readonly values: Values;
-};
-export type BuilderOptionUnlessConfig<Values extends BuilderOptionValues | BuilderParameter = BuilderOptionValues | BuilderParameter, UnlessPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'unless';
-    readonly unlessPath: UnlessPath;
-    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
-    readonly values: Values;
-};
+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 : never;
-type ExtractWhenParameter<Config extends BuilderOptionWhenConfig> = Config extends {
-    readonly values: infer Values;
-} ? Values extends BuilderParameter ? Values : never : never;
+} ? 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]: BuilderOptionValueType<Values>;
         };
         options: [...State['options'], BuilderOption<Name, Values>];
-    }>>;
-    <const Name extends string>(name: Name, values: BuilderParameter): Builder<BuilderStateMerge<State, {
+    }>;
+    <const Name extends string>(name: Name, values: BuilderParameter): BuilderMerge<State, {
         model: State['model'] & {
             [K in Name]: string;
         };
         options: [...State['options'], BuilderOption<Name, BuilderParameter>];
-    }>>;
+    }>;
     when: {
-        <const GatePaths extends ReadonlyArray<BuilderValidPath<State['model']>>, const Name extends string>(gatePaths: GatePaths, name: Name, config: BuilderParameter): Builder<BuilderStateMerge<State, {
+        <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 | OptionGatePathsNullable<State['model'], GatePaths>;
+                [K in Name]: string | WhenPathsNullable<State['model'], GatePaths>;
             };
             options: [...State['options'], BuilderOption<Name, BuilderParameter>];
-            components: State['components'];
-            collections: State['collections'];
-        }>>;
-        <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, WhenConfigResult<State, GatePaths, Name, Config>>>;
+        }>;
+        <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>>;
     };
 };
-declare function createEnable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
-declare function createEnableParameter(): BuilderParameter;
 export declare const enable: typeof createEnable & {
-    parameter: typeof createEnableParameter;
+    parameter: () => BuilderParameter;
 };
-declare function createMatch<const MatchPath extends BuilderPath, const SelectMap extends BuilderOptionValuesMap>(matchPath: MatchPath, selectMap: SelectMap): BuilderOptionMatchConfig<SelectMap, MatchPath>;
-declare function createMatchParameter(): BuilderParameter;
 export declare const match: typeof createMatch & {
-    parameter: typeof createMatchParameter;
+    parameter: () => BuilderParameter;
 };
-declare function createUnless<const Values extends BuilderOptionValues, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, values: Values): BuilderOptionUnlessConfig<Values, UnlessPath>;
-declare function createUnlessParameter(): BuilderParameter;
 export declare const unless: typeof createUnless & {
-    parameter: typeof createUnlessParameter;
+    parameter: () => BuilderParameter;
 };
-type OptionConfigNullable<Config extends BuilderOptionWhenConfig> = Config extends BuilderOptionUnlessConfig ? null : Config extends BuilderOptionMatchConfig<infer SelectMapType> ? SelectMapType extends BuilderOptionValuesMap ? null extends SelectMapType[keyof SelectMapType] ? null : never : null : 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 WhenConfigResult<State extends BuilderState, GatePaths extends BuilderPaths, Name extends string, Config extends BuilderOptionWhenConfig> = ExtractWhenParameter<Config> extends never ? {
+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>> | OptionWhenNullability<State['model'], GatePaths, Config>;
+        [K in Name]: BuilderOptionValueType<BuilderOptionWhenConfigValues<Config>> | WhenNullability<State['model'], GatePaths, Config>;
     };
     options: [...State['options'], BuilderOption<Name, BuilderOptionWhenConfigValues<Config>>];
-    components: State['components'];
-    collections: State['collections'];
 } : {
     model: State['model'] & {
         [K in Name]: string | null;
     };
-    options: [...State['options'], BuilderOption<Name, ExtractWhenParameter<Config>>];
-    components: State['components'];
-    collections: State['collections'];
+    options: [...State['options'], BuilderOption<Name, WhenParameterOf<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<infer SelectMap, infer MatchPath> ? SelectMap extends BuilderParameter ? BuilderOptionMatchConfig<SelectMap, MatchPath & Readonly<BuilderValidPath<Model>>> : BuilderOptionMatchConfig<Record<MatchKeyOfConfig<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 & {
+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,23 +1,13 @@
 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 };
 }
-function createEnableParameter() {
-    return new BuilderParameter();
-}
-export const enable = Object.assign(createEnable, { parameter: createEnableParameter });
 function createMatch(matchPath, selectMap) {
-    const values = Object.values(selectMap).find((value) => value !== null);
-    return { type: 'match', matchPath, selectMap, values };
-}
-function createMatchParameter() {
-    return new BuilderParameter();
+    return { type: 'match', matchPath, selectMap };
 }
-export const match = Object.assign(createMatch, { parameter: createMatchParameter });
 function createUnless(unlessPath, disabledValues, values) {
     return { type: 'unless', unlessPath, disabledValues, values };
 }
-function createUnlessParameter() {
-    return new BuilderParameter();
-}
-export const unless = Object.assign(createUnless, { parameter: createUnlessParameter });

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

@@ -1,16 +1,17 @@
 import type { BuilderPaths } from '../../paths';
-import type { BuilderOptionValues } from '../../schemas/serialise';
-import type { BuilderOptionWhenConfig } from './method';
 import type { BuilderParameter } from '../parameter';
+import type { BuilderOptionWhenConfig } from './method';
 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, BuilderOptionValuesMap } from '../../schemas/serialise';
-export { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../../schemas/serialise.js';
 export type BuilderOptionValueType<Values> = Values extends BuilderParameter ? string : Values extends {
     readonly value: infer Value;
 } ? Value : never;

package/dist/core/option/option.js

@@ -1,10 +1,13 @@
 import * as v from 'valibot';
 import { check } from '../../check.js';
-import { readPath } from '../../paths.js';
-import { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../../schemas/serialise.js';
+import { resolve } from '../when/index.js';
 import { BuilderSelectType } from './select.js';
 import { BuilderToggleType } from './toggle.js';
-export { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../../schemas/serialise.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;
@@ -17,44 +20,22 @@ export class BuilderOption {
         this.config = config;
     }
     resolve(model) {
-        const { values } = this;
-        check.assert(BuilderOptionValuesSchema, values);
-        const resolved = new BuilderOption(this.name, values);
-        if (this.config === null) {
-            return resolved;
-        }
-        if (!this.gatePaths.every((path) => !!readPath(model, path))) {
-            return null;
-        }
-        switch (this.config.type) {
-            case 'enable': {
-                check.assert(BuilderOptionValuesSchema, this.config.values);
-                return resolved;
-            }
-            case 'match': {
-                const { selectMap } = this.config;
-                check.assert(BuilderOptionValuesMapSchema, selectMap);
-                const matchPath = this.config.matchPath;
-                const entry = selectMap[String(readPath(model, matchPath))];
-                return entry ? new BuilderOption(this.name, entry) : null;
-            }
-            case 'unless': {
-                check.assert(BuilderOptionValuesSchema, this.config.values);
-                const value = readPath(model, this.config.unlessPath);
-                return !this.config.disabledValues.includes(value)
-                    ? resolved
-                    : 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])));
+        const keys = new Set(this.gatePaths.map(([first]) => String(first)));
         if (this.config?.type === 'match') {
-            const matchPath = this.config.matchPath;
-            keys.add(String(matchPath[0]));
+            const [firstMatchSegment] = this.config.matchPath;
+            keys.add(String(firstMatchSegment));
         }
         else if (this.config?.type === 'unless') {
-            keys.add(String(this.config.unlessPath[0]));
+            const [firstUnlessSegment] = this.config.unlessPath;
+            keys.add(String(firstUnlessSegment));
         }
         return Array.from(keys);
     }

package/dist/core/parameter.d.ts

@@ -1,35 +1,48 @@
+import type { BuilderValidPath } from '../paths';
 import type { BuilderState, BuilderStateMerge } from './builder';
-import type { BuilderOption, BuilderOptionEntries, BuilderOptionValues, BuilderOptionWhenConfig } from './option/index';
+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 function bindOptions<Bindings extends Record<string, unknown>>(options: BuilderOptionEntries, bindings: Bindings): BuilderOptionEntries;
+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']]?: BuilderOptionValues | BuilderOptionWhenConfig;
+    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>] : [];
-type BindingModelType<Binding> = Binding extends {
+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 | null : string | null : Binding extends {
+} ? Value : string : Binding extends {
     readonly values: infer Values;
 } ? Values extends {
     readonly value: infer Value;
-} ? Value | null : string | null : Binding extends {
+} ? Value : string : Binding extends {
     readonly value: infer Value;
 } ? Value : string;
-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]>;
-    };
-}>;
+type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
 export {};

package/dist/core/parameter.js

@@ -1,25 +1,31 @@
+import * as v from 'valibot';
+import { BuilderWhenConfigSchema } from './when/index.js';
 export class BuilderParameter {
     parameter = true;
 }
-function createOption(option, values, config) {
-    const OptionConstructor = option.constructor;
-    return new OptionConstructor(option.name, values, option.gatePaths, config);
-}
-function isWhenConfig(binding) {
-    return typeof binding === 'object' && binding !== null && 'type' in binding;
-}
-function bindOption(option, binding) {
-    if (isWhenConfig(binding)) {
-        return createOption(option, binding.values, binding);
+export const BuilderParameterSchema = v.instance(BuilderParameter);
+export function extractValues(config) {
+    if (config.type === 'match') {
+        return Object.values(config.selectMap).find((value) => value !== null);
     }
-    return createOption(option, binding, option.config);
+    return config.values;
 }
 export function bindOptions(options, bindings) {
     return options.map((option) => {
         const binding = bindings[option.name];
-        if (binding === undefined) {
+        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,15 +1,12 @@
-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 type { BuilderUI, BuilderUIs } from './ui';
+export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
+export { BuilderExpectation, has } 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';

package/dist/index.js

@@ -1,5 +1,4 @@
-export { BuilderExpectation } from './assert/expectation.js';
-export { assert, component, option } from './assert/index.js';
+export { BuilderExpectation, has } 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';

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 {};

package/dist/paths.d.ts

@@ -1,10 +1,13 @@
-export type { BuilderPath, BuilderPaths } from './schemas/index';
 import type { BuilderGeneric, BuilderModelOf } from './core/index';
 import type { BuilderPath, BuilderPrimitive } from './schemas/index';
+export type { BuilderPath, BuilderPaths } 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]>] : {
     [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...BuilderValidPath<Model[Key], [...Depth, never]>]);
 }[keyof Model & string];
-export type BuilderModelPaths<Builder extends BuilderGeneric> = ReadonlyArray<BuilderValidPath<BuilderModelOf<Builder>>>;
+export type BuilderValidPaths<Model> = ReadonlyArray<BuilderValidPath<Model>>;
+export type BuilderModelPaths<Builder extends BuilderGeneric | null> = [Builder] extends [
+    BuilderGeneric
+] ? BuilderValidPaths<BuilderModelOf<Builder>> : ReadonlyArray<never>;
 export type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Model & string
 ] ? Model[Head] : Path extends readonly [

package/dist/resolve/index.d.ts

@@ -1,7 +1,7 @@
 export type { BuilderOrder } from './order';
-export type { BuilderRenderLayoutOption, BuilderRenderLayoutOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './render';
+export type { BuilderRenderOption, BuilderRenderOptions, 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 type { BuilderDescription, BuilderDescriptionItem } from '../schemas/index';
 export { instance } from './instance.js';
 export { models } from './models.js';
 export { order } from './order.js';