@builder-builder/builder 0.0.7 → 0.0.9

package/dist/entities/builder/expectation.d.ts

@@ -0,0 +1,12 @@
+import type { Prettify } from '../../prettify';
+import type { CollectionsAsserted } from '../collection/index';
+import type { ComponentAsserted } from '../component/index';
+import type { BuilderExpectation, BuilderExpectations } from '../expectation';
+import type { BuilderState, BuilderStateAppend } from './state';
+export type BuilderStateAsserted<State extends BuilderState, Expectations extends BuilderExpectations> = BuilderStateAppend<State, {
+    model: ModelAsserted<State, Expectations>;
+    components: ComponentAsserted<State, Expectations>;
+    collections: CollectionsAsserted<State, Expectations>;
+}>;
+export type ModelExpected<Expectations extends BuilderExpectations> = Expectations extends readonly [infer Head, ...infer Tail extends BuilderExpectations] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : Head extends BuilderExpectation<infer Name, any, 'collection'> ? Record<Name, ReadonlyArray<unknown>> : unknown) & ModelExpected<Tail> : unknown;
+export type ModelAsserted<State extends BuilderState, Expectations extends BuilderExpectations, Current extends State['model'] = State['model'], Asserted extends ModelExpected<Expectations> = ModelExpected<Expectations>> = unknown extends Current ? Prettify<Asserted> : Prettify<Current & Asserted>;

package/dist/entities/builder/index.d.ts

@@ -0,0 +1,7 @@
+export type { BuilderGeneric, BuilderInstanceOf, BuilderReference, BuilderReferences, BuilderSerialised, BuilderStateOf } from './builder';
+export type { BuilderStateAsserted, ModelAsserted, ModelExpected } from './expectation';
+export type { BindingModelType, BuilderBindings, BuilderBoundState } from './parameter';
+export type { BuilderState, BuilderStateAppend, BuilderStateEmpty } from './state';
+export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
+export { builders, mergeBuilderParts } from './builders.js';
+export { bindBuilder } from './parameter.js';

package/dist/entities/builder/index.js

