@builder-builder/builder 0.0.20 → 0.0.21

package/dist/entities/ui/pages.js

@@ -1,6 +1,7 @@
 import * as v from 'valibot';
-import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
+import { isParamable, paramable } from '../../references.js';
+import { createEntityValidator } from '../kind.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIDescribeSerialisedSchema } from './describe.js';
 import { BuilderUIPageSerialisedSchema } from './page.js';
@@ -34,3 +35,12 @@ export const BuilderUIItemSerialisedSchema = v.union([
     BuilderUIPagesSerialisedSchema
 ]);
 export const BuilderUIItemsSerialisedSchema = v.pipe(v.array(paramable(BuilderUIItemSerialisedSchema)), v.readonly());
+export const validateUIPages = createEntityValidator('uiPages', BuilderUIPagesSerialisedSchema, (input, errors) => {
+    if (input.name.length === 0) {
+        errors.emptyName();
+    }
+    if (!isParamable(input.label) && input.label.length === 0) {
+        errors.emptyLabel();
+    }
+});
+export const validateUIItems = createEntityValidator('uiItems', BuilderUIItemsSerialisedSchema);

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

@@ -1,6 +1,6 @@
 import type { Paramable, ParamableSerialised } from '../../references';
-import type { BuilderExpectation, BuilderExpectations, BuilderExpectationsSerialised } from '../expectation';
 import type { CollectionNamesOf } from '../collection/index';
+import type { BuilderExpectation, BuilderExpectations, BuilderExpectationsSerialised } from '../expectation';
 import type { BuilderModel, BuilderModelGeneric, BuilderModelStateAsserted, BuilderModelStateOf } from '../model/index';
 import type { BuilderTags } from '../tags';
 import type { BuilderUIValidInputsOf } from './input';

package/dist/entities/ui/ui.js

@@ -1,8 +1,8 @@
 import * as v from 'valibot';
-import { check } from '../../check.js';
+import { check } from '../../errors/index.js';
 import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { BuilderUIDescribe } from './describe.js';
 import { BuilderUIPage } from './page.js';

package/dist/entities/ui/uis.js

@@ -1,4 +1,4 @@
-import { check } from '../../check.js';
+import { check } from '../../errors/index.js';
 import { BuilderModelSchema } from '../model/index.js';
 import { BuilderUI } from './ui.js';
 export function uis(...args) {

package/dist/entities/validated.d.ts

@@ -1,15 +1,19 @@
-import type { BuilderValidatedBrand } from '../validate/index';
-import type { BuilderComponentVariants, BuilderInstance, BuilderInstances } from '../instance';
+import type { BuilderErrors } from '../errors/index';
+import type { BuilderInstance, BuilderInstances, BuilderVariants } from '../instance';
 import type { Prettify } from '../prettify';
 import type { BuilderParameter, BuilderParameterSerialised, BuilderRef, BuilderRefSerialised } from '../references';
+import type { BuilderValidatedBrand } from '../validate/index';
 import type { BuilderSerialised } from './builder/index';
-import type { BuilderCollectionConfigSerialised, BuilderCollectionSerialised, BuilderCollectionsSerialised } from './collection/index';
-import type { BuilderComponentConfigSerialised, BuilderComponentSerialised, BuilderComponentsSerialised } from './component/index';
+import type { BuilderCollectionSerialised, BuilderCollectionsSerialised } from './collection/index';
+import type { BuilderComponentSerialised, BuilderComponentsSerialised } from './component/index';
+import type { BuilderEntityKind } from './kind';
 import type { BuilderModelSerialised } from './model/index';
-import type { BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionConfigSerialised } from './option/index';
+import type { BuilderOptionSerialised, BuilderOptionsSerialised } from './option/index';
 import type { BuilderPricingSerialised } from './pricing/index';
-import type { BuilderUIDescribeSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderUISerialised } from './ui/index';
-export type Validated<Input> = Input extends BuilderComponentVariants | BuilderInstance | BuilderModelSerialised | BuilderPricingSerialised | BuilderSerialised | BuilderUISerialised ? Validate<Input> & BuilderValidatedBrand : Validate<Input>;
+import type { entitiesMap } from './serialise';
+import type { BuilderUISerialised } from './ui/index';
+import type * as v from 'valibot';
+export type Validated<Input> = Input extends BuilderVariants | BuilderInstance | BuilderModelSerialised | BuilderPricingSerialised | BuilderSerialised | BuilderUISerialised ? Validate<Input> & BuilderValidatedBrand : Validate<Input>;
 type Validate<Input> = Input extends BuilderParameter<string> | BuilderParameterSerialised | BuilderRef | BuilderRefSerialised ? never : Input extends ReadonlyArray<unknown> ? ValidatedTuple<Input> : Input extends object ? {
     readonly [Key in keyof Input]: Validated<Input[Key]>;
 } : Input;
@@ -17,23 +21,27 @@ type ValidatedTuple<Input extends ReadonlyArray<unknown>> = Input extends readon
     infer Head,
     ...infer Rest extends ReadonlyArray<unknown>
 ] ? [Validated<Head>] extends [never] ? ValidatedTuple<Rest> : readonly [Validated<Head>, ...ValidatedTuple<Rest>] : Input extends readonly [] ? readonly [] : ReadonlyArray<Validated<Input[number]>>;
