@builder-builder/builder 0.0.3 → 0.0.5

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,61 +1,70 @@
+import type { Prettify } from '../prettify';
 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 { BuilderOptionEntries, BuilderOptionMethod } from './option/index';
+import type { BuilderBindings, BuilderBoundState } from './parameter';
+import type { BuilderExpectationEntries, BuilderExpectations, ComponentAssert, ModelAssert } from './expectation';
 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>;
-export type BuilderSelectMapGeneric = BuilderSelectMap<any>;
 export type BuilderState = {
     readonly model: unknown;
     readonly options: BuilderOptionEntries;
     readonly components: BuilderComponentEntries;
     readonly collections: BuilderCollectionEntries;
+    readonly expectations: BuilderExpectationEntries;
 };
 export type BuilderStateEmpty = {
     readonly model: unknown;
     readonly options: [];
     readonly components: [];
     readonly collections: [];
+    readonly expectations: [];
 };
-import type { Prettify } from '../prettify';
 export type BuilderStateMerge<State extends BuilderState, Patch extends Partial<BuilderState>> = {
-    model: 'model' extends keyof Patch ? Patch['model'] : State['model'];
-    options: 'options' extends keyof Patch ? Patch['options'] : State['options'];
-    components: 'components' extends keyof Patch ? Patch['components'] : State['components'];
-    collections: 'collections' extends keyof Patch ? Patch['collections'] : State['collections'];
+    model: Prettify<'model' extends keyof Patch ? Patch['model'] : State['model']>;
+    options: Extract<'options' extends keyof Patch ? Patch['options'] : State['options'], BuilderOptionEntries>;
+    components: Extract<'components' extends keyof Patch ? Patch['components'] : State['components'], BuilderComponentEntries>;
+    collections: Extract<'collections' extends keyof Patch ? Patch['collections'] : State['collections'], BuilderCollectionEntries>;
+    expectations: Extract<'expectations' extends keyof Patch ? Patch['expectations'] : State['expectations'], BuilderExpectationEntries>;
 };
+export type BuilderMerge<State extends BuilderState, Patch extends Partial<BuilderState>> = Builder<BuilderStateMerge<State, Patch>>;
 export type BuilderGeneric = Builder<any>;
-export type BuilderFactory = (builder: BuilderGeneric) => BuilderGeneric;
-export type BuilderPart = BuilderGeneric | BuilderFactory;
-export type BuilderParts = ReadonlyArray<BuilderPart>;
+export type Builders = ReadonlyArray<BuilderGeneric>;
 export type BuilderStateOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? State : BuilderStateEmpty;
 export type BuilderModelOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? Prettify<State['model']> : never;
-export type BuilderCollectionsOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? State['collections'] : never;
 export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     #private;
     readonly _options: State['options'];
     readonly _components: State['components'];
     readonly _collections: State['collections'];
+    readonly _expectations: State['expectations'];
     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);
+    readonly expectations: BuilderExpectationEntries;
+    constructor(options?: BuilderOptionEntries, collections?: BuilderCollectionEntries, components?: BuilderComponentEntries, expectations?: BuilderExpectationEntries);
+    get optionGraph(): BuilderOptionGraph;
+    get componentGraph(): BuilderComponentGraph;
     get option(): BuilderOptionMethod<State>;
     get component(): BuilderComponentMethod<State>;
     get collection(): BuilderCollectionMethod<State>;