@@ -0,0 +1,3 @@
+export { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
+export { builders, mergeBuilderParts } from './builders.js';
+export { bindBuilder } from './parameter.js';

package/dist/entities/builder/methods.d.ts

@@ -0,0 +1,58 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderRef, Refable } from '../../references';
+import type { WhenConfigPayload } from '../when';
+import type { BuilderCollectionConfig, BuilderCollectionWhen } from '../collection/index';
+import type { BuilderComponentDetails, BuilderComponentWhen } from '../component/index';
+import type { BuilderOptionValues, BuilderOptionWhen } from '../option/index';
+import type { BuilderValidPaths, BuilderWhenConstrained, WhenNullability } from '../when';
+import type { Builder } from './builder';
+import type { BuilderState, BuilderStateAppend } from './state';
+import { BuilderCollection } from '../collection/index.js';
+import { BuilderComponent } from '../component/index.js';
+import { BuilderOption } from '../option/index.js';
+export type BuilderOptionMethod<State extends BuilderState> = {
+    <const Name extends string, const Payload extends Refable<BuilderOptionValues>>(name: Name, payload: Payload): OptionStateAppend<State, BuilderOption<Name, Payload>>;
+    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderOptionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => OptionStateAppend<State, OptionWhenResolver<Name, Payload>, OptionModelOf<OptionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
+};
+export type BuilderComponentMethod<State extends BuilderState> = {
+    <const Name extends string, const Payload extends Refable<BuilderComponentDetails>>(name: Name, payload?: Payload): ComponentStateAppend<State, BuilderComponent<Name, Payload>>;
+    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderComponentWhen>>(gatePaths: GatePaths, name: Name, payload?: Payload & BuilderWhenConstrained<State, Payload>) => ComponentStateAppend<State, ComponentWhenResolver<Name, Payload>>;
+};
+export type BuilderCollectionMethod<State extends BuilderState> = {
+    <const Name extends string, const Payload extends Refable<BuilderCollectionConfig>>(name: Name, payload: Payload): CollectionStateAppend<State, BuilderCollection<Name, Payload>>;
+    when: <const GatePaths extends Refable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Refable<BuilderCollectionWhen>>(gatePaths: GatePaths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => CollectionStateAppend<State, CollectionWhenResolver<Name, Payload>, CollectionModelOf<CollectionWhenResolver<Name, Payload>> | WhenNullability<State, GatePaths, Payload>>;
+};
+type OptionWhenResolver<Name extends string, Payload extends Refable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionValues>> : BuilderOption<Name, BuilderRef>;
+type ComponentWhenResolver<Name extends string, Payload extends Refable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentDetails>> : BuilderComponent<Name, BuilderRef>;
+type CollectionWhenResolver<Name extends string, Payload extends Refable<BuilderCollectionWhen>> = Payload extends BuilderCollectionWhen ? BuilderCollection<Name, WhenConfigPayload<Payload, BuilderCollectionConfig>> : BuilderCollection<Name, BuilderRef>;
+type OptionStateAppend<State extends BuilderState, Option extends BuilderOption, ModelType = OptionModelOf<Option>> = Builder<BuilderStateAppend<State, {
+    model: State['model'] & {
+        [K in Option['name']]: ModelType;
+    };
+    options: [...State['options'], Option];
+}>>;
+type ComponentStateAppend<State extends BuilderState, Component extends BuilderComponent> = Builder<BuilderStateAppend<State, {
+    components: [...State['components'], Component];
+}>>;
+type CollectionStateAppend<State extends BuilderState, Collection extends BuilderCollection, ModelType = CollectionModelOf<Collection>> = Builder<BuilderStateAppend<State, {
+    model: State['model'] & Record<Collection['name'], ModelType>;
+    collections: [...State['collections'], Collection];
+}>>;
+type OptionModelOf<Option extends BuilderOption> = Option['payload'] extends BuilderRef ? string : Option['payload'] extends {
+    readonly value: infer Value;
+} ? Value : never;
+type CollectionModelOf<Collection extends BuilderCollection> = [Collection['payload']] extends [
+    never
+] ? null : Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['builder'] extends Builder<infer State extends BuilderState> ? CollectionShape<Collection, State['model']> : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+type CollectionShape<Collection extends BuilderCollection, Item> = Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['min'] extends number ? Collection['payload']['max'] extends number ? number extends Collection['payload']['min'] ? ReadonlyArray<Item> : number extends Collection['payload']['max'] ? ReadonlyArray<Item> : Collection['payload']['min'] extends Collection['payload']['max'] ? CollectionTuple<Item, Collection['payload']['min']> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item>;
+type CollectionTuple<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : CollectionTuple<Item, Length, [...Result, Item]>;
+export declare function builderOptionMethod(): ((name: string, payload: Refable<BuilderOptionValues>) => BuilderOption<string, Refable<import("..").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderOptionWhen>): BuilderOption<string, Refable<BuilderOptionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+};
+export declare function builderComponentMethod(): ((name: string, payload?: Refable<BuilderComponentDetails>) => BuilderComponent<string, Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>> | import("../when").BuilderEnableConfig<Refable<BuilderComponentDetails<Refable<readonly import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[]>>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Refable<BuilderPaths>, name: string, payload?: Refable<BuilderComponentWhen>): BuilderComponent<string, Refable<BuilderComponentWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+};
+export declare function builderCollectionMethod(): ((name: string, payload: Refable<BuilderCollectionConfig>) => BuilderCollection<string, Refable<BuilderCollectionConfig<Refable<import("./builder").BuilderGeneric>, Refable<number>, Refable<number>>>, Refable<readonly (readonly (string | number)[])[]>>) & {
+    when(gatePaths: Refable<BuilderPaths>, name: string, payload: Refable<BuilderCollectionWhen>): BuilderCollection<string, Refable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | BuilderRef>;
+};
+export {};

package/dist/entities/builder/methods.js

