@builder-builder/builder 0.0.6 → 0.0.8

package/dist/entities/ui/ui.js

@@ -0,0 +1,53 @@
+import * as v from 'valibot';
+import { BuilderRefsSerialisedSchema, isRef, refable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { BuilderSerialisedSchema } from '../builder/index.js';
+import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { bindUI } from './parameter.js';
+import { BuilderUIDescribe } from './describe.js';
+import { BuilderUILabel } from './label.js';
+import { BuilderUIPage } from './page.js';
+import { BuilderUIItemsSerialisedSchema, BuilderUIPages } from './pages.js';
+import { validatePagesCollections } from './validate.js';
+export class BuilderUI {
+    builder;
+    references;
+    items;
+    expectations;
+    id = crypto.randomUUID();
+    constructor(builder, references, items, expectations) {
+        this.builder = builder;
+        this.references = references;
+        this.items = items;
+        this.expectations = expectations;
+        validatePagesCollections(builder, items);
+    }
+    expect(...expectations) {
+        return new BuilderUI(this.builder, this.references, this.items, [...this.expectations, ...expectations]
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
+        );
+    }
+    page(label, paths) {
+        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPage(this.#label(label), paths)], this.expectations);
+    }
+    describe(label, paths) {
+        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIDescribe(this.#label(label), paths)], this.expectations);
+    }
+    pages(name, label, itemUI) {
+        const items = isRef(itemUI) ? itemUI : itemUI.items;
+        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPages(name, this.#label(label), items)], this.expectations);
+    }
+    bind(bindings) {
+        return bindUI(this, bindings);
+    }
+    #label(label) {
+        return isRef(label) ? label : new BuilderUILabel(label);
+    }
+}
+export const BuilderUISchema = v.instance(BuilderUI);
+export const BuilderUISerialisedSchema = serialisable(BuilderUI, v.object({
+    builder: refable(v.lazy(() => BuilderSerialisedSchema)),
+    references: BuilderRefsSerialisedSchema,
+    items: BuilderUIItemsSerialisedSchema,
+    expectations: BuilderExpectationsSerialisedSchema
+}));

package/dist/entities/ui/uis.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderGeneric } from '../builder/index';
+import type { BuilderUIReferences } from './ui';
+import { BuilderRef } from '../../references.js';
+import { BuilderUI } from './ui.js';
+export declare function uis(): BuilderUI<BuilderRef>;
+export declare function uis<const BuilderType extends BuilderGeneric>(uiBuilder: BuilderType, ...parts: BuilderUIReferences): BuilderUI<BuilderType>;
+export declare function mergeUIParts(parts: ReadonlyArray<unknown>): {
+    references: BuilderRef[];
+    expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
+};

package/dist/entities/ui/uis.js

@@ -0,0 +1,20 @@
+import * as v from 'valibot';
+import { BuilderRef } from '../../references.js';
+import { BuilderUI, BuilderUISchema } from './ui.js';
+export function uis(uiBuilder, ...parts) {
+    const builder = uiBuilder ?? new BuilderRef('builder');
+    const merged = mergeUIParts(parts);
+    return new BuilderUI(builder, merged.references, parts.flatMap((part) => {
+        if (v.is(BuilderUISchema, part)) {
+            return [...part.items];
+        }
+        return [part];
+    }), merged.expectations);
+}
+export function mergeUIParts(parts) {
+    const instances = parts.filter((part) => v.is(BuilderUISchema, part));
+    return {
+        references: instances.flatMap((instance) => [...instance.references]),
+        expectations: instances.flatMap((instance) => [...instance.expectations])
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Refable } from '../../references';
+import type { BuilderGeneric } from '../builder/index';
+import type { BuilderUIItems } from './pages';
+export type BuilderErrorPagesUnknownCollection = {
+    readonly kind: 'pages-unknown-collection';
+    readonly name: string;
+};
+export declare function validatePagesCollections(builder: Refable<BuilderGeneric>, items: Refable<BuilderUIItems>): void;

package/dist/entities/ui/validate.js

@@ -0,0 +1,21 @@
+import { BuilderException } from '../../exception.js';
+import { isRef } from '../../references.js';
+import { BuilderUIPages } from './pages.js';
+export function validatePagesCollections(builder, items) {
+    if (isRef(builder) || isRef(items)) {
+        return;
+    }
+    const errors = items.flatMap((item) => {
+        if (isRef(item) || !(item instanceof BuilderUIPages)) {
+            return [];
+        }
+        const exists = builder.collections.some((entry) => entry.name === item.name);
+        if (exists) {
+            return [];
+        }
+        return [{ kind: 'pages-unknown-collection', name: item.name }];
+    });
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+}

package/dist/entities/validate.d.ts

@@ -0,0 +1,28 @@
+import type { BuilderExpectation } from './expectation';
+import type { BuilderRef } from '../references';
+import type { Builder, BuilderGeneric } from './builder/index';
+import type { BuilderCollection, BuilderCollectionConfig } from './collection/index';
+import type { BuilderComponent, BuilderComponentDetails } from './component/index';
+import type { BuilderOption, BuilderSelectType, BuilderToggleType } from './option/index';
+import type { BuilderUI, BuilderUIDescribe, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUILabel, BuilderUIPage, BuilderUIPages } from './ui/index';
+export type Strip<T> = T extends BuilderRef ? never : T extends BuilderSelectType | BuilderToggleType | BuilderUILabel | BuilderExpectation ? T : T extends Builder<infer State> ? Builder<Strip<State>> : T extends BuilderOption<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderOption<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderComponent<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderComponent<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollection<infer Name, infer Payload, infer GatePaths> ? StripEntry<BuilderCollection<Name, Strip<Payload>, Strip<GatePaths>>, Payload, GatePaths> : T extends BuilderCollectionConfig<infer Inner, infer Min, infer Max> ? BuilderCollectionConfig<Strip<Inner>, Strip<Min>, Strip<Max>> : T extends BuilderComponentDetails<infer Expectations> ? BuilderComponentDetails<Strip<Expectations>> : T extends BuilderUI<infer Inner, infer Items> ? BuilderUI<Strip<Inner>, Strip<Items> & BuilderUIItems> : T extends BuilderUIPage<infer Label, infer Paths> ? BuilderUIPage<Strip<Label>, Strip<Paths>> : T extends BuilderUIDescribe<infer Label, infer Paths> ? BuilderUIDescribe<Strip<Label>, Strip<Paths>> : T extends BuilderUIPages<infer Name, infer Label, infer Items> ? BuilderUIPages<Name, Strip<Label>, Strip<Items>> : T extends ReadonlyArray<unknown> ? StripTuple<T> : T extends object ? {
+    readonly [Key in keyof T]: Strip<T[Key]>;
+} : T;
+type StripEntry<Narrowed, Payload, GatePaths> = [Strip<Payload>] extends [never] ? never : [Strip<GatePaths>] extends [never] ? never : Narrowed;
+export type StripTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
+    infer Head,
+    ...infer Rest extends ReadonlyArray<unknown>
+] ? [Strip<Head>] extends [never] ? StripTuple<Rest> : readonly [Strip<Head>, ...StripTuple<Rest>] : T extends readonly [] ? readonly [] : ReadonlyArray<Strip<T[number]>>;
+export type BuilderValidated = Strip<BuilderGeneric>;
+export type BuilderOptionValidated = Strip<BuilderOption>;
+export type BuilderOptionsValidated = ReadonlyArray<BuilderOptionValidated>;
+export type BuilderComponentValidated = Strip<BuilderComponent>;
+export type BuilderComponentsValidated = ReadonlyArray<BuilderComponentValidated>;
+export type BuilderComponentDetailsValidated = Strip<BuilderComponentDetails>;
+export type BuilderCollectionValidated = Strip<BuilderCollection>;
+export type BuilderCollectionsValidated = ReadonlyArray<BuilderCollectionValidated>;
+export type BuilderCollectionConfigValidated = Strip<BuilderCollectionConfig>;
+export type BuilderUIValidated = Strip<BuilderUIGeneric>;
+export type BuilderUIItemValidated = Strip<BuilderUIItem>;
+export type BuilderUIItemsValidated = Strip<BuilderUIItems>;
+export {};

package/dist/entities/validate.js

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

package/dist/entities/when.d.ts

@@ -0,0 +1,176 @@
+import type { BuilderPath, BuilderPaths } from '../paths';
+import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
+import type { BuilderRef, BuilderRefSerialised, Refable } from '../references';
+import type { BuilderGeneric, BuilderState, BuilderStateOf } from './builder/index';
+import * as v from 'valibot';
+export type BuilderEnableConfig<Payload = unknown> = {
+    readonly type: 'enable';
+    readonly payload: Payload;
+};
+export type BuilderMatchSelectMap<Item> = Record<string, Item | null>;
+export type BuilderMatchConfig<Payload = unknown, MatchPath = BuilderPath, SelectMap = BuilderMatchSelectMap<Payload>> = {
+    readonly type: 'match';
+    readonly matchPath: MatchPath;
+    readonly selectMap: SelectMap;
+};
+export type BuilderUnlessConfig<Payload = unknown, UnlessPath = BuilderPath> = {
+    readonly type: 'unless';
+    readonly unlessPath: UnlessPath;
+    readonly disabledValues: BuilderPrimitives;
+    readonly payload: Payload;
+};
+export type BuilderWhen<Payload = unknown, MatchPath = BuilderPath, MatchSelectMap = Record<string, Payload | null>, UnlessPath = BuilderPath> = BuilderEnableConfig<Payload> | BuilderMatchConfig<Payload, MatchPath, MatchSelectMap> | BuilderUnlessConfig<Payload, UnlessPath>;
+export type WhenSerialised<Payload> = {
+    readonly type: 'enable';
+    readonly payload: Payload | BuilderRefSerialised;
+} | {
+    readonly type: 'match';
+    readonly matchPath: BuilderRefSerialised | BuilderPath;
+    readonly selectMap: Record<string, (Payload | BuilderRefSerialised) | null> | BuilderRefSerialised;
+} | {
+    readonly type: 'unless';
+    readonly unlessPath: BuilderRefSerialised | BuilderPath;
+    readonly disabledValues: BuilderPrimitives;
+    readonly payload: Payload | BuilderRefSerialised;
+};
+export type WhenConfigPayload<Config extends BuilderWhenConfig, Payload> = Config extends {
+    readonly payload: infer Inner extends Payload;
+} ? Inner : Config extends BuilderMatchConfig ? NonNullable<Config['selectMap'][keyof Config['selectMap']]> & Payload : never;
+export declare const BuilderWhenEnableSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"enable", undefined>;
+}, undefined>;
+export declare const BuilderWhenMatchSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"match", undefined>;
+    readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }>]>;
+}, undefined>;
+export declare const BuilderWhenUnlessSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"unless", undefined>;
+    readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }>]>;
+}, undefined>;
+export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"enable", undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"match", undefined>;
+    readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }>]>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"unless", undefined>;
+    readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+        readonly name: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>, {
+        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
+    }>]>;
+}, undefined>], undefined>, v.ReadonlyAction<{
+    type: "enable";
+} | {
+    type: "match";
+    matchPath: readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>;
+} | {
+    type: "unless";
+    unlessPath: readonly (string | number)[] | BuilderRef | Readonly<{
+        type: "ref";
+        id: string;
+        name: string;
+    }>;
+}>]>;
+export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
+export declare function createWhenSerialisedSchema(payloadSchema: v.GenericSchema): v.GenericSchema;
+export declare function createWhenFactories<Payload>(): {
+    enable: <const Values extends Refable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Refable<Payload>, const MatchPath extends Refable<BuilderPath>, const SelectMap extends Refable<BuilderMatchSelectMap<Refable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Refable<Payload>, const UnlessPath extends Refable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
+};
+export type BuilderValidPath<State extends BuilderState> = ModelValidPath<State['model']>;
+export type BuilderValidPaths<State extends BuilderState> = ReadonlyArray<BuilderValidPath<State>>;
+export type BuilderValidPathsOf<Input extends Refable<BuilderGeneric>> = BuilderValidPaths<BuilderStateOf<Input>>;
+export type BuilderWhenConstrained<State extends BuilderState, Config> = Config extends BuilderRef ? Config : Config extends {
+    readonly type: 'match';
+    readonly matchPath: infer MatchPath extends BuilderPath;
+    readonly selectMap: infer SelectMap;
+} ? Config & {
+    readonly matchPath: [MatchPath] extends [Readonly<BuilderValidPath<State>>] ? MatchPath : Readonly<BuilderValidPath<State>>;
+    readonly selectMap: SelectMap extends BuilderRef ? SelectMap : Record<BuilderResolvePath<State['model'], MatchPath> & string, SelectMap[keyof SelectMap]>;
+} : Config extends {
+    readonly type: 'unless';
+    readonly unlessPath: infer UnlessPath extends BuilderPath;
+} ? Config & {
+    readonly unlessPath: [UnlessPath] extends [Readonly<BuilderValidPath<State>>] ? UnlessPath : Readonly<BuilderValidPath<State>>;
+} : Config;
+export type WhenConfigNullable<Config extends BuilderWhenConfig> = Config extends {
+    readonly type: 'unless';
+} ? null : Config extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? null extends SelectMap[keyof SelectMap] ? null : never : never;
+export type WhenNullability<State extends BuilderState, GatePaths extends Refable<BuilderPaths>, Config extends Refable<BuilderWhenConfig>> = [GatePaths] extends [BuilderRef] ? null : WhenNullabilityFromPaths<State['model'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
+type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
+    infer Head extends keyof Model & string
+] ? Model[Head] : Path extends readonly [
+    infer Head extends keyof Model & string,
+    ...infer Tail extends BuilderPath
+] ? Model[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Model[Head], Tail> : never;
+type WhenNullabilityFromPaths<Model, GatePaths extends BuilderPaths, Config extends Refable<BuilderWhenConfig>> = Config extends BuilderRef ? WhenPathsNullable<Model, GatePaths> : Config extends BuilderWhenConfig ? WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config> : never;
+type WhenPathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
+    infer Head extends BuilderPath,
+    ...infer Tail extends BuilderPaths
+] ? WhenPathNullable<Model, Head> | WhenPathsNullable<Model, Tail> : never;
+type WhenPathNullable<Model, Path extends BuilderPath> = null extends BuilderResolvePath<Model, Path> ? null : never;
+type ModelValidPath<Model, Depth extends ReadonlyArray<never> = []> = Depth['length'] extends 10 ? never : Model extends BuilderPrimitive | null ? never : Model extends ReadonlyArray<infer Item> ? [number] | [number, ...ModelValidPath<Item, [...Depth, never]>] : {
+    [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...ModelValidPath<Model[Key], [...Depth, never]>]);
+}[keyof Model & string];
+export {};