-export type BuilderValidated = Prettify<Validated<BuilderSerialised>>;
-export type BuilderModelValidated = Prettify<Validated<BuilderModelSerialised>>;
-export type BuilderUIValidated = Prettify<Validated<BuilderUISerialised>>;
+export type BuilderValidatedMap = {
+    readonly [Kind in BuilderEntityKind]: Prettify<Validated<v.InferOutput<(typeof entitiesMap)[Kind]['serialised']>>>;
+};
+export type ValidationResult<Entity> = readonly [Entity, BuilderErrors];
+export type BuilderValidated = BuilderValidatedMap['builder'];
+export type BuilderModelValidated = BuilderValidatedMap['model'];
+export type BuilderPricingValidated = BuilderValidatedMap['pricing'];
+export type BuilderUIValidated = BuilderValidatedMap['ui'];
+export type BuilderUIDescribeValidated = BuilderValidatedMap['uiDescribe'];
+export type BuilderUIItemsValidated = BuilderValidatedMap['uiItems'];
+export type BuilderUIPageValidated = BuilderValidatedMap['uiPage'];
 export type BuilderInstanceValidated = Prettify<Validated<BuilderInstance>>;
 export type BuilderInstancesValidated = Prettify<Validated<BuilderInstances>>;
-export type BuilderComponentVariantsValidated = Prettify<Validated<BuilderComponentVariants>>;
+export type BuilderVariantsValidated = Prettify<Validated<BuilderVariants>>;
 export type BuilderOptionValidated = Prettify<Validated<BuilderOptionSerialised>>;
 export type BuilderOptionsValidated = Prettify<Validated<BuilderOptionsSerialised>>;
-export type BuilderOptionConfigValidated = Prettify<Validated<BuilderOptionConfigSerialised>>;
+export type BuilderOptionConfigValidated = BuilderValidatedMap['select' | 'toggle'];
 export type BuilderComponentValidated = Prettify<Validated<BuilderComponentSerialised>>;
 export type BuilderComponentsValidated = Prettify<Validated<BuilderComponentsSerialised>>;
-export type BuilderComponentConfigValidated = Prettify<Validated<BuilderComponentConfigSerialised>>;
+export type BuilderComponentConfigValidated = BuilderValidatedMap['componentConfig'];
 export type BuilderCollectionValidated = Prettify<Validated<BuilderCollectionSerialised>>;
 export type BuilderCollectionsValidated = Prettify<Validated<BuilderCollectionsSerialised>>;
-export type BuilderCollectionConfigValidated = Prettify<Validated<BuilderCollectionConfigSerialised>>;
-export type BuilderPricingValidated = Prettify<Validated<BuilderPricingSerialised>>;
-export type BuilderUIItemsValidated = Prettify<Validated<BuilderUIItemsSerialised>>;
-export type BuilderUIPageValidated = Prettify<Validated<BuilderUIPageSerialised>>;
-export type BuilderUIDescribeValidated = Prettify<Validated<BuilderUIDescribeSerialised>>;
+export type BuilderCollectionConfigValidated = BuilderValidatedMap['collectionConfig'];
 export {};