@@ -0,0 +1,30 @@
+import { BuilderCollection } from '../collection/index.js';
+import { BuilderComponent, componentWhen } from '../component/index.js';
+import { BuilderOption } from '../option/index.js';
+export function builderOptionMethod() {
+    return Object.assign((name, payload) => {
+        return new BuilderOption(name, payload);
+    }, {
+        when(gatePaths, name, payload) {
+            return new BuilderOption(name, payload, gatePaths);
+        }
+    });
+}
+export function builderComponentMethod() {
+    return Object.assign((name, payload) => {
+        return new BuilderComponent(name, payload ?? componentWhen.enable());
+    }, {
+        when(gatePaths, name, payload) {
+            return new BuilderComponent(name, payload ?? componentWhen.enable(), gatePaths);
+        }
+    });
+}
+export function builderCollectionMethod() {
+    return Object.assign((name, payload) => {
+        return new BuilderCollection(name, payload);
+    }, {
+        when(gatePaths, name, payload) {
+            return new BuilderCollection(name, payload, gatePaths);
+        }
+    });
+}

package/dist/entities/builder/parameter.d.ts

@@ -0,0 +1,62 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderRef, Refable } from '../../references';
+import type { BuilderCollectionPayload } from '../collection/index';
+import type { BuilderComponentPayload } from '../component/index';
+import type { BuilderOptionPayload } from '../option/index';
+import type { BuilderWhenConfig, BuilderWhenConstrained, WhenConfigNullable } from '../when';
+import type { BuilderState, BuilderStateAppend } from './state';
+import { Builder } from './builder.js';
+type ParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = EntryParameters<Entries>['name'];
+type PayloadForParameter<State extends BuilderState, Name extends string> = Name extends ParameterNamesOf<State['options']> ? BuilderOptionPayload : Name extends ParameterNamesOf<State['collections']> ? BuilderCollectionPayload : Name extends ParameterNamesOf<State['components']> ? BuilderComponentPayload : never;
+export type BuilderBindings<State extends BuilderState> = {
+    readonly [Name in ParameterNamesOf<State['options']> | ParameterNamesOf<State['collections']> | ParameterNamesOf<State['components']>]: BuilderWhenConstrained<State, PayloadForParameter<State, Name>>;
+};
+export declare function bindBuilder<State extends BuilderState, Bindings extends BuilderBindings<State>>(builder: Builder<State>, bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
+export type BuilderBoundState<State extends BuilderState, Bindings extends BuilderBindings<State>> = BuilderStateAppend<State, {
+    options: EntryBound<State['options'], Extract<keyof Bindings, string>>;
+    collections: EntryBound<State['collections'], Extract<keyof Bindings, string>>;
+    components: EntryBound<State['components'], Extract<keyof Bindings, string>>;
+    model: Omit<State['model'], keyof Bindings> & {
+        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
+    };
+}>;
+export type BindingModelType<Binding> = BindingValueType<Binding> | BindingConfigNullable<Binding>;
+type BindingValueType<Binding> = Binding extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap extends Record<string, unknown>;
+} ? NonNullable<SelectMap[keyof SelectMap]> extends {
+    readonly value: infer Value;
+} ? Value : string : Binding extends {
+    readonly payload: {
+        readonly value: infer Value;
+    };
+} ? Value : Binding extends {
+    readonly value: infer Value;
+} ? Value : string;
+type BindingConfigNullable<Binding> = Binding extends BuilderWhenConfig ? WhenConfigNullable<Binding> : never;
+type EntryLike = {
+    readonly name: string;
+    readonly payload: unknown;
+    readonly gatePaths?: Refable<BuilderPaths>;
+};
+type EntryBound<Entries extends ReadonlyArray<EntryLike>, BoundNames extends string> = Entries extends readonly [
+    infer Head extends EntryLike,
+    ...infer Tail extends ReadonlyArray<EntryLike>
+] ? Head extends {
+    readonly payload: infer Payload;
+} ? Payload extends BuilderRef ? Head['name'] extends BoundNames ? [...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [Head, ...EntryBound<Tail, BoundNames>] : [];
+type EntryParameters<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
+    readonly payload: infer Payload;
+} ? PayloadParameters<Payload> : never : never;
+type PayloadParameters<Payload> = ParameterOf<Payload> | (Payload extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? ParameterOf<SelectMap[keyof SelectMap]> : never) | (Payload extends {
+    readonly type: 'enable' | 'unless';
+    readonly payload: infer Inner;
+} ? ParameterOf<Inner> : never);
+type ParameterOf<Value> = Extract<Value, BuilderRef> extends infer Ref extends BuilderRef ? {
+    readonly name: Ref['name'];
+    readonly payload: Ref;
+} : never;
+export {};