+    expect<const Expectations extends BuilderExpectations>(...expectations: Expectations): BuilderMerge<State, {
+        model: ModelAssert<Builder<State>, Expectations>;
+        components: ComponentAssert<Builder<State>, Expectations>;
+        expectations: [...State['expectations'], ...Expectations];
+    }>;
+    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;
-type MergedPartsState<Parts extends ReadonlyArray<BuilderPart>> = Parts extends readonly [
-    infer Head,
-    ...infer Tail extends ReadonlyArray<BuilderPart>
-] ? MergeStates<ExtractPartState<Head>, MergedPartsState<Tail>> : BuilderStateEmpty;
-type MergeStates<Left extends BuilderState, Right extends BuilderState> = {
+export declare function builder<const BuildersToMerge extends Builders>(...buildersToMerge: BuildersToMerge): Builder<MergedPartsState<BuildersToMerge>>;
+type MergedPartsState<Parts extends ReadonlyArray<BuilderGeneric>> = Parts extends readonly [
+    infer Head extends BuilderGeneric,
+    ...infer Tail extends ReadonlyArray<BuilderGeneric>
+] ? MergedStates<BuilderStateOf<Head>, MergedPartsState<Tail>> : BuilderStateEmpty;
+type MergedStates<Left extends BuilderState, Right extends BuilderState> = {
     model: Left['model'] & Right['model'];
     options: [...Left['options'], ...Right['options']];
     components: [...Left['components'], ...Right['components']];
     collections: [...Left['collections'], ...Right['collections']];
+    expectations: [...Left['expectations'], ...Right['expectations']];
 };
 export {};

package/dist/core/builder.js

@@ -1,72 +1,118 @@
-import { invariant } from '../invariant.js';
+import * as v from 'valibot';
+import { BuilderExpectation } from './expectation.js';
+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, bindOptions, extractValues } from './parameter.js';
 export class Builder {
     options;
     components;
     collections;
-    optionGraph;
-    componentGraph;
-    constructor(options = [], collections = [], components = [], optionGraph = new BuilderOptionGraph(), componentGraph = new BuilderComponentGraph()) {
+    expectations;
+    #optionGraph = null;
+    #componentGraph = null;
+    constructor(options = [], collections = [], components = [], expectations = []) {
         this.options = options;
         this.collections = collections;
         this.components = components;
-        this.optionGraph = optionGraph;
-        this.componentGraph = componentGraph;
+        this.expectations = expectations;
+    }
+    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);
+            if (v.is(v.instance(BuilderParameter), config)) {
+                const entry = new BuilderOption(name, config, gatePaths, null);
+                return this.#next([...this.options, entry], this.collections, this.components);
+            }
+            const entry = new BuilderOption(name, extractValues(config), gatePaths, config);
+            return this.#next([...this.options, entry], this.collections, this.components);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         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]);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         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);
         };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
         return Object.assign(addCollection, { when: addConditionalCollection });
     }
-    #next(options, collections, components, optionGraph, componentGraph) {
-        return new Builder(options, collections, components, optionGraph, componentGraph);
+    expect(...expectations) {
+        return new Builder(this.options, this.collections, this.components, [
+            ...this.expectations,
+            ...expectations
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
+        ]);
+    }
+    bind(bindings) {
+        const boundOptions = bindOptions(this.options, bindings);
+        return new Builder(boundOptions, this.collections, this.components, this.expectations);
+    }
+    #next(options, collections, components) {
+        return new Builder(options, collections, components, this.expectations);
     }
 }
-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 factories = parts.filter((part) => !(part instanceof Builder));
-    return factories.reduce((accumulated, factory) => {
-        return factory(accumulated);
-    }, base);
+export function builder(...buildersToMerge) {
+    const merged = new Builder(buildersToMerge.flatMap((builder) => builder.options), buildersToMerge.flatMap((builder) => builder.collections), buildersToMerge.flatMap((builder) => builder.components));
+    buildersToMerge
+        .flatMap((builder) => builder.expectations)
+        .forEach((expectation) => {
+        if (v.is(v.instance(BuilderExpectation), expectation)) {
+            if (expectation.kind === 'option') {
+                expectation.validate(merged.options);
+            }
+            else if (expectation.kind === 'component') {
+                expectation.validate(merged.components);
+            }
+        }
+    });
+    return merged;
 }

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

@@ -1,22 +1,18 @@
-import type { BuilderModel, BuilderModels } from '../../config';
+import type { BuilderModel, BuilderModels } from '../../model';
 import type { BuilderPaths } from '../../paths';
+import type { BuilderGeneric, BuilderModelOf, BuilderStateOf } from '../builder';
 import type { BuilderCollectionWhenConfig } from './method';
-import type { BuilderGeneric, BuilderStateOf } from '../builder';
 export type BuilderCollectionConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = {
     readonly builder: CollectionRecipe;
     readonly min: Min;
     readonly max: Max;
 };
 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>;
