@builder-builder/builder 0.0.5 → 0.0.6

package/dist/core/builder.js

@@ -35,11 +35,14 @@ export class Builder {
         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);
@@ -112,6 +115,9 @@ export function builder(...buildersToMerge) {
             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

@@ -11,7 +11,9 @@ 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> = CollectionNamesOf<BuilderStateOf<Builder>['collections']>;
+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;

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

@@ -1,11 +1,9 @@
 import type { BuilderPaths } from '../../paths';
 export type BuilderComponentEntries = ReadonlyArray<BuilderComponent>;
-export type BuilderComponentMap = Record<string, 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>);
-    resolve(resolved: BuilderComponentMap): BuilderComponent<Name> | null;
 }

package/dist/core/component/component.js

@@ -7,11 +7,4 @@ export class BuilderComponent {
         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

@@ -5,6 +5,5 @@ export declare class BuilderComponentGraph {
     #private;
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
-    has(name: string): boolean;
     add(component: BuilderComponent, options: BuilderOptionGraph): BuilderComponentGraph;
 }

package/dist/core/component/graph.js

@@ -6,16 +6,16 @@ export class BuilderComponentGraph {
     constructor(paths = []) {
         this.paths = paths;
     }
-    has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     add(component, options) {
-        check.falsy(this.has(component.name), `Duplicate component name '${component.name}'! ❌`);
-        const keys = new Set(component.paths.map((path) => String(path[0])));
+        check.falsy(this.#has(component.name), `Duplicate component name '${component.name}'! ❌`);
+        const keys = new Set(component.paths.map(([first]) => String(first)));
         const models = this.#mergeModels(keys, options);
         const newPath = { name: component.name, keys, models };
         return new BuilderComponentGraph([...this.paths, newPath]);
     }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
     #mergeModels(keys, options) {
         const graphPaths = Array.from(keys)
             .map((key) => options.get(key))

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

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

package/dist/core/expectation.d.ts

@@ -1,39 +1,45 @@
 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';
+export type BuilderExpectationKind = 'option' | 'component' | 'collection';
 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 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 declare class BuilderExpectation<Name extends string = string, Value = unknown> {
+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: BuilderExpectationKind;
-    constructor(name: Name, kind: BuilderExpectationKind);
-    optional(): BuilderExpectation<Name, Value | null>;
+    readonly kind: Kind;
+    constructor(name: Name, kind: Kind);
+    optional(): BuilderExpectation<Name, Value | null, Kind>;
     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>;
+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> ? [Value] extends [never] ? unknown : Record<Name, Value> : unknown) & ExpectedModel<Tail> : unknown;
+] ? (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, ReadonlyArray<any>> ? [BuilderComponent<Name>, ...ExpectedComponents<Tail>] : ExpectedComponents<Tail> : [];
+] ? 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,3 +1,4 @@
+import { BuilderCollection } from './collection/index.js';
 import { BuilderComponent } from './component/index.js';
 import { check } from '../check.js';
 export class BuilderExpectation {
@@ -14,9 +15,8 @@ export class BuilderExpectation {
         check.truthy(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')
+export const has = {
+    option: (name) => new BuilderExpectation(name, 'option'),
+    component: (name) => new BuilderExpectation(name, 'component'),
+    collection: (name) => new BuilderExpectation(name, 'collection')
 };

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 export type { BuilderCollectionConfig, BuilderCollectionEnableConfig, BuilderCollectionEntries, BuilderCollectionMatchConfig, BuilderCollectionMethod, BuilderCollectionModelOf, BuilderCollectionNamesOf, BuilderCollectionOf, BuilderCollectionUnlessConfig, BuilderCollectionWhenConfig } from './collection/index';
-export type { BuilderComponentEntries, BuilderComponentMap, BuilderComponentMethod, BuilderComponentNamesOf } from './component/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';
@@ -7,6 +7,6 @@ export type { BuilderMerge, BuilderGeneric, BuilderModelOf, Builders, BuilderSta
 export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
-export { BuilderExpectation, component, option } from './expectation.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 +1,6 @@
 export { Builder, builder } from './builder.js';
 export { BuilderCollection, collection, resolveCollectionModels, resolveCollectionNames } from './collection/index.js';
 export { BuilderComponent, BuilderComponentGraph } from './component/index.js';
-export { BuilderExpectation, component, option } from './expectation.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

@@ -2,10 +2,9 @@ import type { GraphPath, GraphPaths } from '../graph';
 import { BuilderOption } from './option.js';
 export type BuilderOptionGraphs = ReadonlyArray<BuilderOptionGraph>;
 export declare class BuilderOptionGraph {
+    #private;
     readonly paths: GraphPaths;
     constructor(paths?: GraphPaths);
-    static merge(...graphs: BuilderOptionGraphs): BuilderOptionGraph;
-    has(name: string): boolean;
     get(name: string): GraphPath;
     add(option: BuilderOption): BuilderOptionGraph;
 }

package/dist/core/option/graph.js

@@ -8,18 +8,13 @@ export class BuilderOptionGraph {
     constructor(paths = []) {
         this.paths = paths;
     }
-    static merge(...graphs) {
-        return new BuilderOptionGraph(graphs.flatMap((graph) => graph.paths));
-    }
-    has(name) {
-        return this.paths.some((graphPath) => graphPath.name === name);
-    }
     get(name) {
         const graphPath = this.paths.find((graphPath) => graphPath.name === name);
         check.truthy(graphPath, `Option '${name}' not found in graph! ❌`);
         return graphPath;
     }
     add(option) {
+        check.falsy(this.#has(option.name), `Duplicate option name '${option.name}'! ❌`);
         const dependencyKeys = option.dependencyKeys();
         if (dependencyKeys.length === 0) {
             const values = optionValues(option);
@@ -50,6 +45,9 @@ export class BuilderOptionGraph {
             { name: option.name, keys: merged.keys, models: finalModels }
         ]);
     }
+    #has(name) {
+        return this.paths.some((graphPath) => graphPath.name === name);
+    }
 }
 function mergePaths(dependencyKeys, graphPaths) {
     const dependencyPaths = Array.from(dependencyKeys).map((dependencyKey) => {

package/dist/core/option/option.js

@@ -28,13 +28,14 @@ export class BuilderOption {
         });
     }
     dependencyKeys() {
-        const keys = new Set(this.gatePaths.map((path) => String(path[0])));
+        const keys = new Set(this.gatePaths.map(([first]) => String(first)));
         if (this.config?.type === 'match') {
-            const matchPath = this.config.matchPath;
-            keys.add(String(matchPath[0]));
+            const [firstMatchSegment] = this.config.matchPath;
+            keys.add(String(firstMatchSegment));
         }
         else if (this.config?.type === 'unless') {
-            keys.add(String(this.config.unlessPath[0]));
+            const [firstUnlessSegment] = this.config.unlessPath;
+            keys.add(String(firstUnlessSegment));
         }
         return Array.from(keys);
     }

package/dist/index.d.ts

@@ -4,9 +4,9 @@ export type { BuilderModelPaths, BuilderResolvePath, BuilderValidPath } from './
 export type { BuilderPath, BuilderPaths } from './schemas/index';
 export type { BuilderDataValidated, BuilderDescription, BuilderDescriptionItem, BuilderErrorComponentMissing, BuilderErrorComponentUnexpected, BuilderErrorsValidate, BuilderErrorValidate, BuilderErrorVariantInvalid, BuilderErrorVariantMissing, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderValidateResult } from './resolve/index';
 export type { BuilderUICollection, BuilderUIDescribe, BuilderUIItem, BuilderUIItems, BuilderUIPage } from './schemas/index';
-export type { BuilderUI, BuilderUIFactory, BuilderUIs } from './ui';
+export type { BuilderUI, BuilderUIs } from './ui';
 export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
-export { BuilderExpectation, component, option } from './core/index.js';
+export { BuilderExpectation, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
 export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
 export { deserialise, serialise } from './serialise/index.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { BuilderExpectation, component, option } from './core/index.js';
+export { BuilderExpectation, has } from './core/index.js';
 export { builder, BuilderCollection, BuilderComponent, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType, collection, enable, match, select, toggleBoolean, toggleNumber, toggleString, unless } from './core/index.js';
 export { instance, models, order, ordinal, render, validate } from './resolve/index.js';
 export { deserialise, serialise } from './serialise/index.js';

package/dist/paths.d.ts

@@ -5,7 +5,9 @@ export type BuilderValidPath<Model, Depth extends ReadonlyArray<never> = []> = D
     [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...BuilderValidPath<Model[Key], [...Depth, never]>]);
 }[keyof Model & string];
 export type BuilderValidPaths<Model> = ReadonlyArray<BuilderValidPath<Model>>;
-export type BuilderModelPaths<Builder extends BuilderGeneric> = BuilderValidPaths<BuilderModelOf<Builder>>;
+export type BuilderModelPaths<Builder extends BuilderGeneric | null> = [Builder] extends [
+    BuilderGeneric
+] ? BuilderValidPaths<BuilderModelOf<Builder>> : ReadonlyArray<never>;
 export type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
     infer Head extends keyof Model & string
 ] ? Model[Head] : Path extends readonly [

package/dist/resolve/order.js

@@ -1,15 +1,15 @@
 import { resolveCollectionModels } from '../core/index.js';
+import { check } from '../check.js';
 export function order(builder, model, componentModels) {
     const result = {};
-    const resolved = {};
+    const resolved = new Set();
     builder.components.forEach((component) => {
-        const active = component.resolve(resolved);
-        if (!active) {
-            return;
-        }
-        resolved[active.name] = active;
-        const variants = componentModels[active.name] ?? [];
-        result[active.name] =
+        component.dependencies.forEach((dependency) => {
+            check.truthy(resolved.has(dependency), `Component '${component.name}' depends on '${dependency}' which has not been resolved! ❌`);
+        });
+        resolved.add(component.name);
+        const variants = componentModels[component.name] ?? [];
+        result[component.name] =
             variants.find((variant) => Object.entries(variant.model).every(([key, value]) => model[key] === value)) ?? null;
     });
     builder.collections.forEach((entry) => {

package/dist/serialise/schemas.d.ts

@@ -40,7 +40,7 @@ export type BuilderCollectionSerialised = {
 };
 export type BuilderExpectationSerialised = {
     readonly name: string;
-    readonly kind: 'option' | 'component';
+    readonly kind: 'option' | 'component' | 'collection';
 };
 export type BuilderSerialised = {
     readonly options: ReadonlyArray<BuilderOptionSerialised>;
@@ -1133,10 +1133,10 @@ export declare const BuilderCollectionSerialisedSchema: v.SchemaWithPipe<readonl
 }>]>;
 export declare const BuilderExpectationSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
-    readonly kind: v.PicklistSchema<["option", "component"], undefined>;
+    readonly kind: v.PicklistSchema<["option", "component", "collection"], undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
-    kind: "option" | "component";
+    kind: "collection" | "option" | "component";
 }>]>;
 export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -1669,13 +1669,13 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
     }[]>]>;
     readonly expectations: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly name: v.StringSchema<undefined>;
-        readonly kind: v.PicklistSchema<["option", "component"], undefined>;
+        readonly kind: v.PicklistSchema<["option", "component", "collection"], undefined>;
     }, undefined>, v.ReadonlyAction<{
         name: string;
-        kind: "option" | "component";
+        kind: "collection" | "option" | "component";
     }>]>, undefined>, v.ReadonlyAction<Readonly<{
         name: string;
-        kind: "option" | "component";
+        kind: "collection" | "option" | "component";
     }>[]>]>;
 }, undefined>, v.ReadonlyAction<{
     readonly options: readonly Readonly<{
@@ -1795,7 +1795,7 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
     }[];
     readonly expectations: readonly Readonly<{
         name: string;
-        kind: "option" | "component";
+        kind: "collection" | "option" | "component";
     }>[];
 }>]>;
 export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{

package/dist/serialise/schemas.js

@@ -118,7 +118,7 @@ export const BuilderCollectionWhenConfigSerialisedSchema = v.pipe(v.variant('typ
 export const BuilderCollectionSerialisedSchema = v.pipe(BuilderSerialisedCollectionObject, v.readonly());
 export const BuilderExpectationSerialisedSchema = v.pipe(v.object({
     name: v.string(),
-    kind: v.picklist(['option', 'component'])
+    kind: v.picklist(['option', 'component', 'collection'])
 }), v.readonly());
 export const BuilderSerialisedSchema = v.pipe(v.object({
     options: v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly()),

package/dist/ui.d.ts

@@ -1,11 +1,10 @@
 import type { BuilderModelPaths } from './paths';
-import type { BuilderCollectionNamesOf, BuilderCollectionOf, BuilderGeneric } from './core/index';
+import type { BuilderCollectionNamesOf, BuilderGeneric } from './core/index';
 import type { BuilderExpectationEntries, BuilderExpectations, BuilderModelAsserted } from './core/expectation';
 import type { BuilderUIItems } from './schemas/index';
 export type BuilderUIGeneric = BuilderUI<BuilderGeneric>;
-export type BuilderUIFactory<Builder extends BuilderGeneric = BuilderGeneric> = (ui: BuilderUI<Builder>) => BuilderUIGeneric;
-export type BuilderUIs = ReadonlyArray<BuilderUIGeneric>;
-export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric> {
+export type BuilderUIs = ReadonlyArray<BuilderUI<BuilderGeneric | null>>;
+export declare class BuilderUI<Builder extends BuilderGeneric | null = BuilderGeneric> {
     readonly builder: Builder;
     readonly items: BuilderUIItems;
     readonly expectations: BuilderExpectationEntries;
@@ -13,6 +12,7 @@ export declare class BuilderUI<Builder extends BuilderGeneric = BuilderGeneric>
     expect<const Expectations extends BuilderExpectations>(...expectations: Expectations): BuilderUI<BuilderModelAsserted<Builder, Expectations>>;
     page(label: string | null, paths: BuilderModelPaths<Builder>): BuilderUI<Builder>;
     describe(label: string | null, paths: BuilderModelPaths<Builder>): BuilderUI<Builder>;
-    collection<const Name extends BuilderCollectionNamesOf<Builder>>(name: Name, label: string, factory: BuilderUIFactory<BuilderCollectionOf<Builder, Name>['builder']>): BuilderUI<Builder>;
+    collection<const Name extends BuilderCollectionNamesOf<Builder>>(name: Name, label: string, itemUI: BuilderUI<BuilderGeneric | null>): BuilderUI<Builder>;
 }
+export declare function ui(): BuilderUI<null>;
 export declare function ui<const Builder extends BuilderGeneric>(builder: Builder, ...uis: BuilderUIs): BuilderUI<Builder>;

package/dist/ui.js

@@ -21,21 +21,32 @@ export class BuilderUI {
     describe(label, paths) {
         return new BuilderUI(this.builder, [...this.items, { type: 'describe', label, paths }], this.expectations);
     }
-    collection(name, label, factory) {
-        const foundCollection = this.builder.collections.find((entry) => entry.name === name);
-        check.truthy(foundCollection, `Collection '${name}' not found! ❌`);
-        const templateUI = new BuilderUI(foundCollection.builder);
-        const result = factory(templateUI);
-        return new BuilderUI(this.builder, [...this.items, { type: 'collection', name, label, items: result.items }], this.expectations);
+    collection(name, label, itemUI) {
+        if (this.builder) {
+            const foundCollection = this.builder.collections.find((entry) => entry.name === name);
+            check.truthy(foundCollection, `Collection '${name}' not found! ❌`);
+        }
+        return new BuilderUI(this.builder, [...this.items, { type: 'collection', name, label, items: itemUI.items }], this.expectations);
     }
 }
 export function ui(builder, ...uis) {
-    const merged = uis.reduce((accumulated, ui) => {
-        return new BuilderUI(accumulated.builder, [...accumulated.items, ...ui.items], [...accumulated.expectations, ...ui.expectations]);
+    if (!builder) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- null builder for partial UIs, typed as BuilderUI<null>
+        return new BuilderUI(null);
+    }
+    const merged = uis.reduce((accumulated, currentUI) => {
+        return new BuilderUI(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accumulated.builder is always the real builder from the first argument
+        accumulated.builder, [...accumulated.items, ...currentUI.items], [...accumulated.expectations, ...currentUI.expectations]);
     }, new BuilderUI(builder));
     merged.expectations.forEach((expectation) => {
-        if (v.is(v.instance(BuilderExpectation), expectation) && expectation.kind === 'option') {
-            expectation.validate(merged.builder.options);
+        if (v.is(v.instance(BuilderExpectation), expectation)) {
+            if (expectation.kind === 'option') {
+                expectation.validate(merged.builder.options);
+            }
+            else if (expectation.kind === 'collection') {
+                expectation.validate(merged.builder.collections);
+            }
         }
     });
     return merged;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "exports": {
     ".": {
@@ -39,6 +39,7 @@
     "@sveltejs/vite-plugin-svelte": "^5.0.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/svelte": "^5.2.4",
+    "@vitest/coverage-v8": "^3.1.4",
     "dotenv-cli": "^8.0.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",