@builder-builder/builder 0.0.6 → 0.0.8

package/dist/core/builder.d.ts

@@ -1,70 +0,0 @@
-import type { Prettify } from '../prettify';
-import type { BuilderCollectionEntries, BuilderCollectionMethod } from './collection/index';
-import type { BuilderComponentEntries, BuilderComponentMethod } from './component/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 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: [];
-};
-export type BuilderStateMerge<State extends BuilderState, Patch extends Partial<BuilderState>> = {
-    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 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 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 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 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,124 +0,0 @@
-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;
-    expectations;
-    #optionGraph = null;
-    #componentGraph = null;
-    constructor(options = [], collections = [], components = [], expectations = []) {
-        this.options = options;
-        this.collections = collections;
-        this.components = components;
-        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 existingNames = new Set(this.options.map((entry) => entry.name));
-        const addOption = (name, values) => {
-            check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
-            const entry = new BuilderOption(name, values);
-            return this.#next([...this.options, entry], this.collections, this.components);
-        };
-        const addConditionalOption = (gatePaths, name, config) => {
-            check.falsy(existingNames.has(name), `Duplicate option name '${name}'! ❌`);
-            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]);
-        };
-        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]);
-        };
-        // 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);
-            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);
-        };
-        const addConditionalCollection = (gatePaths, name, config) => {
-            const existing = resolveCollectionNames(this.collections);
-            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);
-        };
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- bridges loose implementation to strict overloaded type
-        return Object.assign(addCollection, { when: addConditionalCollection });
-    }
-    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(...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);
-            }
-            else if (expectation.kind === 'collection') {
-                expectation.validate(merged.collections);
-            }
-        }
-    });
-    return merged;
-}

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

@@ -1,32 +0,0 @@
-import type { BuilderModel, BuilderModels } from '../../model';
-import type { BuilderPaths } from '../../paths';
-import type { BuilderGeneric, BuilderModelOf, BuilderStateOf } from '../builder';
-import type { BuilderCollectionWhenConfig } from './method';
-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 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 | null> = [Builder] extends [
-    BuilderGeneric
-] ? CollectionNamesOf<BuilderStateOf<Builder>['collections']> : never;
-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;
-    readonly min: Min;
-    readonly max: Max;
-    readonly gatePaths: BuilderPaths;
-    readonly config: BuilderCollectionWhenConfig | null;
-    constructor(name: Name, builder: CollectionRecipe, min?: Min, max?: Max, gatePaths?: BuilderPaths, config?: BuilderCollectionWhenConfig | null);
-    resolve(model: unknown): BuilderCollection<Name> | null;
-}
-export declare function resolveCollectionNames(collections: BuilderCollectionEntries): Set<string>;
-export declare function resolveCollectionModels(model: BuilderModel, collectionName: string): BuilderModels;
-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,37 +0,0 @@
-import { check } from '../../check.js';
-import { resolve } from '../when/index.js';
-export class BuilderCollection {
-    name;
-    builder;
-    min;
-    max;
-    gatePaths;
-    config;
-    constructor(name, builder, min = 0, max = Infinity, gatePaths = [], config = null) {
-        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;
-        this.max = max;
-        this.gatePaths = gatePaths;
-        this.config = config;
-    }
-    resolve(model) {
-        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) {
-    return new Set(collections.map((collection) => collection.name));
-}
-export function resolveCollectionModels(model, collectionName) {
-    const value = model[collectionName];
-    if (!Array.isArray(value)) {
-        throw new Error(`Expected array for collection '${collectionName}', got ${typeof value}! ❌`);
-    }
-    return value;
-}

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

@@ -1,4 +0,0 @@
-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/index.js

@@ -1,2 +0,0 @@
-export { BuilderCollection, resolveCollectionModels, resolveCollectionNames } from './collection.js';
-export { collection } from './method.js';

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

@@ -1,30 +0,0 @@
-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> = 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 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): BuilderMerge<State, {
-        model: State['model'] & Record<Name, BuilderCollectionModelOf<CollectionRecipe, Min, Max>>;
-        collections: [...State['collections'], BuilderCollection<Name, CollectionRecipe, Min, Max>];
-    }>;
-    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/collection/method.js

@@ -1,11 +0,0 @@
-export const collection = {
-    enable: (builder, min, max) => {
-        return { type: 'enable', builder, min, max };
-    },
-    match: (matchPath, selectMap) => {
-        return { type: 'match', matchPath, selectMap };
-    },
-    unless: (unlessPath, disabledValues, builder, min, max) => {
-        return { type: 'unless', unlessPath, disabledValues, builder, min, max };
-    }
-};

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

@@ -1,9 +0,0 @@
-import type { BuilderPaths } from '../../paths';
-export type BuilderComponentEntries = ReadonlyArray<BuilderComponent>;
-export type BuilderComponentNamesOf<Components extends BuilderComponentEntries> = Components[number]['name'];
-export declare class BuilderComponent<const Name extends string = string> {
-    readonly name: Name;
-    readonly paths: BuilderPaths;
-    readonly dependencies: ReadonlyArray<string>;
-    constructor(name: Name, paths: BuilderPaths, dependencies?: ReadonlyArray<string>);
-}

package/dist/core/component/component.js

@@ -1,10 +0,0 @@
-export class BuilderComponent {
-    name;
-    paths;
-    dependencies;
-    constructor(name, paths, dependencies = []) {
-        this.name = name;
-        this.paths = paths;
-        this.dependencies = dependencies;
-    }
-}

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

@@ -1,9 +0,0 @@
-import type { GraphPaths } from '../graph';
-import type { BuilderOptionGraph } from '../option/index';
-import { BuilderComponent } from './component.js';
-export declare class BuilderComponentGraph {
-    #private;
-    readonly paths: GraphPaths;
-    constructor(paths?: GraphPaths);
-    add(component: BuilderComponent, options: BuilderOptionGraph): BuilderComponentGraph;
-}

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

@@ -1,4 +0,0 @@
-export type { BuilderComponentEntries, BuilderComponentNamesOf } from './component';
-export type { BuilderComponentMethod } from './method';
-export { BuilderComponent } from './component.js';
-export { BuilderComponentGraph } from './graph.js';

package/dist/core/component/index.js

@@ -1,2 +0,0 @@
-export { BuilderComponent } from './component.js';
-export { BuilderComponentGraph } from './graph.js';

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

@@ -1,11 +0,0 @@
-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: BuilderValidPaths<State['model']>): BuilderMerge<State, {
-        components: [...State['components'], BuilderComponent<Name>];
-    }>;
-    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

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

package/dist/core/expectation.js

@@ -1,22 +0,0 @@
-import { BuilderCollection } from './collection/index.js';
-import { BuilderComponent } from './component/index.js';
-import { check } from '../check.js';
-export class BuilderExpectation {
-    name;
-    kind;
-    constructor(name, kind) {
-        this.name = name;
-        this.kind = kind;
-    }
-    optional() {
-        return new BuilderExpectation(this.name, this.kind);
-    }
-    validate(entries) {
-        check.truthy(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
-    }
-}
-export const has = {
-    option: (name) => new BuilderExpectation(name, 'option'),
-    component: (name) => new BuilderExpectation(name, 'component'),
-    collection: (name) => new BuilderExpectation(name, 'collection')
-};

package/dist/core/graph.js

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

package/dist/core/index.d.ts

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

package/dist/core/index.js

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

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

@@ -1,10 +0,0 @@
-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);
-    get(name: string): GraphPath;
-    add(option: BuilderOption): BuilderOptionGraph;
-}

package/dist/core/option/graph.js

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

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

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

package/dist/core/option/index.js

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