package/dist/entities/when.js

@@ -0,0 +1,47 @@
+import * as v from 'valibot';
+import { BuilderPathSchema } from '../paths.js';
+import { BuilderPrimitivesSchema } from '../primitive.js';
+import { refable } from '../references.js';
+export const BuilderWhenEnableSchema = v.object({
+    type: v.literal('enable')
+});
+export const BuilderWhenMatchSchema = v.object({
+    type: v.literal('match'),
+    matchPath: refable(BuilderPathSchema)
+});
+export const BuilderWhenUnlessSchema = v.object({
+    type: v.literal('unless'),
+    unlessPath: refable(BuilderPathSchema)
+});
+export const BuilderWhenConfigSchema = v.pipe(v.variant('type', [BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema]), v.readonly());
+export function createWhenSerialisedSchema(payloadSchema) {
+    const refablePayload = refable(payloadSchema);
+    return v.pipe(v.variant('type', [
+        v.object({
+            ...BuilderWhenEnableSchema.entries,
+            payload: refablePayload
+        }),
+        v.object({
+            ...BuilderWhenMatchSchema.entries,
+            selectMap: refable(v.record(v.string(), v.nullable(refablePayload)))
+        }),
+        v.object({
+            ...BuilderWhenUnlessSchema.entries,
+            disabledValues: BuilderPrimitivesSchema,
+            payload: refablePayload
+        })
+    ]), v.readonly());
+}
+export function createWhenFactories() {
+    return {
+        enable: (values) => {
+            return { type: 'enable', payload: values };
+        },
+        match: (matchPath, selectMap) => {
+            return { type: 'match', matchPath, selectMap };
+        },
+        unless: (unlessPath, disabledValues, values) => {
+            return { type: 'unless', unlessPath, disabledValues, payload: values };
+        }
+    };
+}