-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']>;
-type ExtractCollectionNames<Entries extends BuilderCollectionEntries> = Entries extends readonly [
-    infer Head extends BuilderCollection,
-    ...infer Tail extends BuilderCollectionEntries
-] ? Head['name'] | ExtractCollectionNames<Tail> : never;
-export type BuilderCollectionModelOf<CollectionRecipe, Min extends number, Max extends number> = number extends Min ? ReadonlyArray<ExtractModel<CollectionRecipe>> : number extends Max ? ReadonlyArray<ExtractModel<CollectionRecipe>> : Min extends Max ? BuilderTupleOf<ExtractModel<CollectionRecipe>, Min> : ReadonlyArray<ExtractModel<CollectionRecipe>>;
+export type TupleOf<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : TupleOf<Item, Length, [...Result, Item]>;
+export type CollectionShape<Item, Min extends number, Max extends number> = number extends Min ? ReadonlyArray<Item> : number extends Max ? ReadonlyArray<Item> : Min extends Max ? TupleOf<Item, Min> : ReadonlyArray<Item>;
+export type BuilderCollectionOf<Builder extends BuilderGeneric, Name extends string> = CollectionOf<BuilderStateOf<Builder>['collections'], Name>;
+export type BuilderCollectionNamesOf<Builder extends BuilderGeneric> = CollectionNamesOf<BuilderStateOf<Builder>['collections']>;
+export type BuilderCollectionModelOf<CollectionRecipe extends BuilderGeneric, Min extends number, Max extends number> = CollectionShape<BuilderModelOf<CollectionRecipe>, Min, Max>;
 export declare class BuilderCollection<const Name extends string = string, const CollectionRecipe = any, const Min extends number = number, const Max extends number = number> implements BuilderCollectionConfig<CollectionRecipe, Min, Max> {
     readonly name: Name;
     readonly builder: CollectionRecipe;
@@ -29,5 +25,6 @@ export declare class BuilderCollection<const Name extends string = string, const
 }
 export declare function resolveCollectionNames(collections: BuilderCollectionEntries): Set<string>;
 export declare function resolveCollectionModels(model: BuilderModel, collectionName: string): BuilderModels;
-type ExtractModel<Input> = Input extends BuilderGeneric ? BuilderStateOf<Input>['model'] : unknown;
+type CollectionOf<Config extends BuilderCollectionEntries, Name extends string> = Config extends readonly [infer Head, ...infer Tail extends BuilderCollectionEntries] ? Extract<Head, BuilderCollection<Name, any, any, any>> extends never ? CollectionOf<Tail, Name> : Extract<Head, BuilderCollection<Name, any, any, any>> : Extract<Config[number], BuilderCollection<Name, any, any, any>>;
+type CollectionNamesOf<Entries extends BuilderCollectionEntries> = Entries[number]['name'];
 export {};

package/dist/core/collection/collection.js