package/dist/entities/when.d.ts

@@ -1,7 +1,7 @@
-import type { BuilderPath, BuilderPaths } from '../paths';
 import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
 import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '../references';
 import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from './model/index';
+import type { BuilderPath, BuilderPaths } from './paths';
 import * as v from 'valibot';
 export type BuilderEnableConfig<Payload = unknown> = {
     readonly type: 'enable';
@@ -112,6 +112,8 @@ export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.Varia
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>], undefined>, v.ReadonlyAction<{
+    type: "enable";
+} | {
     type: "match";
     matchPath: readonly (string | number)[] | Readonly<{
         type: "parameter";
@@ -131,12 +133,11 @@ export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.Varia
         type: "ref";
         id: string;
     }>;
-} | {
-    type: "enable";
 }>]>;
 export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
 export type BuilderWhenGeneric = BuilderWhen<unknown, unknown, unknown, unknown>;
 export declare const BuilderWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<unknown>>;
+export declare function whenBranches<Leaf>(payload: unknown, schema: v.GenericSchema<Leaf>): ReadonlyArray<Leaf>;
 export declare function createSelectMapSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderMatchSelectMap<v.InferOutput<Payload> | BuilderParameterSerialised>>;
 export declare function createWhenSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderWhenSerialised<v.InferOutput<Payload>>>;
 export declare function createWhenFactories<Payload>(): {

package/dist/entities/when.js

@@ -1,7 +1,8 @@
 import * as v from 'valibot';
-import { BuilderPathSchema } from '../paths.js';
+import { check } from '../errors/index.js';
 import { BuilderPrimitivesSchema } from '../primitive.js';
-import { paramable } from '../references.js';
+import { isParamable, paramable } from '../references.js';
+import { BuilderPathSchema } from './paths.js';
 export const BuilderWhenEnableSchema = v.object({
     type: v.literal('enable')
 });
@@ -15,6 +16,25 @@ export const BuilderWhenUnlessSchema = v.object({
 });
 export const BuilderWhenConfigSchema = v.pipe(v.variant('type', [BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema]), v.readonly());
 export const BuilderWhenSerialisedSchema = createWhenSerialisedSchema(v.unknown());
+export function whenBranches(payload, schema) {
+    if (check.is(schema, payload)) {
+        return [payload];
+    }
+    if (isParamable(payload)) {
+        return [];
+    }
+    check.assert(BuilderWhenSerialisedSchema, payload);
+    const when = payload;
+    switch (when.type) {
+        case 'enable':
+        case 'unless': {
+            return [when.payload];
+        }
+        case 'match': {
+            return Object.values(when.selectMap).filter((branch) => branch != null);
+        }
+    }
+}
 export function createSelectMapSerialisedSchema(payloadSchema) {
     return v.pipe(v.record(v.string(), v.nullable(paramable(payloadSchema))), v.readonly());
 }

package/dist/environment.d.ts

@@ -1,5 +1,5 @@
-import type { BuilderErrors } from './exception';
+import type { BuilderErrors } from './errors/index';
 import * as v from 'valibot';
 export declare const BuilderEnvironmentSchema: v.PicklistSchema<["development", "staging", "production"], undefined>;
 export type BuilderEnvironment = v.InferOutput<typeof BuilderEnvironmentSchema>;
-export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'development' ? readonly [EntityType, BuilderErrors] : readonly [EntityType, readonly never[]];
+export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'development' ? readonly [EntityType, BuilderErrors] : readonly [EntityType, ReadonlyArray<never>];

package/dist/{validate → errors}/errors.d.ts

@@ -1,16 +1,25 @@
-import type { BuilderExpectationKind } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { BuilderEntityKind, BuilderExpectationKind } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-export type BuilderInvalidInputTarget = 'builder' | 'model' | 'pricing' | 'ui' | 'variants';
-export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
-export type BuilderErrorInvalidPricingReason = 'scope' | 'nested-variants';
+export type BuilderErrorLocation = ReadonlyArray<string | number>;
+export declare function builderError<Kind extends string>(kind: Kind, location: BuilderErrorLocation): {
+    kind: Kind;
+    location: BuilderErrorLocation;
+};
+export type BuilderError = ReturnType<typeof builderError> & {
+    readonly [key: string]: unknown;
+};
+export type BuilderErrors = ReadonlyArray<BuilderError>;
 export declare class BuilderValidateErrors {
     #private;
     get errors(): BuilderErrors;
     scope<Result>(part: string | number, fn: () => Result): Result;
-    invalidInput(target: BuilderInvalidInputTarget): {
-        target: BuilderInvalidInputTarget;
-        kind: "invalid-input";
+    invalidEntity(target: BuilderEntityKind): {
+        target: "string" | "number" | "boolean" | "builder" | "model" | "select" | "toggle" | "optionSelectMap" | "optionWhen" | "componentConfig" | "componentSelectMap" | "componentWhen" | "collectionConfig" | "collectionSelectMap" | "collectionWhen" | "ui" | "uiDescribe" | "uiItems" | "uiPage" | "uiPages" | "uiInput" | "pricing" | "pricingRates" | "expectations" | "paths" | "path";
+        kind: "invalid-entity";
+        location: BuilderErrorLocation;
+    };
+    invalidVariants(): {
+        kind: "invalid-variants";
         location: BuilderErrorLocation;
     };
     invalidOption(name: string, value: unknown): {
@@ -29,15 +38,14 @@ export declare class BuilderValidateErrors {
         kind: "duplicate-name";
         location: BuilderErrorLocation;
     };
-    invalidCollectionBounds(name: string, min: number, max: number): {
-        name: string;
+    invalidCollectionBounds(min: number, max: number): {
         min: number;
         max: number;
         kind: "invalid-collection-bounds";
         location: BuilderErrorLocation;
     };
-    invalidPath(reason: BuilderErrorInvalidPathReason): {
-        reason: BuilderErrorInvalidPathReason;
+    invalidPath(reason: string): {
+        reason: string;
         kind: "invalid-path";
         location: BuilderErrorLocation;
     };
@@ -46,6 +54,38 @@ export declare class BuilderValidateErrors {
         kind: "invalid-select-map-key";
         location: BuilderErrorLocation;
     };
+    invalidSelectDefault(value: string): {
+        value: string;
+        kind: "invalid-select-default";
+        location: BuilderErrorLocation;
+    };
+    invalidSelectLabel(key: string): {
+        key: string;
+        kind: "invalid-select-label";
+        location: BuilderErrorLocation;
+    };
+    invalidToggleDefault(value: unknown, valueType: string): {
+        value: unknown;
+        valueType: string;
+        kind: "invalid-toggle-default";
+        location: BuilderErrorLocation;
+    };
+    emptyLabel(): {
+        kind: "empty-label";
+        location: BuilderErrorLocation;
+    };
+    emptyInputs(): {
+        kind: "empty-inputs";
+        location: BuilderErrorLocation;
+    };
+    emptyItems(): {
+        kind: "empty-items";
+        location: BuilderErrorLocation;
+    };
+    emptyName(): {
+        kind: "empty-name";
+        location: BuilderErrorLocation;
+    };
     unboundParameter(name: string): {
         name: string;
         kind: "unbound-parameter";
@@ -110,8 +150,8 @@ export declare class BuilderValidateErrors {
         kind: "invalid-detail";
         location: BuilderErrorLocation;
     };
-    invalidPricing(reason: BuilderErrorInvalidPricingReason): {
-        reason: BuilderErrorInvalidPricingReason;
+    invalidPricing(reason: string): {
+        reason: string;
         kind: "invalid-pricing";
         location: BuilderErrorLocation;
     };
@@ -125,24 +165,6 @@ export declare class BuilderValidateErrors {
         location: BuilderErrorLocation;
     };
 }
-export type BuilderErrorInvalidInput = ReturnType<BuilderValidateErrors['invalidInput']>;
-export type BuilderErrorInvalidOption = ReturnType<BuilderValidateErrors['invalidOption']>;
-export type BuilderErrorInvalidCollection = ReturnType<BuilderValidateErrors['invalidCollection']>;
-export type BuilderErrorDuplicateName = ReturnType<BuilderValidateErrors['duplicateName']>;
-export type BuilderErrorInvalidCollectionBounds = ReturnType<BuilderValidateErrors['invalidCollectionBounds']>;
-export type BuilderErrorInvalidPath = ReturnType<BuilderValidateErrors['invalidPath']>;
-export type BuilderErrorInvalidSelectMapKey = ReturnType<BuilderValidateErrors['invalidSelectMapKey']>;
-export type BuilderErrorUnboundParameter = ReturnType<BuilderValidateErrors['unboundParameter']>;
-export type BuilderErrorMissingReference = ReturnType<BuilderValidateErrors['missingReference']>;
-export type BuilderErrorUnmetExpectation = ReturnType<BuilderValidateErrors['unmetExpectation']>;
-export type BuilderErrorUnvalidated = ReturnType<BuilderValidateErrors['unvalidated']>;
-export type BuilderErrorMissingComponent = ReturnType<BuilderValidateErrors['missingComponent']>;
-export type BuilderErrorUnexpectedComponent = ReturnType<BuilderValidateErrors['unexpectedComponent']>;
-export type BuilderErrorMissingVariant = ReturnType<BuilderValidateErrors['missingVariant']>;
-export type BuilderErrorInvalidVariant = ReturnType<BuilderValidateErrors['invalidVariant']>;
-export type BuilderErrorMissingDetail = ReturnType<BuilderValidateErrors['missingDetail']>;
-export type BuilderErrorUnexpectedDetail = ReturnType<BuilderValidateErrors['unexpectedDetail']>;
-export type BuilderErrorInvalidDetail = ReturnType<BuilderValidateErrors['invalidDetail']>;
-export type BuilderErrorInvalidPricing = ReturnType<BuilderValidateErrors['invalidPricing']>;
-export type BuilderErrorMissingRate = ReturnType<BuilderValidateErrors['missingRate']>;
-export type BuilderErrorNoComponents = ReturnType<BuilderValidateErrors['noComponents']>;
+type ErrorMethodKey = Exclude<keyof BuilderValidateErrors, 'scope' | 'errors'>;
+export type BuilderErrorKind = ReturnType<BuilderValidateErrors[ErrorMethodKey]>['kind'];
+export {};

package/dist/{validate → errors}/errors.js

@@ -1,4 +1,6 @@
-import { builderError } from '../exception.js';
+export function builderError(kind, location) {
+    return { kind, location };
+}
 export class BuilderValidateErrors {
     #errors = [];
     #location = [];
@@ -14,12 +16,15 @@ export class BuilderValidateErrors {
             this.#location = this.#location.slice(0, -1);
         }
     }
-    invalidInput(target) {
+    invalidEntity(target) {
         return this.#addError({
-            ...builderError('invalid-input', this.#location),
+            ...builderError('invalid-entity', this.#location),
             target
         });
     }
+    invalidVariants() {
+        return this.#addError(builderError('invalid-variants', this.#location));
+    }
     invalidOption(name, value) {
         return this.#addError({
             ...builderError('invalid-option', this.#location),
@@ -39,10 +44,9 @@ export class BuilderValidateErrors {
             name
         });
     }
-    invalidCollectionBounds(name, min, max) {
+    invalidCollectionBounds(min, max) {
         return this.#addError({
             ...builderError('invalid-collection-bounds', this.#location),
-            name,
             min,
             max
         });
@@ -59,6 +63,37 @@ export class BuilderValidateErrors {
             key
         });
     }
+    invalidSelectDefault(value) {
+        return this.#addError({
+            ...builderError('invalid-select-default', this.#location),
+            value
+        });
+    }
+    invalidSelectLabel(key) {
+        return this.#addError({
+            ...builderError('invalid-select-label', this.#location),
+            key
+        });
+    }
+    invalidToggleDefault(value, valueType) {
+        return this.#addError({
+            ...builderError('invalid-toggle-default', this.#location),
+            value,
+            valueType
+        });
+    }
+    emptyLabel() {
+        return this.#addError(builderError('empty-label', this.#location));
+    }
+    emptyInputs() {
+        return this.#addError(builderError('empty-inputs', this.#location));
+    }
+    emptyItems() {
+        return this.#addError(builderError('empty-items', this.#location));
+    }
+    emptyName() {
+        return this.#addError(builderError('empty-name', this.#location));
+    }
     unboundParameter(name) {
         return this.#addError({
             ...builderError('unbound-parameter', this.#location),

package/dist/errors/exception.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderErrors } from './errors';
+export declare class BuilderException extends globalThis.Error {
+    readonly errors: BuilderErrors;
+    constructor(errors: BuilderErrors, message?: string);
+}

package/dist/{exception.js → errors/exception.js}

@@ -1,6 +1,3 @@
-export function builderError(kind, location) {
-    return { kind, location };
-}
 export class BuilderException extends globalThis.Error {
     errors;
     constructor(errors, message = '') {

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderError, BuilderErrorKind, BuilderErrorLocation, BuilderErrors } from './errors';
+export { check } from './check.js';
+export { BuilderValidateErrors } from './errors.js';
+export { BuilderException } from './exception.js';

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+export { check } from './check.js';
+export { BuilderValidateErrors } from './errors.js';
+export { BuilderException } from './exception.js';

package/dist/index.d.ts

@@ -1,27 +1,27 @@
-export type { BB, BBOptions } from './bb';
-export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentVariantsValidated, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { BB, BBOptions, BuilderEntityValidators } from './bb';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
 export type { BuilderEnvironment } from './environment';
-export type { BuilderError, BuilderErrorBase, BuilderErrorLocation, BuilderErrors } from './exception';
-export type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariant, BuilderVariants } from './instance';
+export type { BuilderError, BuilderErrorLocation, BuilderErrors } from './errors/index';
+export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariants } from './instance';
 export type { BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
-export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidPricingReason, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingRate, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from './validate/index';
-export type { BuilderPath, BuilderPaths } from './paths';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
+export type { BuilderErrorKind, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';
 import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, optionExpectation, uis } from './entities/index.js';
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, parameter, pricing, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { BuilderException } from './exception.js';
+export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './errors/index.js';
+export { parameter, ref } from './references.js';
 export { ordinal } from './mappers/index.js';
 export declare const collection: typeof collectionConfig & {
     enable: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import(".").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import(".").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import(".").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const component: typeof componentConfig & {
     enable: <const Payload extends import("./references").Paramable<import(".").BuilderComponentConfig>>(payload?: Payload) => import(".").BuilderEnableConfig<Payload>;
-    match: <const Payload extends import("./references").Paramable<import(".").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>, const Payload extends import("./references").Paramable<import(".").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import(".").BuilderUnlessConfig<Payload, UnlessPath>;
+    match: <const Payload extends import("./references").Paramable<import(".").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import(".").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends import("./references").Paramable<import(".").BuilderPath>, const Payload extends import("./references").Paramable<import(".").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import(".").BuilderUnlessConfig<Payload, UnlessPath>;
 };
 export declare const has: {
     collection: typeof collectionExpectation;
@@ -30,7 +30,7 @@ export declare const has: {
 };
 export declare const option: {
     enable: <const Values extends import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import(".").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import(".").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import(".").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const ui: typeof uis;

package/dist/index.js

@@ -1,7 +1,8 @@
 import { collectionConfig, collectionExpectation, collectionWhen, componentConfig, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, parameter, pricing, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { BuilderException } from './exception.js';
+export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './errors/index.js';
+export { parameter, ref } from './references.js';
 export { ordinal } from './mappers/index.js';
 export const collection = Object.assign(collectionConfig, {
     ...collectionWhen

package/dist/instance.d.ts

@@ -1,5 +1,5 @@
+import type { BuilderPrimitive } from './primitive';
 import * as v from 'valibot';
-import { type BuilderPrimitive } from './primitive.js';
 export type BuilderInstance = {
     readonly [key: string]: BuilderPrimitive | BuilderInstances;
 };
@@ -7,7 +7,7 @@ export declare const BuilderInstanceSchema: v.GenericSchema<BuilderInstance>;
 export declare const BuilderInstancesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderInstance>, undefined>, v.ReadonlyAction<BuilderInstance[]>]>;
 export type BuilderInstances = v.InferOutput<typeof BuilderInstancesSchema>;
 export type BuilderInstanceInput = Readonly<Record<string, unknown>>;
-export declare const BuilderVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export declare const BuilderComponentVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
     readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
@@ -18,8 +18,8 @@ export declare const BuilderVariantSchema: v.SchemaWithPipe<readonly [v.ObjectSc
     } | undefined;
     tags?: readonly string[] | undefined;
 }>]>;
-export type BuilderVariant = v.InferOutput<typeof BuilderVariantSchema>;
-export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export type BuilderComponentVariant = v.InferOutput<typeof BuilderComponentVariantSchema>;
+export declare const BuilderComponentVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
     readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
@@ -36,8 +36,8 @@ export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.ArraySc
     } | undefined;
     tags?: readonly string[] | undefined;
 }>[]>]>;
-export type BuilderVariants = v.InferOutput<typeof BuilderVariantsSchema>;
-export declare const BuilderComponentVariantsSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export type BuilderComponentVariants = v.InferOutput<typeof BuilderComponentVariantsSchema>;
+export declare const BuilderVariantsSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly instance: v.GenericSchema<BuilderInstance>;
     readonly details: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.NullableSchema<v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
     readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
@@ -62,4 +62,4 @@ export declare const BuilderComponentVariantsSchema: v.SchemaWithPipe<readonly [
         tags?: readonly string[] | undefined;
     }>[];
 }>]>;
-export type BuilderComponentVariants = v.InferOutput<typeof BuilderComponentVariantsSchema>;
+export type BuilderVariants = v.InferOutput<typeof BuilderVariantsSchema>;

package/dist/instance.js

@@ -1,12 +1,12 @@
 import * as v from 'valibot';
+import { BuilderTagsSchema } from './entities/index.js';
 import { BuilderPrimitiveSchema } from './primitive.js';
-import { BuilderTagsSchema } from './entities/tags.js';
 export const BuilderInstanceSchema = v.pipe(v.record(v.string(), v.union([BuilderPrimitiveSchema, v.lazy(() => BuilderInstancesSchema)])), v.readonly());
 export const BuilderInstancesSchema = v.pipe(v.array(BuilderInstanceSchema), v.readonly());
-export const BuilderVariantSchema = v.pipe(v.object({
+export const BuilderComponentVariantSchema = v.pipe(v.object({
     instance: BuilderInstanceSchema,
     details: v.optional(v.record(v.string(), BuilderPrimitiveSchema)),
     tags: v.optional(BuilderTagsSchema)
 }), v.readonly());
-export const BuilderVariantsSchema = v.pipe(v.array(BuilderVariantSchema), v.readonly());
-export const BuilderComponentVariantsSchema = v.pipe(v.record(v.string(), BuilderVariantsSchema), v.readonly());
+export const BuilderComponentVariantsSchema = v.pipe(v.array(BuilderComponentVariantSchema), v.readonly());
+export const BuilderVariantsSchema = v.pipe(v.record(v.string(), BuilderComponentVariantsSchema), v.readonly());

package/dist/mappers/instance.js

@@ -1,5 +1,5 @@
-import { check } from '../check.js';
 import { modelsMerge, optionValueSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from './resolve.js';
 export function createInstance(entity, partial = {}, references = []) {

package/dist/mappers/order.d.ts

@@ -1,6 +1,6 @@
-import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderReferences } from '../entities/index';
-import type { BuilderVariant } from '../instance';
+import type { BuilderInstanceValidated, BuilderModelValidated, BuilderReferences, BuilderVariantsValidated } from '../entities/index';
+import type { BuilderComponentVariant } from '../instance';
 export interface BuilderOrder {
-    readonly [key: string]: BuilderVariant | BuilderOrder | ReadonlyArray<BuilderOrder> | null;
+    readonly [key: string]: BuilderComponentVariant | BuilderOrder | ReadonlyArray<BuilderOrder> | null;
 }
-export declare function order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated, references?: BuilderReferences): BuilderOrder;
+export declare function order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderVariantsValidated, references?: BuilderReferences): BuilderOrder;

package/dist/mappers/order.js

@@ -1,4 +1,4 @@
-import { check } from '../check.js';
+import { check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveComponent } from './resolve.js';
 export function order(model, instance, variants, references = []) {