package/dist/exception.d.ts

@@ -0,0 +1,8 @@
+import type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation } from './entities/index';
+import type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './mappers/index';
+export type BuilderError = BuilderErrorUnmetExpectation | BuilderErrorUnboundParameter | BuilderErrorInvalidGatePath | BuilderErrorDuplicateName | BuilderErrorInvalidCollectionBounds | BuilderErrorPagesUnknownCollection | BuilderErrorInvalidOption | BuilderErrorInvalidCollection | BuilderErrorMissingComponent | BuilderErrorUnexpectedComponent | BuilderErrorMissingVariant | BuilderErrorInvalidVariant | BuilderErrorMissingDetail | BuilderErrorUnexpectedDetail;
+export type BuilderErrors = ReadonlyArray<BuilderError>;
+export declare class BuilderException extends globalThis.Error {
+    readonly errors: BuilderErrors;
+    constructor(errors: BuilderErrors, message?: string);
+}

package/dist/exception.js

@@ -0,0 +1,7 @@
+export class BuilderException extends globalThis.Error {
+    errors;
+    constructor(errors, message = '') {
+        super(`BuilderBuilder exception 🏗️${message ? `: ${message}` : ''}`);
+        this.errors = errors;
+    }
+}

package/dist/index.d.ts

@@ -1,13 +1,37 @@
-export type { BuilderData, BuilderModel, BuilderModels, BuilderPrimitive, BuilderPrimitives, BuilderVariant, BuilderVariants } from './model';
-export type { Builder, Builders, BuilderCollectionEntries, BuilderComponentEntries, BuilderGeneric, BuilderModelOf, BuilderOptionEntries } from './core/index';
-export type { BuilderModelPaths, BuilderResolvePath, BuilderValidPath } from './paths';
-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, BuilderUIs } from './ui';
-export type { BuilderCollectionSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderOptionSerialised, BuilderOptionWhenConfigSerialised, BuilderParameterSerialised, BuilderSelectTypeSerialised, BuilderSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderValuesSerialised } from './serialise/index';
-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';
-export { ui } from './ui.js';
+export type { Builder, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderGeneric, BuilderInstanceOf, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderReference, BuilderReferences, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUILabel, BuilderUILabelSerialised, BuilderUIPage, BuilderUIPageSerialised, BuilderUIPages, BuilderUIPagesSerialised, BuilderUIReference, BuilderUIReferences, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderWhenConfig } from './entities/index';
+export type { BuilderError, BuilderErrors } from './exception';
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
+export type { BuilderData, BuilderModel, BuilderModelInput, BuilderModels, BuilderVariant, BuilderVariants } from './model';
+export type { BuilderPath, BuilderPaths } from './paths';
+export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
+export type { BuilderRef, BuilderRefSerialised, Refable, RefableSerialised } from './references';
+import { builders, collectionConfig, collectionExpectation, componentDetails, componentExpectation, detailExpectation, optionExpectation, uis } from './entities/index.js';
+import { createInstance, createModels } from './mappers/index.js';
+export declare const builder: typeof builders;
+export declare const collection: typeof collectionConfig & {
+    enable: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+};
+export declare const component: typeof componentDetails & {
+    enable: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(payload?: Payload) => import("./entities/when").BuilderEnableConfig<Payload>;
+    match: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>, const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./entities/when").BuilderUnlessConfig<Payload, UnlessPath>;
+};
+export declare const has: {
+    collection: typeof collectionExpectation;
+    component: typeof componentExpectation;
+    detail: typeof detailExpectation;
+    option: typeof optionExpectation;
+};
+export declare const instance: typeof createInstance;
+export declare const models: typeof createModels;
+export declare const option: {
+    enable: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+};
+export declare const ui: typeof uis;
+export { BuilderException } from './exception.js';
+export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { order, ordinal, render } from './mappers/index.js';

