@builder-builder/builder 0.0.1

package/README.md

@@ -0,0 +1,38 @@
+# sv
+
+Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+## Building
+
+To create a production version of your app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

package/dist/assert/assert.d.ts

@@ -0,0 +1,28 @@
+import type { BuilderStateMerge, BuilderGeneric, BuilderStateOf } from '../core/index';
+import type { Prettify } from '../prettify';
+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 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 declare const assert: {
+    builder: typeof assertBuilder;
+    ui: typeof assertUI;
+};
+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>;
+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];
+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, Array<any>> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
+export {};

package/dist/assert/assert.js

@@ -0,0 +1,28 @@
+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);
+            }
+            else if (item.kind === 'component') {
+                item.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);
+        }
+    });
+    return ui;
+}
+export const assert = {
+    builder: assertBuilder,
+    ui: assertUI
+};

package/dist/assert/expectation.d.ts

@@ -0,0 +1,20 @@
+import type { BuilderComponentEntries, BuilderOptionEntries } from '../core/index';
+export type BuilderExpectationKind = 'option' | 'component';
+export type BuilderExpectationEntries = BuilderOptionEntries | BuilderComponentEntries;
+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: BuilderExpectationEntries): void;
+}
+export type BuilderExpectations = readonly [
+    BuilderExpectation,
+    ...ReadonlyArray<BuilderExpectation>
+];
+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>;
+};

package/dist/assert/expectation.js

@@ -0,0 +1,21 @@
+import { invariant } from '../invariant.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) {
+        invariant(entries.some((entry) => entry.name === this.name), `assert: no \`${this.kind}\` named '${this.name}' exists in the builder config! ❌`);
+    }
+}
+export const option = {
+    expect: (name) => new BuilderExpectation(name, 'option')
+};
+export const component = {
+    expect: (name) => new BuilderExpectation(name, 'component')
+};

package/dist/assert/index.d.ts

@@ -0,0 +1,3 @@
+export type { BuilderExpectations } from './expectation';
+export { assert } from './assert.js';
+export { BuilderExpectation, component, option } from './expectation.js';

package/dist/assert/index.js

@@ -0,0 +1,2 @@
+export { assert } from './assert.js';
+export { BuilderExpectation, component, option } from './expectation.js';

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+import type { BuilderPrimitive } from './schemas/index';
+export type { BuilderPrimitive, BuilderPrimitives } from './schemas/index';
+export type BuilderModel = {
+    readonly [key: string]: BuilderPrimitive | BuilderModels;
+};
+export type BuilderModelMutable = Record<string, unknown>;
+export type BuilderModels = ReadonlyArray<BuilderModel>;
+export type BuilderVariant = {
+    readonly model: BuilderModel;
+    readonly price?: string;
+    readonly image?: string;
+};
+export type BuilderVariants = ReadonlyArray<BuilderVariant>;
+export type BuilderData = Readonly<Record<string, BuilderVariants>>;

package/dist/config.js

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

package/dist/core/builder.d.ts

@@ -0,0 +1,61 @@
+import type { BuilderCollectionEntries, BuilderCollectionMethod } from './collection/index';
+import type { BuilderComponentEntries, BuilderComponentMethod } from './component/index';
+import type { BuilderOptionEntries, BuilderOptionMethod, BuilderOptionValues, BuilderSelectType } from './option/index';
+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;
+};
+export type BuilderStateEmpty = {
+    readonly model: unknown;
+    readonly options: [];
+    readonly components: [];
+    readonly collections: [];
+};
+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'];
+};
+export type BuilderGeneric = Builder<any>;
+export type BuilderFactory = (builder: BuilderGeneric) => BuilderGeneric;
+export type BuilderPart = BuilderGeneric | BuilderFactory;
+export type BuilderParts = ReadonlyArray<BuilderPart>;
+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 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);
+    get option(): BuilderOptionMethod<State>;
+    get component(): BuilderComponentMethod<State>;
+    get collection(): BuilderCollectionMethod<State>;
+}
+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> = {
+    model: Left['model'] & Right['model'];
+    options: [...Left['options'], ...Right['options']];
+    components: [...Left['components'], ...Right['components']];
+    collections: [...Left['collections'], ...Right['collections']];
+};
+export {};

package/dist/core/builder.js

@@ -0,0 +1,72 @@
+import { invariant } from '../invariant.js';
+import { BuilderCollection, resolveCollectionNames } from './collection/index.js';
+import { BuilderComponent, BuilderComponentGraph } from './component/index.js';
+import { BuilderOption, BuilderOptionGraph } from './option/index.js';
+export class Builder {
+    options;
+    components;
+    collections;
+    optionGraph;
+    componentGraph;
+    constructor(options = [], collections = [], components = [], optionGraph = new BuilderOptionGraph(), componentGraph = new BuilderComponentGraph()) {
+        this.options = options;
+        this.collections = collections;
+        this.components = components;
+        this.optionGraph = optionGraph;
+        this.componentGraph = 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);
+        };
+        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);
+        };
+        return Object.assign(addOption, { when: addConditionalOption });
+    }
+    get component() {
+        const addComponent = (name, paths) => {
+            const entry = new BuilderComponent(name, paths);
+            return this.#next(this.options, this.collections, [...this.components, entry], this.optionGraph, this.componentGraph.add(entry, this.optionGraph));
+        };
+        const addConditionalComponent = (dependencies, name, paths) => {
+            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 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}'! ❌`);
+            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));
+        };
+        const addConditionalCollection = (gatePaths, name, config) => {
+            const existing = resolveCollectionNames(this.collections);
+            invariant(!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 Object.assign(addCollection, { when: addConditionalCollection });
+    }
+    #next(options, collections, components, optionGraph, componentGraph) {
+        return new Builder(options, collections, components, optionGraph, componentGraph);
+    }
+}
+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);
+}

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