package/dist/entities/builder/parameter.js

@@ -0,0 +1,18 @@
+import * as v from 'valibot';
+import { isRef } from '../../references.js';
+import { createWalkerBinding } from '../../walker/index.js';
+import { Builder, BuilderSchema, BuilderSerialisedSchema } from './builder.js';
+import { mergeBuilderParts } from './builders.js';
+export function bindBuilder(builder, bindings) {
+    const { expectations, references } = builder;
+    const bindingEntries = Object.entries(bindings);
+    const boundNames = new Set(bindingEntries.filter(([, value]) => v.is(BuilderSchema, value)).map(([name]) => name));
+    const remainingReferences = references.filter((reference) => !isRef(reference) || !boundNames.has(reference.name));
+    const bindingLookup = bindings;
+    const walkBind = createWalkerBinding({
+        lookupBinding: (ref) => bindingLookup[ref.name]
+    });
+    const walked = walkBind(BuilderSerialisedSchema, builder);
+    const merged = mergeBuilderParts(bindingEntries.map(([, value]) => value));
+    return new Builder([...remainingReferences, ...merged.references], [...walked.options, ...merged.options], [...walked.components, ...merged.components], [...walked.collections, ...merged.collections], [...expectations, ...merged.expectations]);
+}

package/dist/entities/builder/state.d.ts

@@ -0,0 +1,26 @@
+import type { Prettify } from '../../prettify';
+import type { BuilderRefs } from '../../references';
+import type { BuilderCollections } from '../collection/index';
+import type { BuilderComponents } from '../component/index';
+import type { BuilderOptions } from '../option/index';
+export type BuilderState = {
+    model: unknown;
+    references: BuilderRefs;
+    options: BuilderOptions;
+    components: BuilderComponents;
+    collections: BuilderCollections;
+};
+export type BuilderStateEmpty = {
+    readonly model: unknown;
+    readonly references: [];
+    readonly options: [];
+    readonly components: [];
+    readonly collections: [];
+};
+export type BuilderStateAppend<State extends BuilderState, Patch extends Partial<BuilderState>> = {
+    model: Prettify<'model' extends keyof Patch ? Patch['model'] : State['model']>;
+    references: 'references' extends keyof Patch ? Extract<Patch['references'], BuilderRefs> : State['references'];
+    options: Extract<'options' extends keyof Patch ? Patch['options'] : State['options'], BuilderOptions>;
+    components: Extract<'components' extends keyof Patch ? Patch['components'] : State['components'], BuilderComponents>;
+    collections: Extract<'collections' extends keyof Patch ? Patch['collections'] : State['collections'], BuilderCollections>;
+};

package/dist/entities/builder/validate.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderGeneric } from './builder';
+export declare function validateDuplicates(builder: BuilderGeneric): void;
+export declare function validatePaths(builder: BuilderGeneric): void;

package/dist/entities/builder/validate.js