package/dist/index.js

@@ -1,5 +1,22 @@
-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';
-export { ui } from './ui.js';
+import { builders, collectionConfig, collectionExpectation, collectionWhen, componentDetails, componentExpectation, componentWhen, detailExpectation, optionExpectation, optionWhen, uis } from './entities/index.js';
+import { createInstance, createModels } from './mappers/index.js';
+export const builder = builders;
+export const collection = Object.assign(collectionConfig, {
+    ...collectionWhen
+});
+export const component = Object.assign(componentDetails, {
+    ...componentWhen
+});
+export const has = {
+    collection: collectionExpectation,
+    component: componentExpectation,
+    detail: detailExpectation,
+    option: optionExpectation
+};
+export const instance = createInstance;
+export const models = createModels;
+export const option = optionWhen;
+export const ui = uis;
+export { BuilderException } from './exception.js';
+export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { order, ordinal, render } from './mappers/index.js';

package/dist/mappers/assert/builder.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderGeneric, Strip } from '../../entities/index';
+export declare function assertBuilder<Input extends BuilderGeneric>(builder: Input): asserts builder is Input & Strip<Input>;

package/dist/mappers/assert/builder.js

@@ -0,0 +1,46 @@
+import * as v from 'valibot';
+import { BuilderCollectionConfigSchema, BuilderSerialisedSchema } from '../../entities/index.js';
+import { BuilderException } from '../../exception.js';
+import { isRef } from '../../references.js';
+import { createWalkerValidation } from '../../walker/index.js';
+import { collectExpectationErrors } from './expectation.js';
+export function assertBuilder(builder) {
+    const errors = collectBuilderErrors(builder);
+    if (errors.length > 0) {
+        throw new BuilderException(errors);
+    }
+}
+function collectBuilderErrors(builder) {
+    const expectationErrors = collectNestedBuilders(builder).flatMap((inner) => collectExpectationErrors(inner, inner.expectations));
+    const parameterErrors = [];
+    const walkValidate = createWalkerValidation((ref) => {
+        parameterErrors.push({ kind: 'unbound-parameter', name: ref.name });
+    });
+    walkValidate(BuilderSerialisedSchema, builder);
+    const referenceErrors = builder.references
+        .filter(isRef)
+        .map((reference) => ({ kind: 'unbound-parameter', name: reference.name }));
+    return [...expectationErrors, ...referenceErrors, ...parameterErrors];
+}
+function collectNestedBuilders(builder) {
+    const nested = builder.collections.flatMap((collection) => nestedBuildersOf(collection.payload));
+    return [builder, ...nested.flatMap((inner) => collectNestedBuilders(inner))];
+}
+function nestedBuildersOf(payload) {
+    if (isRef(payload)) {
+        return [];
+    }
+    if (v.is(BuilderCollectionConfigSchema, payload)) {
+        return isRef(payload.builder) ? [] : [payload.builder];
+    }
+    const whenPayload = payload;
+    if (whenPayload.type === 'match' && whenPayload.selectMap != null) {
+        return Object.values(whenPayload.selectMap).flatMap((value) => value && !isRef(value.builder) ? [value.builder] : []);
+    }
+    const inner = whenPayload.payload;
+    if (inner == null || isRef(inner)) {
+        return [];
+    }
+    const innerBuilder = inner.builder;
+    return isRef(innerBuilder) ? [] : [innerBuilder];
+}

