@builder-builder/builder 0.0.2 → 0.0.4

package/dist/assert/assert.d.ts

@@ -4,13 +4,13 @@ import type { BuilderUI } from '../ui';
 import type { BuilderExpectations } from './expectation';
 import { BuilderComponent, Builder } from '../core/index.js';
 import { BuilderExpectation } from './expectation.js';
-export type BuilderModelAsserted<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations> = Builder<BuilderStateMerge<BuilderStateOf<BuilderInput>, {
-    model: ModelAssert<BuilderInput, Items>;
-    components: ComponentAssert<BuilderInput, Items>;
+export type BuilderModelAsserted<BuilderInput extends BuilderGeneric, Expectations extends BuilderExpectations> = Builder<BuilderStateMerge<BuilderStateOf<BuilderInput>, {
+    model: ModelAssert<BuilderInput, Expectations>;
+    components: ComponentAssert<BuilderInput, Expectations>;
 }>>;
-export type BuilderUIModelAsserted<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations> = BuilderUI<BuilderModelAsserted<BuilderInput, Items>>;
-declare function assertBuilder<const R extends BuilderGeneric, const Items extends BuilderExpectations>(builder: R, ...items: Items): BuilderModelAsserted<R, Items>;
-declare function assertUI<const R extends BuilderGeneric, const Items extends BuilderExpectations>(ui: BuilderUI<R>, ...items: Items): BuilderUIModelAsserted<R, Items>;
+export type BuilderUIModelAsserted<Builder extends BuilderGeneric, Expectations extends BuilderExpectations> = BuilderUI<BuilderModelAsserted<Builder, Expectations>>;
+declare function assertBuilder<const Builder extends BuilderGeneric, const Expectations extends BuilderExpectations>(builder: Builder, ...expectations: Expectations): BuilderModelAsserted<Builder, Expectations>;
+declare function assertUI<const Builder extends BuilderGeneric, const Expectations extends BuilderExpectations>(ui: BuilderUI<Builder>, ...expectations: Expectations): BuilderUIModelAsserted<Builder, Expectations>;
 export declare const assert: {
     builder: typeof assertBuilder;
     ui: typeof assertUI;

package/dist/assert/assert.js

@@ -1,23 +1,23 @@
 import * as v from 'valibot';
 import { BuilderComponent, Builder } from '../core/index.js';
 import { BuilderExpectation } from './expectation.js';
-function assertBuilder(builder, ...items) {
-    items.forEach((item) => {
-        if (v.is(v.instance(BuilderExpectation), item)) {
-            if (item.kind === 'option') {
-                item.validate(builder.options);
+function assertBuilder(builder, ...expectations) {
+    expectations.forEach((expectation) => {
+        if (v.is(v.instance(BuilderExpectation), expectation)) {
+            if (expectation.kind === 'option') {
+                expectation.validate(builder.options);
             }
-            else if (item.kind === 'component') {
-                item.validate(builder.components);
+            else if (expectation.kind === 'component') {
+                expectation.validate(builder.components);
             }
         }
     });
     return builder;
 }
-function assertUI(ui, ...items) {
-    items.forEach((item) => {
-        if (v.is(v.instance(BuilderExpectation), item) && item.kind === 'option') {
-            item.validate(ui.builder.options);
+function assertUI(ui, ...expectations) {
+    expectations.forEach((expectation) => {
+        if (v.is(v.instance(BuilderExpectation), expectation) && expectation.kind === 'option') {
+            expectation.validate(ui.builder.options);
         }
     });
     return ui;

package/dist/assert/expectation.js

@@ -1,4 +1,4 @@
-import { invariant } from '../invariant.js';
+import { check } from '../check.js';
 export class BuilderExpectation {
     name;
     kind;
@@ -10,7 +10,7 @@ export class BuilderExpectation {
         return new BuilderExpectation(this.name, this.kind);
     }
     validate(entries) {
-        invariant(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
+        check.truthy(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
     }
 }
 export const option = {

package/dist/check.d.ts

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+declare class Check {
+    truthy<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
+    falsy(input: unknown, message?: `${string}! ❌`): void;
+    assert<const TSchema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: TSchema, input: unknown): asserts input is v.InferOutput<TSchema>;
+}
+export declare const check: Check;
+export {};

package/dist/check.js

@@ -0,0 +1,18 @@
+import * as v from 'valibot';
+const DEFAULT_MESSAGE = 'Unexpected value! ❌';
+class Check {
+    truthy(input, message = DEFAULT_MESSAGE) {
+        if (!input) {
+            throw new Error(message);
+        }
+    }
+    falsy(input, message = DEFAULT_MESSAGE) {
+        if (input) {
+            throw new Error(message);
+        }
+    }
+    assert(schema, input) {
+        v.assert(schema, input);
+    }
+}
+export const check = new Check();

package/dist/core/builder.d.ts

@@ -1,6 +1,7 @@
 import type { BuilderCollectionEntries, BuilderCollectionMethod } from './collection/index';
 import type { BuilderComponentEntries, BuilderComponentMethod } from './component/index';
 import type { BuilderOptionEntries, BuilderOptionMethod, BuilderOptionValues, BuilderSelectType } from './option/index';
+import type { BuilderBindings, BuilderBoundState } from './parameter';
 import { BuilderComponentGraph } from './component/index.js';
 import { BuilderOptionGraph } from './option/index.js';
 export type BuilderSelectMap<Select extends BuilderSelectType = BuilderSelectType> = Record<Select['options'][number], BuilderOptionValues | null>;
@@ -39,12 +40,13 @@ export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     readonly options: BuilderOptionEntries;
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
-    readonly optionGraph: BuilderOptionGraph;
-    readonly componentGraph: BuilderComponentGraph;
-    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries, optionGraph?: BuilderOptionGraph, componentGraph?: BuilderComponentGraph);
+    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries);
+    get optionGraph(): BuilderOptionGraph;
+    get componentGraph(): BuilderComponentGraph;
     get option(): BuilderOptionMethod<State>;
     get component(): BuilderComponentMethod<State>;
     get collection(): BuilderCollectionMethod<State>;
+    bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
 }
 export declare function builder<const Parts extends BuilderParts>(...parts: Parts): Builder<MergedPartsState<Parts>>;
 type ExtractPartState<Part> = Part extends BuilderGeneric ? BuilderStateOf<Part> : Part extends (...args: ReadonlyArray<any>) => infer Result ? Result extends BuilderGeneric ? BuilderStateOf<Result> : BuilderStateEmpty : BuilderStateEmpty;

package/dist/core/builder.js

@@ -1,70 +1,94 @@
-import { invariant } from '../invariant.js';
+import { bindOptions } from './parameter.js';
+import * as v from 'valibot';
+import { check } from '../check.js';
 import { BuilderCollection, resolveCollectionNames } from './collection/index.js';
 import { BuilderComponent, BuilderComponentGraph } from './component/index.js';
 import { BuilderOption, BuilderOptionGraph } from './option/index.js';
+import { BuilderParameter } from './parameter.js';
 export class Builder {
     options;
     components;
     collections;
-    optionGraph;
-    componentGraph;
-    constructor(options = [], collections = [], components = [], optionGraph = new BuilderOptionGraph(), componentGraph = new BuilderComponentGraph()) {
+    #optionGraph = null;
+    #componentGraph = null;
+    constructor(options = [], collections = [], components = []) {
         this.options = options;
         this.collections = collections;
         this.components = components;
-        this.optionGraph = optionGraph;
-        this.componentGraph = componentGraph;
+    }
+    get optionGraph() {
+        if (this.#optionGraph === null) {
+            this.#optionGraph = this.options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
+        }
+        return this.#optionGraph;
+    }
+    get componentGraph() {
+        if (this.#componentGraph === null) {
+            const graphs = [
+                this.components.reduce((graph, component) => graph.add(component, this.optionGraph), new BuilderComponentGraph()),
+                ...this.collections.map((collection) => collection.builder.componentGraph)
+            ];
+            this.#componentGraph = new BuilderComponentGraph(graphs.flatMap((graph) => graph.paths));
+        }
+        return this.#componentGraph;
     }
     get option() {
         const addOption = (name, values) => {
             const entry = new BuilderOption(name, values);
-            return this.#next([...this.options, entry], this.collections, this.components, this.optionGraph.add(entry), this.componentGraph);
+            return this.#next([...this.options, entry], this.collections, this.components);
         };
         const addConditionalOption = (gatePaths, name, config) => {
-            const values = config.type === 'match'
-                ? Object.values(config.selectMap).find((value) => value !== null)
-                : config.values;
-            const entry = new BuilderOption(name, values, gatePaths, config);
-            return this.#next([...this.options, entry], this.collections, this.components, this.optionGraph.add(entry), this.componentGraph);
+            const values = v.is(v.instance(BuilderParameter), config) ? config : config.values;
+            const optionConfig = v.is(v.instance(BuilderParameter), config) ? null : config;
+            const entry = new BuilderOption(name, values, gatePaths, optionConfig);
+            return this.#next([...this.options, entry], this.collections, this.components);
         };
         return Object.assign(addOption, { when: addConditionalOption });
     }
     get component() {
+        const existingNames = new Set(this.components.map((component) => component.name));
         const addComponent = (name, paths) => {
+            check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths);
-            return this.#next(this.options, this.collections, [...this.components, entry], this.optionGraph, this.componentGraph.add(entry, this.optionGraph));
+            return this.#next(this.options, this.collections, [...this.components, entry]);
         };
         const addConditionalComponent = (dependencies, name, paths) => {
+            check.falsy(existingNames.has(name), `Duplicate component name '${name}'! ❌`);
             const entry = new BuilderComponent(name, paths, dependencies);
-            return this.#next(this.options, this.collections, [...this.components, entry], this.optionGraph, this.componentGraph.add(entry, this.optionGraph));
+            return this.#next(this.options, this.collections, [...this.components, entry]);
         };
         return Object.assign(addComponent, { when: addConditionalComponent });
     }
     get collection() {
         const addCollection = (name, collectionRecipe, min = 0, max = Infinity) => {
             const existing = resolveCollectionNames(this.collections);
-            invariant(!existing.has(name), `Duplicate collection name '${name}'! ❌`);
+            check.falsy(existing.has(name), `Duplicate collection name '${name}'! ❌`);
+            check.assert(v.instance(Builder), collectionRecipe);
             const entry = new BuilderCollection(name, collectionRecipe, min, max);
-            return this.#next(this.options, [...this.collections, entry], this.components, this.optionGraph, BuilderComponentGraph.merge(this.componentGraph, collectionRecipe.componentGraph));
+            return this.#next(this.options, [...this.collections, entry], this.components);
         };
         const addConditionalCollection = (gatePaths, name, config) => {
             const existing = resolveCollectionNames(this.collections);
-            invariant(!existing.has(name), `Duplicate collection name '${name}'! ❌`);
+            check.falsy(existing.has(name), `Duplicate collection name '${name}'! ❌`);
             const defaultEntry = config.type === 'match'
                 ? Object.values(config.selectMap).find((value) => value !== null)
                 : config;
             const entry = new BuilderCollection(name, defaultEntry.builder, defaultEntry.min, defaultEntry.max, gatePaths, config);
-            return this.#next(this.options, [...this.collections, entry], this.components, this.optionGraph, BuilderComponentGraph.merge(this.componentGraph, defaultEntry.builder.componentGraph));
+            return this.#next(this.options, [...this.collections, entry], this.components);
         };
         return Object.assign(addCollection, { when: addConditionalCollection });
     }
-    #next(options, collections, components, optionGraph, componentGraph) {
-        return new Builder(options, collections, components, optionGraph, componentGraph);
+    bind(bindings) {
+        const boundOptions = bindOptions(this.options, bindings);
+        return new Builder(boundOptions, this.collections, this.components);
+    }
+    #next(options, collections, components) {
+        return new Builder(options, collections, components);
     }
 }
 export function builder(...parts) {
     const instances = parts.filter((part) => part instanceof Builder);
-    const base = new Builder(instances.flatMap((instance) => instance.options), instances.flatMap((instance) => instance.collections), instances.flatMap((instance) => instance.components), BuilderOptionGraph.merge(...instances.map((instance) => instance.optionGraph)), BuilderComponentGraph.merge(...instances.map((instance) => instance.componentGraph)));
+    const base = new Builder(instances.flatMap((instance) => instance.options), instances.flatMap((instance) => instance.collections), instances.flatMap((instance) => instance.components));
     const factories = parts.filter((part) => !(part instanceof Builder));
     return factories.reduce((accumulated, factory) => {
         return factory(accumulated);

package/dist/core/collection/collection.d.ts

@@ -9,9 +9,9 @@ export type BuilderCollectionConfig<CollectionRecipe = any, Min extends number =
 };
 export type BuilderCollectionEntries = ReadonlyArray<BuilderCollection>;
 export type BuilderTupleOf<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : BuilderTupleOf<Item, Length, [...Result, Item]>;
-export type BuilderCollectionOf<R extends BuilderGeneric, Name extends string> = FindCollection<BuilderStateOf<R>['collections'], Name>;
+export type BuilderCollectionOf<Builder extends BuilderGeneric, Name extends string> = FindCollection<BuilderStateOf<Builder>['collections'], Name>;
 type FindCollection<Config extends BuilderCollectionEntries, Name extends string> = Config extends readonly [infer Head, ...infer Tail extends BuilderCollectionEntries] ? Extract<Head, BuilderCollection<Name, any, any, any>> extends never ? FindCollection<Tail, Name> : Extract<Head, BuilderCollection<Name, any, any, any>> : Extract<Config[number], BuilderCollection<Name, any, any, any>>;
-export type BuilderCollectionNamesOf<R extends BuilderGeneric> = ExtractCollectionNames<BuilderStateOf<R>['collections']>;
+export type BuilderCollectionNamesOf<Builder extends BuilderGeneric> = ExtractCollectionNames<BuilderStateOf<Builder>['collections']>;
 type ExtractCollectionNames<Entries extends BuilderCollectionEntries> = Entries extends readonly [
     infer Head extends BuilderCollection,
     ...infer Tail extends BuilderCollectionEntries

package/dist/core/collection/collection.js

@@ -1,4 +1,4 @@
-import { invariant } from '../../invariant.js';
+import { check } from '../../check.js';
 import { readPath } from '../../paths.js';
 export class BuilderCollection {
     name;
@@ -8,9 +8,9 @@ export class BuilderCollection {
     gatePaths;
     config;
     constructor(name, builder, min = 0, max = Infinity, gatePaths = [], config = null) {
-        invariant(min >= 0, `Collection '${name}': min must be >= 0, got ${String(min)}! ❌`);
-        invariant(max > 0, `Collection '${name}': max must be > 0, got ${String(max)}! ❌`);
-        invariant(max >= min, `Collection '${name}': max must be >= min, got min=${String(min)}, max=${String(max)}! ❌`);
+        check.truthy(min >= 0, `Collection '${name}': min must be >= 0, got ${min}! ❌`);
+        check.truthy(max > 0, `Collection '${name}': max must be > 0, got ${max}! ❌`);
+        check.truthy(max >= min, `Collection '${name}': max must be >= min, got min=${min}, max=${max}! ❌`);
         this.name = name;
         this.builder = builder;
         this.min = min;

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

@@ -5,9 +5,6 @@ export declare class BuilderComponentGraph {
     #private;
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
-    static merge(...graphs: ComponentGraphs): BuilderComponentGraph;
     has(name: string): boolean;
     add(component: BuilderComponent, options: BuilderOptionGraph): BuilderComponentGraph;
 }
-type ComponentGraphs = ReadonlyArray<BuilderComponentGraph>;
-export {};

package/dist/core/component/graph.js

@@ -1,18 +1,16 @@
-import { invariant } from '../../invariant.js';
+import { check } from '../../check.js';
 import { BuilderComponent } from './component.js';
+const EMPTY_MODEL = '{}';
 export class BuilderComponentGraph {
     paths;
     constructor(paths = []) {
         this.paths = paths;
     }
-    static merge(...graphs) {
-        return new BuilderComponentGraph(graphs.flatMap((graph) => graph.paths));
-    }
     has(name) {
         return this.paths.some((graphPath) => graphPath.name === name);
     }
     add(component, options) {
-        invariant(!this.has(component.name), `Duplicate component name '${component.name}'! ❌`);
+        check.falsy(this.has(component.name), `Duplicate component name '${component.name}'! ❌`);
         const keys = new Set(component.paths.map((path) => String(path[0])));
         const models = this.#mergeModels(keys, options);
         const newPath = { name: component.name, keys, models };
@@ -39,10 +37,10 @@ export class BuilderComponentGraph {
     #createModels(graphPath, keys) {
         const seen = new Set();
         const models = [];
-        graphPath.models.forEach((item) => {
-            const picked = Object.fromEntries(Object.entries(item).filter(([key, value]) => keys.has(key) && value != null));
+        graphPath.models.forEach((model) => {
+            const picked = Object.fromEntries(Object.entries(model).filter(([key, value]) => keys.has(key) && value != null));
             const identity = JSON.stringify(picked);
-            if (!seen.has(identity)) {
+            if (identity !== EMPTY_MODEL && !seen.has(identity)) {
                 seen.add(identity);
                 models.push(picked);
             }

package/dist/core/index.d.ts

@@ -6,3 +6,4 @@ export { BuilderCollection, collection, resolveCollectionModels, resolveCollecti
 export { BuilderComponent, BuilderComponentGraph } from './component/index.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 } from './parameter.js';

package/dist/core/index.js

@@ -2,3 +2,4 @@ export { BuilderCollection, collection, resolveCollectionModels, resolveCollecti
 export { BuilderComponent, BuilderComponentGraph } from './component/index.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 } from './parameter.js';

package/dist/core/option/graph.js

@@ -1,6 +1,6 @@
 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 +15,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,7 +53,7 @@ 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;
@@ -65,6 +65,7 @@ function mergePaths(dependencyKeys, graphPaths) {
 }
 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

@@ -2,51 +2,96 @@ 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 { BuilderOptionValueType, BuilderOptionValues, BuilderOptionValuesMap } from './option';
 import type { BuilderOption } from './option';
-export type BuilderOptionEnableConfig<Values extends BuilderOptionValues = BuilderOptionValues> = {
+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 = BuilderOptionValuesMap, MatchPath extends BuilderPath = BuilderPath> = {
+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 = BuilderOptionValues, UnlessPath extends BuilderPath = BuilderPath> = {
+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 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;
+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;
 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'];
+            [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): Builder<BuilderStateMerge<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 ReadonlyArray<BuilderValidPath<State['model']>>, const Name extends string>(gatePaths: GatePaths, name: Name, config: BuilderParameter): Builder<BuilderStateMerge<State, {
+            model: State['model'] & {
+                [K in Name]: string | OptionGatePathsNullable<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>>>;
+    };
+};
+declare function createEnable<const Values extends BuilderOptionValues>(values: Values): BuilderOptionEnableConfig<Values>;
+declare function createEnableParameter(): BuilderParameter;
+export declare const enable: typeof createEnable & {
+    parameter: typeof createEnableParameter;
+};
+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;
 };
-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;
+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;
+};
+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 ? {
+    model: State['model'] & {
+        [K in Name]: BuilderOptionValueType<BuilderOptionWhenConfigValues<Config>> | OptionWhenNullability<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'];
+};
 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 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 & {
     readonly unlessPath: Readonly<BuilderValidPath<Model>>;
 } : Config;
 export {};

package/dist/core/option/method.js

@@ -1,9 +1,23 @@
-export function enable(values) {
+import { BuilderParameter } from '../parameter.js';
+function createEnable(values) {
     return { type: 'enable', values };
 }
-export function match(matchPath, selectMap) {
-    return { type: 'match', matchPath, selectMap };
+function createEnableParameter() {
+    return new BuilderParameter();
 }
-export function unless(unlessPath, disabledValues, values) {
+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();
+}
+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,23 +1,29 @@
 import type { BuilderPaths } from '../../paths';
+import type { BuilderOptionValues } from '../../schemas/serialise';
 import type { BuilderOptionWhenConfig } from './method';
-import type { BuilderSelectType, BuilderSelectTypeValues } from './select';
-import type { BuilderToggleType } from './toggle';
+import type { BuilderParameter } from '../parameter';
+import type { BuilderSelectTypeValues } from './select';
 import * as v from 'valibot';
+import { BuilderSelectType } from './select.js';
+import { BuilderToggleType } from './toggle.js';
 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 { 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;
 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,10 @@
 import * as v from 'valibot';
+import { check } from '../../check.js';
 import { readPath } from '../../paths.js';
+import { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../../schemas/serialise.js';
+import { BuilderSelectType } from './select.js';
+import { BuilderToggleType } from './toggle.js';
+export { BuilderOptionValuesMapSchema, BuilderOptionValuesSchema } from '../../schemas/serialise.js';
 export class BuilderOption {
     name;
     values;
@@ -12,25 +17,32 @@ 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 this;
+            return resolved;
         }
         if (!this.gatePaths.every((path) => !!readPath(model, path))) {
             return null;
         }
         switch (this.config.type) {
             case 'enable': {
-                return this;
+                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 = this.config.selectMap[String(readPath(model, 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)
-                    ? this
+                    ? resolved
                     : null;
             }
         }