@@ -1,5 +1,5 @@
-import { invariant } from '../../invariant.js';
-import { readPath } from '../../paths.js';
+import { check } from '../../check.js';
+import { resolve } from '../when/index.js';
 export class BuilderCollection {
     name;
     builder;
@@ -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;
@@ -19,28 +19,10 @@ export class BuilderCollection {
         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 BuilderCollection(this.name, entry.builder, entry.min, entry.max) : null;
-            }
-            case 'unless': {
-                const value = readPath(model, this.config.unlessPath);
-                return !this.config.disabledValues.includes(value)
-                    ? this
-                    : null;
-            }
-        }
+        return resolve(this, model, (selectMap, matchValue) => {
+            const entry = selectMap[matchValue];
+            return entry ? new BuilderCollection(this.name, entry.builder, entry.min, entry.max) : null;
+        });
     }
 }
 export function resolveCollectionNames(collections) {

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

@@ -1,4 +1,4 @@
-export type { BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderTupleOf } from './collection';
+export type { BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, TupleOf, CollectionShape } from './collection';
 export type { BuilderCollectionEnableConfig, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './method';
 export { BuilderCollection, resolveCollectionModels, resolveCollectionNames } from './collection.js';
 export { collection } from './method.js';

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

@@ -1,51 +1,30 @@
-import type { BuilderPrimitive } from '../../config';
-import type { BuilderPath, BuilderPaths, BuilderResolvePath, BuilderValidPath } from '../../paths';
-import type { BuilderStateMerge, BuilderGeneric, BuilderState } from '../builder';
-import type { Builder } from '../builder';
+import type { BuilderPrimitive } from '../../model';
+import type { BuilderPath, BuilderValidPaths } from '../../paths';
+import type { BuilderGeneric, BuilderMerge, BuilderState } from '../builder';
+import type { BuilderWhenEnableConfig, BuilderWhenMatchConfig, BuilderWhenUnlessConfig, WhenConfigConstrained, WhenNullability } from '../when/index';
 import type { BuilderCollection, BuilderCollectionConfig, BuilderCollectionModelOf } from './collection';
-export type BuilderCollectionEnableConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = {
-    readonly type: 'enable';
-    readonly builder: CollectionRecipe;
-    readonly min: Min;
-    readonly max: Max;
-};
-export type BuilderCollectionMatchConfig<SelectMap extends Record<string, BuilderCollectionConfig | null> = Record<string, BuilderCollectionConfig | null>, MatchPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'match';
-    readonly matchPath: MatchPath;
-    readonly selectMap: SelectMap;
-};
-export type BuilderCollectionUnlessConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number, UnlessPath extends BuilderPath = BuilderPath> = {
-    readonly type: 'unless';
-    readonly unlessPath: UnlessPath;
-    readonly disabledValues: ReadonlyArray<BuilderPrimitive>;
-    readonly builder: CollectionRecipe;
-    readonly min: Min;
-    readonly max: Max;
-};
+export type BuilderCollectionEnableConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number> = BuilderWhenEnableConfig<BuilderCollectionConfig<CollectionRecipe, Min, Max>>;
+export type BuilderCollectionMatchConfig<SelectMap extends Record<string, BuilderCollectionConfig | null> = Record<string, BuilderCollectionConfig | null>, MatchPath extends BuilderPath = BuilderPath> = BuilderWhenMatchConfig<SelectMap, MatchPath>;
+export type BuilderCollectionUnlessConfig<CollectionRecipe = any, Min extends number = number, Max extends number = number, UnlessPath extends BuilderPath = BuilderPath> = BuilderWhenUnlessConfig<BuilderCollectionConfig<CollectionRecipe, Min, Max>, UnlessPath>;
 export type BuilderCollectionWhenConfig = BuilderCollectionEnableConfig | BuilderCollectionMatchConfig | BuilderCollectionUnlessConfig;
-export declare const collection: {
-    enable: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionEnableConfig<CollectionRecipe, Min, Max>;
-    match: <const MatchPath extends BuilderPath, const SelectMap extends Record<string, BuilderCollectionConfig | null>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderCollectionMatchConfig<SelectMap, MatchPath>;
-    unless: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionUnlessConfig<CollectionRecipe, Min, Max, UnlessPath>;
-};
-type CollectionWhenConfigModel<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? BuilderCollectionModelOf<(NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['builder'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['min'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['max']> : never;
-type CollectionWhenConfigResolver<Name extends string, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min, infer Max> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? BuilderCollection<Name, (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['builder'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['min'], (NonNullable<SelectMapType[keyof SelectMapType]> & BuilderCollectionConfig)['max']> : never;
-type CollectionConfigNullable<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionUnlessConfig ? null : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? null extends SelectMapType[keyof SelectMapType] ? null : never : never;
-type CollectionGatePathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [infer Head extends BuilderPath, ...infer Tail extends BuilderPaths] ? null extends BuilderResolvePath<Model, Head> ? null : CollectionGatePathsNullable<Model, Tail> : never;
-type CollectionWhenNullability<Model, GatePaths extends BuilderPaths, Config extends BuilderCollectionWhenConfig> = CollectionGatePathsNullable<Model, GatePaths> | CollectionConfigNullable<Config>;
-type CollectionWhenConfigConstrained<Model, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionMatchConfig ? Config & {
-    readonly matchPath: Readonly<BuilderValidPath<Model>>;
-} : Config extends BuilderCollectionUnlessConfig ? Config & {
-    readonly unlessPath: Readonly<BuilderValidPath<Model>>;
-} : Config;
 export type BuilderCollectionMethod<State extends BuilderState> = {
-    <const Name extends string, const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(name: Name, collectionRecipe: CollectionRecipe, min?: Min, max?: Max): Builder<BuilderStateMerge<State, {
+    <const Name extends string, const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(name: Name, collectionRecipe: CollectionRecipe, min?: Min, max?: Max): BuilderMerge<State, {
         model: State['model'] & Record<Name, BuilderCollectionModelOf<CollectionRecipe, Min, Max>>;
         collections: [...State['collections'], BuilderCollection<Name, CollectionRecipe, Min, Max>];
-    }>>;
-    when: <const GatePaths extends ReadonlyArray<BuilderValidPath<State['model']>>, const Name extends string, const Config extends BuilderCollectionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & CollectionWhenConfigConstrained<State['model'], Config>) => Builder<BuilderStateMerge<State, {
-        model: State['model'] & Record<Name, CollectionWhenConfigModel<Config> | CollectionWhenNullability<State['model'], GatePaths, Config>>;
+    }>;
+    when: <const GatePaths extends BuilderValidPaths<State['model']>, const Name extends string, const Config extends BuilderCollectionWhenConfig>(gatePaths: GatePaths, name: Name, config: Config & WhenConfigConstrained<State['model'], Config>) => BuilderMerge<State, {
+        model: State['model'] & Record<Name, CollectionWhenConfigModel<Config> | WhenNullability<State['model'], GatePaths, Config>>;
         collections: [...State['collections'], CollectionWhenConfigResolver<Name, Config>];
-    }>>;
+    }>;
+};
+export declare const collection: {
+    enable: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number>(builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionEnableConfig<CollectionRecipe, Min, Max>;
+    match: <const MatchPath extends BuilderPath, const SelectMap extends Record<string, BuilderCollectionConfig | null>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderCollectionMatchConfig<SelectMap, MatchPath>;
+    unless: <const CollectionRecipe extends BuilderGeneric, const Min extends number, const Max extends number, const UnlessPath extends BuilderPath>(unlessPath: UnlessPath, disabledValues: ReadonlyArray<BuilderPrimitive>, builder: CollectionRecipe, min: Min, max: Max) => BuilderCollectionUnlessConfig<CollectionRecipe, Min, Max, UnlessPath>;
 };
+type SelectMapEntryOf<SelectMap> = NonNullable<SelectMap[keyof SelectMap]> & BuilderCollectionConfig;
+type CollectionModelOfConfig<Config extends BuilderCollectionConfig> = BuilderCollectionModelOf<Config['builder'], Config['min'], Config['max']>;
+type CollectionOfConfig<Name extends string, Config extends BuilderCollectionConfig> = BuilderCollection<Name, Config['builder'], Config['min'], Config['max']>;
+type CollectionWhenConfigModel<Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput extends BuilderGeneric, infer Min extends number, infer Max extends number> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput extends BuilderGeneric, infer Min extends number, infer Max extends number> ? BuilderCollectionModelOf<BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? CollectionModelOfConfig<SelectMapEntryOf<SelectMapType>> : never;
+type CollectionWhenConfigResolver<Name extends string, Config extends BuilderCollectionWhenConfig> = Config extends BuilderCollectionEnableConfig<infer BuilderInput, infer Min extends number, infer Max extends number> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionUnlessConfig<infer BuilderInput, infer Min extends number, infer Max extends number> ? BuilderCollection<Name, BuilderInput, Min, Max> : Config extends BuilderCollectionMatchConfig<infer SelectMapType> ? CollectionOfConfig<Name, SelectMapEntryOf<SelectMapType>> : never;
 export {};

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

@@ -1,10 +1,7 @@
 import type { BuilderPaths } from '../../paths';
 export type BuilderComponentEntries = ReadonlyArray<BuilderComponent>;
 export type BuilderComponentMap = Record<string, BuilderComponent>;
-export type BuilderComponentNamesOf<Components extends BuilderComponentEntries> = Components extends readonly [
-    ...infer Init extends BuilderComponentEntries,
-    BuilderComponent<infer Name>
-] ? Name | BuilderComponentNamesOf<Init> : never;
+export type BuilderComponentNamesOf<Components extends BuilderComponentEntries> = Components[number]['name'];
 export declare class BuilderComponent<const Name extends string = string> {
     readonly name: Name;
     readonly paths: BuilderPaths;

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,19 +1,16 @@
-import { invariant } from '../../invariant.js';
+import { check } from '../../check.js';
+import { crossProduct } from '../graph.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 };
@@ -30,7 +27,7 @@ export class BuilderComponentGraph {
                 Array.from(graphPath.keys).every((key) => handledKeys.has(key));
             if (!isHandled) {
                 const componentModels = this.#createModels(graphPath, keys);
-                models = models.flatMap((model) => componentModels.map((pathModel) => ({ ...model, ...pathModel })));
+                models = crossProduct(models, componentModels);
                 handledKeys.add(graphPath.name);
                 graphPath.keys.forEach((key) => handledKeys.add(key));
             }
@@ -40,8 +37,8 @@ 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 (identity !== EMPTY_MODEL && !seen.has(identity)) {
                 seen.add(identity);
@@ -51,3 +48,4 @@ export class BuilderComponentGraph {
         return models;
     }
 }
+const EMPTY_MODEL = '{}';

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

@@ -1,13 +1,11 @@
-import type { BuilderValidPath } from '../../paths';
-import type { BuilderComponentNamesOf } from './component';
-import type { BuilderStateMerge, BuilderState } from '../builder';
-import type { Builder } from '../builder';
-import type { BuilderComponent } from './component';
+import type { BuilderValidPaths } from '../../paths';
+import type { BuilderMerge, BuilderState } from '../builder';
+import type { BuilderComponent, BuilderComponentNamesOf } from './component';
 export type BuilderComponentMethod<State extends BuilderState> = {
-    <const Name extends string>(name: Name, paths: ReadonlyArray<BuilderValidPath<State['model']>>): Builder<BuilderStateMerge<State, {
+    <const Name extends string>(name: Name, paths: BuilderValidPaths<State['model']>): BuilderMerge<State, {
         components: [...State['components'], BuilderComponent<Name>];
-    }>>;
-    when: <const Name extends string>(dependencies: ReadonlyArray<BuilderComponentNamesOf<State['components']>>, name: Name, paths: ReadonlyArray<BuilderValidPath<State['model']>>) => Builder<BuilderStateMerge<State, {
+    }>;
+    when: <const Name extends string>(dependencies: ReadonlyArray<BuilderComponentNamesOf<State['components']>>, name: Name, paths: BuilderValidPaths<State['model']>) => BuilderMerge<State, {
         components: [...State['components'], BuilderComponent<Name>];
-    }>>;
+    }>;
 };

package/dist/core/expectation.d.ts

@@ -0,0 +1,39 @@
+import type { BuilderGeneric, BuilderMerge, BuilderStateOf } from './builder';
+import type { Prettify } from '../prettify';
+import { BuilderComponent } from './component/index.js';
+export type BuilderExpectationKind = 'option' | 'component';
+export type BuilderExpectationEntries = ReadonlyArray<BuilderExpectation>;
+export type BuilderExpectations = readonly [
+    BuilderExpectation,
+    ...ReadonlyArray<BuilderExpectation>
+];
+export type BuilderModelAsserted<BuilderInput extends BuilderGeneric, Expectations extends BuilderExpectations> = BuilderMerge<BuilderStateOf<BuilderInput>, {
+    model: ModelAssert<BuilderInput, Expectations>;
+    components: ComponentAssert<BuilderInput, Expectations>;
+}>;
+export type ModelAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedModel<Items> = ExpectedModel<Items>> = unknown extends Current['model'] ? Prettify<Asserted> : Prettify<Current['model'] & Asserted>;
+export type ComponentAssert<BuilderInput extends BuilderGeneric, Items extends BuilderExpectations, Current extends BuilderStateOf<BuilderInput> = BuilderStateOf<BuilderInput>, Asserted extends ExpectedComponents<Items> = ExpectedComponents<Items>> = Current['components'] extends [] ? ExpectedComponents<Items> : number extends Asserted['length'] ? Asserted : [...Current['components'], ...Asserted];
+export declare class BuilderExpectation<Name extends string = string, Value = unknown> {
+    readonly name: Name;
+    readonly kind: BuilderExpectationKind;
+    constructor(name: Name, kind: BuilderExpectationKind);
+    optional(): BuilderExpectation<Name, Value | null>;
+    validate(entries: ReadonlyArray<{
+        readonly name: string;
+    }>): void;
+}
+export declare const option: {
+    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, string>;
+};
+export declare const component: {
+    expect: <const Name extends string>(name: Name) => BuilderExpectation<Name, never>;
+};
+type ExpectedModel<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
+    infer Head,
+    ...infer Tail extends ReadonlyArray<BuilderExpectation>
+] ? (Head extends BuilderExpectation<infer Name, infer Value> ? [Value] extends [never] ? unknown : Record<Name, Value> : unknown) & ExpectedModel<Tail> : unknown;
+type ExpectedComponents<Items extends ReadonlyArray<BuilderExpectation>> = Items extends readonly [
+    infer Head,
+    ...infer Tail extends ReadonlyArray<BuilderExpectation>
+] ? Head extends BuilderExpectation<infer Name, ReadonlyArray<any>> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
+export {};

package/dist/{assert → core}/expectation.js

@@ -1,4 +1,5 @@
-import { invariant } from '../invariant.js';
+import { BuilderComponent } from './component/index.js';
+import { check } from '../check.js';
 export class BuilderExpectation {
     name;
     kind;
@@ -10,7 +11,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 = {