package/dist/mappers/assert/expectation.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderErrorUnmetExpectation, BuilderExpectations, BuilderGeneric } from '../../entities/index';
+export declare function collectExpectationErrors(builder: BuilderGeneric, expectations: BuilderExpectations): ReadonlyArray<BuilderErrorUnmetExpectation>;

package/dist/mappers/assert/expectation.js

@@ -0,0 +1,23 @@
+export function collectExpectationErrors(builder, expectations) {
+    return expectations.flatMap((expectation) => {
+        if (expectation.kind === 'detail') {
+            return [];
+        }
+        const lookup = expectation.kind === 'option'
+            ? builder.options
+            : expectation.kind === 'component'
+                ? builder.components
+                : builder.collections;
+        const exists = lookup.some((entry) => entry.name === expectation.name);
+        if (exists) {
+            return [];
+        }
+        return [
+            {
+                kind: 'unmet-expectation',
+                expectationKind: expectation.kind,
+                name: expectation.name
+            }
+        ];
+    });
+}

package/dist/mappers/assert/index.d.ts

@@ -0,0 +1,6 @@
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption } from './model';
+export type { BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './models';
+export { assertBuilder } from './builder.js';
+export { assertModel } from './model.js';
+export { assertModels } from './models.js';
+export { assertUI } from './ui.js';

package/dist/mappers/assert/index.js

@@ -0,0 +1,4 @@
+export { assertBuilder } from './builder.js';
+export { assertModel } from './model.js';
+export { assertModels } from './models.js';
+export { assertUI } from './ui.js';

package/dist/mappers/assert/model.d.ts

@@ -0,0 +1,13 @@
+import type { BuilderValidated } from '../../entities/index';
+import type { BuilderModel } from '../../model';
+export type BuilderErrorInvalidOption = {
+    readonly kind: 'invalid-option';
+    readonly name: string;
+    readonly value: unknown;
+};
+export type BuilderErrorInvalidCollection = {
+    readonly kind: 'invalid-collection';
+    readonly name: string;
+    readonly detail: string;
+};
+export declare function assertModel(builder: BuilderValidated, model: BuilderModel): void;