@@ -0,0 +1,33 @@
+import type { BuilderModel, BuilderModels } from '../../config';
+import type { BuilderPaths } from '../../paths';
+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 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 ExtractModel<Input> = Input extends BuilderGeneric ? BuilderStateOf<Input>['model'] : unknown;
+export {};

package/dist/core/collection/collection.js

@@ -0,0 +1,55 @@
+import { invariant } from '../../invariant.js';
+import { readPath } from '../../paths.js';
+export class BuilderCollection {
+    name;
+    builder;
+    min;
+    max;
+    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)}! ❌`);
+        this.name = name;
+        this.builder = builder;
+        this.min = min;
+        this.max = max;
+        this.gatePaths = gatePaths;
+        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;
+            }
+        }
+    }
+}
+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

@@ -0,0 +1,4 @@
+export type { BuilderCollectionConfig, BuilderCollectionEntries, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderTupleOf } 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

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

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

@@ -0,0 +1,51 @@
+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 { 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 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, {
+        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>>;
+        collections: [...State['collections'], CollectionWhenConfigResolver<Name, Config>];
+    }>>;
+};
+export {};

package/dist/core/collection/method.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,14 @@
+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 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>);
+    resolve(resolved: BuilderComponentMap): BuilderComponent<Name> | null;
+}

package/dist/core/component/component.js

@@ -0,0 +1,17 @@
+export class BuilderComponent {
+    name;
+    paths;
+    dependencies;
+    constructor(name, paths, dependencies = []) {
+        this.name = name;
+        this.paths = paths;
+        this.dependencies = dependencies;
+    }
+    resolve(resolved) {
+        if (this.dependencies.length === 0) {
+            return this;
+        }
+        const ready = this.dependencies.every((dependency) => !!resolved[dependency]);
+        return ready ? this : null;
+    }
+}

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

@@ -0,0 +1,13 @@
+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);
+    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

@@ -0,0 +1,52 @@
+import { invariant } from '../../invariant.js';
+import { BuilderComponent } from './component.js';
+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}'! ❌`);
+        const keys = new Set(component.paths.map((path) => String(path[0])));
+        const models = this.#mergeModels(keys, options);
+        const newPath = { name: component.name, keys, models };
+        return new BuilderComponentGraph([...this.paths, newPath]);
+    }
+    #mergeModels(keys, options) {
+        const graphPaths = Array.from(keys)
+            .map((key) => options.get(key))
+            .sort((pathA, pathB) => pathB.keys.size - pathA.keys.size);
+        const handledKeys = new Set();
+        let models = [{}];
+        graphPaths.forEach((graphPath) => {
+            const isHandled = handledKeys.has(graphPath.name) &&
+                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 })));
+                handledKeys.add(graphPath.name);
+                graphPath.keys.forEach((key) => handledKeys.add(key));
+            }
+        });
+        return models;
+    }
+    #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));
+            const identity = JSON.stringify(picked);
+            if (!seen.has(identity)) {
+                seen.add(identity);
+                models.push(picked);
+            }
+        });
+        return models;
+    }
+}

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

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

package/dist/core/component/index.js

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

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

@@ -0,0 +1,13 @@
+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';
+export type BuilderComponentMethod<State extends BuilderState> = {
+    <const Name extends string>(name: Name, paths: ReadonlyArray<BuilderValidPath<State['model']>>): Builder<BuilderStateMerge<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, {
+        components: [...State['components'], BuilderComponent<Name>];
+    }>>;
+};

package/dist/core/component/method.js

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

package/dist/core/graph.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderModels } from '../config';
+export type GraphKeys = ReadonlySet<string>;
+export type GraphPath = {
+    name: string;
+    keys: GraphKeys;
+    models: BuilderModels;
+};
+export type GraphPaths = ReadonlyArray<GraphPath>;

package/dist/core/graph.js

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

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig, BuilderTupleOf } from './collection/index';
+export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentMethod, BuilderComponentNamesOf } from './component/index';
+export type { BuilderOptionEnableConfig, BuilderOptionEntries, BuilderOptionGraphs, BuilderOptionMatchConfig, BuilderOptionMethod, BuilderOptionUnlessConfig, BuilderOptionValues, BuilderOptionWhenConfig, BuilderSelectTypeGeneric, BuilderSelectTypeLabels, BuilderSelectTypeValues, BuilderToggleTypeGeneric, BuilderOptionValueSchema } from './option/index';
+export type { BuilderStateMerge, BuilderFactory, BuilderGeneric, BuilderModelOf, BuilderPart, BuilderParts, BuilderState, BuilderStateEmpty, BuilderStateOf, BuilderSelectMap, BuilderSelectMapGeneric } from './builder';
+export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
+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';

package/dist/core/index.js

@@ -0,0 +1,4 @@
+export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
+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';