@@ -0,0 +1,108 @@
+import * as v from 'valibot';
+import { BuilderException } from '../../exception.js';
+import { isRef } from '../../references.js';
+import { BuilderCollectionConfigSchema } from '../collection/index.js';
+import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../when.js';
+export function validateDuplicates(builder) {
+    const kinds = [
+        { entryKind: 'option', entries: builder.options },
+        { entryKind: 'component', entries: builder.components },
+        { entryKind: 'collection', entries: builder.collections }
+    ];
+    const errors = kinds.flatMap(({ entryKind, entries }) => {
+        const seen = new Set();
+        return entries.flatMap((entry) => {
+            if (seen.has(entry.name)) {
+                return [{ kind: 'duplicate-name', entryKind, name: entry.name }];
+            }
+            seen.add(entry.name);
+            return [];
+        });
+    });
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+}
+export function validatePaths(builder) {
+    const errors = collectPathErrors(builder);
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+}
+function collectPathErrors(builder) {
+    if (builder.expectations.length > 0) {
+        return [];
+    }
+    const allEntries = [...builder.options, ...builder.components, ...builder.collections];
+    return allEntries.flatMap((entry) => pathsForEntry(entry).flatMap((path) => collectEntryPathErrors(builder, entry.name, path)));
+}
+function pathsForEntry(entry) {
+    const gatePaths = entry.gatePaths != null && !isRef(entry.gatePaths)
+        ? entry.gatePaths
+        : [];
+    const configPaths = pathsFromWhen(entry.payload);
+    return [...gatePaths, ...configPaths];
+}
+function pathsFromWhen(payload) {
+    if (v.is(BuilderWhenMatchSchema, payload)) {
+        const matchPath = payload.matchPath;
+        return isRef(matchPath) ? [] : [matchPath];
+    }
+    if (v.is(BuilderWhenUnlessSchema, payload)) {
+        const unlessPath = payload.unlessPath;
+        return isRef(unlessPath) ? [] : [unlessPath];
+    }
+    return [];
+}
+function collectEntryPathErrors(builder, entryName, path) {
+    const collectionSegments = path.slice(0, -1);
+    const optionName = path.at(-1);
+    const reached = traverseCollections([builder], collectionSegments);
+    if (reached === null) {
+        return [{ kind: 'invalid-gate-path', name: entryName, path }];
+    }
+    const anyHasOption = reached.some((current) => current.options.some((option) => option.name === optionName));
+    return anyHasOption ? [] : [{ kind: 'invalid-gate-path', name: entryName, path }];
+}
+function traverseCollections(candidates, remaining) {
+    if (remaining.length === 0) {
+        return candidates;
+    }
+    const [collectionName, index, ...rest] = remaining;
+    if (!v.is(v.string(), collectionName) || !v.is(v.number(), index)) {
+        return null;
+    }
+    const descents = candidates.map((current) => descendCollection(current, collectionName, index));
+    if (descents.some((descent) => descent === null)) {
+        return null;
+    }
+    const nextCandidates = descents.flatMap((descent) => descent ?? []);
+    if (nextCandidates.length === 0) {
+        return null;
+    }
+    return traverseCollections(nextCandidates, rest);
+}
+function descendCollection(builder, collectionName, index) {
+    const collection = builder.collections.find((entry) => entry.name === collectionName);
+    if (!collection) {
+        return [];
+    }
+    const configs = possibleConfigs(collection.payload);
+    const withinBounds = configs.filter((config) => isRef(config.max) || index < config.max);
+    if (withinBounds.length === 0 && configs.length > 0) {
+        return null;
+    }
+    return withinBounds.flatMap((config) => (isRef(config.builder) ? [] : [config.builder]));
+}
+function possibleConfigs(payload) {
+    if (isRef(payload)) {
+        return [];
+    }
+    if (v.is(BuilderCollectionConfigSchema, payload)) {
+        return [payload];
+    }
+    if (payload.type === 'match') {
+        return Object.values(payload.selectMap).flatMap((value) => v.is(BuilderCollectionConfigSchema, value) ? [value] : []);
+    }
+    return v.is(BuilderCollectionConfigSchema, payload.payload) ? [payload.payload] : [];
+}

package/dist/entities/collection/collection.d.ts

@@ -0,0 +1,37 @@
+import type { BuilderPaths } from '../../paths';
+import type { Refable, RefableSerialised } from '../../references';
+import type { BuilderState } from '../builder/index';
+import type { BuilderWhen, WhenSerialised } from '../when';
+import type { BuilderCollectionConfigSerialised } from './config';
+import * as v from 'valibot';
+import { BuilderCollectionConfig } from './config.js';
+export type BuilderErrorInvalidCollectionBounds = {
+    readonly kind: 'invalid-collection-bounds';
+    readonly name: string;
+    readonly min: number;
+    readonly max: number;
+};
+export type BuilderCollectionPayload = BuilderCollectionConfig | BuilderWhen<Refable<BuilderCollectionConfig>>;
+export declare class BuilderCollection<const Name extends string = string, const Payload extends Refable<BuilderCollectionPayload> = Refable<BuilderCollectionPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+    readonly type: 'collection';
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly gatePaths?: GatePaths;
+    constructor(name: Name, payload: Payload, gatePaths?: GatePaths);
+}
+export declare const BuilderCollectionSchema: v.InstanceSchema<typeof BuilderCollection, undefined>;
+export type BuilderCollections = ReadonlyArray<BuilderCollection>;
+export declare const BuilderCollectionWhenSerialisedSchema: v.GenericSchema;
+export type BuilderCollectionWhenSerialised = WhenSerialised<BuilderCollectionConfigSerialised>;
+export type BuilderCollectionSerialised = {
+    readonly name: string;
+    readonly gatePaths?: RefableSerialised<BuilderPaths>;
+    readonly payload: RefableSerialised<BuilderCollectionConfigSerialised | BuilderCollectionWhenSerialised>;
+};
+export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
+export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;
+export type BuilderCollectionsSerialised = ReadonlyArray<BuilderCollectionSerialised>;
+export type CollectionNamesOf<State extends BuilderState | null> = [State] extends [BuilderState] ? State['collections'][number]['name'] : never;
+export type CollectionShape<Collection extends BuilderCollection, Item> = Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['min'] extends number ? Collection['payload']['max'] extends number ? number extends Collection['payload']['min'] ? ReadonlyArray<Item> : number extends Collection['payload']['max'] ? ReadonlyArray<Item> : Collection['payload']['min'] extends Collection['payload']['max'] ? CollectionTuple<Item, Collection['payload']['min']> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item>;
+type CollectionTuple<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : CollectionTuple<Item, Length, [...Result, Item]>;
+export {};

package/dist/entities/collection/collection.js

@@ -0,0 +1,42 @@
+import * as v from 'valibot';
+import { BuilderException } from '../../exception.js';
+import { BuilderPathsSchema } from '../../paths.js';
+import { isRef, refable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { createWhenSerialisedSchema } from '../when.js';
+import { BuilderCollectionConfig, BuilderCollectionConfigSerialisedSchema } from './config.js';
+export class BuilderCollection {
+    name;
+    payload;
+    gatePaths;
+    constructor(name, payload, gatePaths) {
+        this.name = name;
+        this.payload = payload;
+        this.gatePaths = gatePaths;
+        validateCollectionBounds(name, payload);
+    }
+}
+function validateCollectionBounds(name, payload) {
+    if (!(payload instanceof BuilderCollectionConfig)) {
+        return;
+    }
+    const { min, max } = payload;
+    if (isRef(min) || isRef(max)) {
+        return;
+    }
+    const minValue = min;
+    const maxValue = max;
+    if (minValue < 0 || maxValue <= 0 || maxValue < minValue) {
+        throw new BuilderException([
+            { kind: 'invalid-collection-bounds', name, min: minValue, max: maxValue }
+        ]);
+    }
+}
+export const BuilderCollectionSchema = v.instance(BuilderCollection);
+export const BuilderCollectionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderCollectionConfigSerialisedSchema);
+export const BuilderCollectionSerialisedSchema = serialisable(BuilderCollection, v.object({
+    name: v.string(),
+    payload: refable(v.union([BuilderCollectionConfigSerialisedSchema, BuilderCollectionWhenSerialisedSchema])),
+    gatePaths: v.optional(refable(BuilderPathsSchema))
+}));
+export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());