@builder-builder/builder 0.0.20 → 0.0.22

package/dist/mappers/price.js

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
 import { BuilderPricingExpressionSchema } from '../entities/index.js';
-import { BuilderVariantSchema } from '../instance.js';
+import { check } from '../errors/index.js';
+import { BuilderComponentVariantSchema } from '../instance.js';
 const NumberSchema = v.number();
 export function price(pricingInput, order) {
     const { rates, formula } = pricingInput;
@@ -10,31 +10,31 @@ export function price(pricingInput, order) {
     }
     const variants = collectVariants(order);
     return evaluate(formula);
-    function evaluate(expression, currentVariant = null) {
+    function evaluate(expression, variant = null) {
         check.assert(BuilderPricingExpressionSchema, expression);
         if (check.is(NumberSchema, expression)) {
             return expression;
         }
         switch (expression.kind) {
             case 'variantPrice':
-                return variantPrice(currentVariant);
+                return variantPrice(variant);
             case 'lookup':
-                return evaluateLookup(expression, currentVariant);
+                return evaluateLookup(expression, variant);
             case 'variants':
                 return evaluateVariants(expression);
             case 'add':
-                return combine(expression.left, expression.right, currentVariant, (l, r) => l + r);
+                return combine(expression.left, expression.right, variant, (l, r) => l + r);
             case 'sub':
-                return combine(expression.left, expression.right, currentVariant, (l, r) => l - r);
+                return combine(expression.left, expression.right, variant, (l, r) => l - r);
             case 'mul':
-                return combine(expression.left, expression.right, currentVariant, (l, r) => l * r);
+                return combine(expression.left, expression.right, variant, (l, r) => l * r);
             case 'div':
-                return combine(expression.left, expression.right, currentVariant, (l, r) => l / r);
+                return combine(expression.left, expression.right, variant, (l, r) => l / r);
         }
     }
-    function combine(left, right, currentVariant, operation) {
-        const leftValue = evaluate(left, currentVariant);
-        const rightValue = evaluate(right, currentVariant);
+    function combine(left, right, variant, operation) {
+        const leftValue = evaluate(left, variant);
+        const rightValue = evaluate(right, variant);
         if (leftValue == null || rightValue == null) {
             return null;
         }
@@ -54,8 +54,8 @@ export function price(pricingInput, order) {
         const candidate = variant?.details?.price;
         return check.is(NumberSchema, candidate) ? candidate : null;
     }
-    function evaluateLookup(expression, currentVariant) {
-        const keys = resolveKey(expression.key, currentVariant);
+    function evaluateLookup(expression, variant) {
+        const keys = resolveKey(expression.key, variant);
         const matches = keys
             .map((key) => lookupRate(expression.rate, key))
             .filter((value) => value != null);
@@ -73,12 +73,12 @@ export function price(pricingInput, order) {
         }
         return reduceValues(results, expression.reduce ?? 'sum');
     }
-    function resolveKey(key, currentVariant) {
+    function resolveKey(key, variant) {
         switch (key.kind) {
             case 'variantTags':
-                return currentVariant?.tags ?? [];
+                return variant?.tags ?? [];
             case 'option': {
-                const value = currentVariant?.instance?.[key.name];
+                const value = variant?.instance?.[key.name];
                 return value == null ? [] : [String(value)];
             }
         }
@@ -100,7 +100,7 @@ function collectVariants(order) {
         if (value == null) {
             return [];
         }
-        if (check.is(BuilderVariantSchema, value)) {
+        if (check.is(BuilderComponentVariantSchema, value)) {
             return [value];
         }
         if (Array.isArray(value)) {

package/dist/mappers/render/render.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { check } from '../../check.js';
+import { check } from '../../errors/index.js';
 import { BuilderInstancesSchema } from '../../instance.js';
 import { BuilderPrimitiveSchema } from '../../primitive.js';
 import { createInstance } from '../instance.js';

package/dist/mappers/resolve.d.ts

@@ -1,6 +1,5 @@
-import type { BuilderCollectionConfigsSerialised, BuilderCollectionConfigValidated, BuilderCollectionSerialised, BuilderCollectionValidated, BuilderComponentConfigsSerialised, BuilderComponentConfigValidated, BuilderComponentSerialised, BuilderComponentValidated, BuilderModelValidated, BuilderOptionConfigsSerialised, BuilderOptionConfigValidated, BuilderOptionSerialised, BuilderOptionValidated, BuilderReferences } from '../entities/index';
+import type { BuilderCollectionConfigsSerialised, BuilderCollectionConfigValidated, BuilderCollectionSerialised, BuilderCollectionValidated, BuilderComponentConfigsSerialised, BuilderComponentConfigValidated, BuilderComponentSerialised, BuilderComponentValidated, BuilderModelValidated, BuilderOptionConfigsSerialised, BuilderOptionConfigValidated, BuilderOptionSerialised, BuilderOptionValidated, BuilderPath, BuilderReferences } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-import type { BuilderPath } from '../paths';
 export declare function resolveOption(option: BuilderOptionValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderOptionConfigValidated | null;
 export declare function resolveOptions(option: BuilderOptionSerialised, references?: BuilderReferences): BuilderOptionConfigsSerialised;
 export declare function resolveComponent(component: BuilderComponentValidated, model: BuilderModelValidated, instance: unknown, references?: BuilderReferences): BuilderComponentConfigValidated | null;

package/dist/mappers/resolve.js

@@ -1,8 +1,7 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderWhenSerialisedSchema, modelsMerge } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, modelsMerge, whenBranches } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { BuilderInstanceSchema, BuilderInstancesSchema } from '../instance.js';
-import { BuilderPathsSchema } from '../paths.js';
 import { BuilderPrimitiveSchema } from '../primitive.js';
 import { BuilderRefSerialisedSchema } from '../references.js';
 export function resolveOption(option, model, instance, references = []) {
@@ -105,21 +104,5 @@ function resolveEntryInstance(entry, schema, model, instance, references) {
     }
 }
 function resolveEntryExhaustive(entry, schema, references) {
-    const payload = resolveReference(entry.payload, references);
-    if (check.is(schema, payload)) {
-        return [payload];
-    }
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return [];
-    }
-    const when = payload;
-    switch (when.type) {
-        case 'enable':
-        case 'unless': {
-            return [when.payload];
-        }
-        case 'match': {
-            return Object.values(when.selectMap).filter((branch) => branch != null);
-        }
-    }
+    return whenBranches(resolveReference(entry.payload, references), schema);
 }

package/dist/mappers/variants/option-graph.d.ts

@@ -1,6 +1,5 @@
-import type { BuilderModelValidated, BuilderOptionValidated } from '../../entities/index';
+import type { BuilderModelValidated, BuilderOptionValidated, BuilderPaths } from '../../entities/index';
 import type { BuilderInstances } from '../../instance';
-import type { BuilderPaths } from '../../paths';
 export type GraphKeys = ReadonlySet<string>;
 export type GraphPath = {
     name: string;

package/dist/mappers/variants/option-graph.js

@@ -1,6 +1,5 @@
-import { check } from '../../check.js';
-import { BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
-import { BuilderPathSchema } from '../../paths.js';
+import { BuilderPathSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from '../../entities/index.js';
+import { check } from '../../errors/index.js';
 import { resolveOption } from '../resolve.js';
 export function crossProduct(left, right) {
     return left.flatMap((leftModel) => right.map((rightModel) => ({ ...leftModel, ...rightModel })));

package/dist/mappers/variants/variants.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderCollectionValidated, BuilderComponentValidated, BuilderModelValidated, BuilderValidated } from '../../entities/index';
-import type { BuilderComponentVariants, BuilderInstances } from '../../instance';
+import type { BuilderVariants, BuilderInstances } from '../../instance';
 import { BuilderOptionGraph } from './option-graph.js';
-export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+export declare function createVariants(entity: BuilderValidated | BuilderModelValidated): BuilderVariants;
 export declare function optionGraph(model: BuilderModelValidated): BuilderOptionGraph;
 export declare function variantsFor(entity: BuilderComponentValidated | BuilderCollectionValidated, options: BuilderOptionGraph): BuilderInstances;

package/dist/mappers/variants/variants.js

@@ -1,5 +1,5 @@
-import { check } from '../../check.js';
 import { BuilderModelSerialisedSchema, BuilderSerialisedSchema } from '../../entities/index.js';
+import { check } from '../../errors/index.js';
 import { resolveCollection } from '../resolve.js';
 import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
 export function createVariants(entity) {

package/dist/private.d.ts

@@ -1,4 +1,3 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
 export { BuilderEnvironmentSchema } from './environment.js';
 export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
-export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/private.js

@@ -1,4 +1,3 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
 export { BuilderEnvironmentSchema } from './environment.js';
 export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
-export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/references.js

@@ -1,5 +1,5 @@
 import * as v from 'valibot';
-import { check } from './check.js';
+import { check } from './errors/index.js';
 export class BuilderParameter {
     id;
     name;

package/dist/validate/brand.js

@@ -1,5 +1,4 @@
-import { BuilderException } from '../exception.js';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderException, BuilderValidateErrors } from '../errors/index.js';
 const VALIDATED_ENTITIES = new WeakSet();
 export function validate(value) {
     VALIDATED_ENTITIES.add(value);

package/dist/validate/builder.d.ts

@@ -1,5 +1,4 @@
-import type { BuilderReferences, BuilderValidated } from '../entities/index';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import type { BuilderReferences, BuilderValidated, ValidationResult } from '../entities/index';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderValidationResult = ValidationResult<BuilderValidated>;
 export declare function validateBuilder(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderValidationResult;

package/dist/validate/builder.js

@@ -1,7 +1,6 @@
-import { check } from '../check.js';
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
 import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
@@ -9,7 +8,7 @@ import { checkUIExpectations, validateUIStructure } from './ui.js';
 const EMPTY_BUILDER = validate(serialise.builder(builder()));
 export function validateBuilder(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        errors.invalidInput('builder');
+        errors.invalidEntity('builder');
         return [EMPTY_BUILDER, errors.errors];
     }
     const resolve = resolver(errors, references, input.bindings);

package/dist/validate/expectations.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderValidateErrors } from './errors';
+import type { BuilderValidateErrors } from '../errors/index';
 export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/index.d.ts

@@ -1,11 +1,13 @@
+export type { BuilderValidatedMap, ValidationResult } from '../entities/index';
+export type { BuilderErrorKind, BuilderValidateErrors } from '../errors/index';
 export type { BuilderValidatedBrand } from './brand';
 export type { BuilderValidationResult } from './builder';
-export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidPricingReason, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingRate, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInvalidInputTarget } from './errors';
 export type { BuilderInstanceValidationResult } from './instance';
 export type { BuilderModelValidationResult } from './model';
 export type { BuilderPricingValidationResult } from './pricing';
 export type { BuilderUIValidationResult } from './ui';
-export type { BuilderComponentVariantsValidationResult, BuilderVariantsValidationOptions } from './variants';
+export type { BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './variants';
+export { createEntityValidator } from '../entities/index.js';
 export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';

package/dist/validate/index.js

@@ -1,3 +1,4 @@
+export { createEntityValidator } from '../entities/index.js';
 export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';

package/dist/validate/instance.d.ts

@@ -1,6 +1,5 @@
-import type { BuilderInstanceValidated, BuilderModelValidated } from '../entities/index';
+import type { BuilderInstanceValidated, BuilderModelValidated, ValidationResult } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
 export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderValidateErrors): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,9 +1,8 @@
-import { check } from '../check.js';
 import { optionValueSchema } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 export function validateInstance(model, instance, errors = new BuilderValidateErrors()) {
     errors.scope('instance', () => {
         checkInstance(model, instance);

package/dist/validate/model.d.ts

@@ -1,8 +1,7 @@
-import type { BuilderModelSerialised, BuilderModelValidated, BuilderReferences } from '../entities/index';
+import type { BuilderModelSerialised, BuilderModelValidated, BuilderReferences, ValidationResult } from '../entities/index';
 import type { ParamableSerialised } from '../references';
 import type { BuilderResolve } from './resolve';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
 export declare function validateModel(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderModelValidationResult;
 export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/model.js

@@ -1,15 +1,14 @@
-import { check } from '../check.js';
-import { BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
-import { resolveCollections } from '../mappers/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
+import { isParamable } from '../references.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 const EMPTY_MODEL = validate(serialise.model(model()));
 export function validateModel(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        errors.invalidInput('model');
+        errors.invalidEntity('model');
         return [EMPTY_MODEL, errors.errors];
     }
     const resolve = resolver(errors, references);
@@ -41,9 +40,32 @@ export function validateModelStructure(input, resolve, errors) {
     const modelInput = resolved;
     const skipPathValidation = modelInput.expectations.length > 0;
     const childModels = errors.scope('models', () => modelInput.models.flatMap((part, partIndex) => errors.scope(partIndex, () => [validateModelStructure(part, resolve, errors)])));
-    const options = walkEntries(modelInput.options, 'option');
-    const components = walkEntries(modelInput.components, 'component');
-    const collections = walkCollections();
+    const options = errors.scope('options', () => walkEntries(modelInput.options, (resolved) => {
+        whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
+            .filter((config) => !isParamable(config))
+            .forEach((config) => {
+            if (config.type === 'select') {
+                validateSelect(config, [], errors);
+            }
+            else if (config.type === 'toggle') {
+                validateToggle(config, [], errors);
+            }
+        });
+    }));
+    const components = errors.scope('components', () => walkEntries(modelInput.components, (resolved) => {
+        whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
+            .filter((config) => !isParamable(config))
+            .forEach((config) => {
+            validateComponentConfig(config, [], errors);
+        });
+    }));
+    const collections = errors.scope('collections', () => walkEntries(modelInput.collections, (resolved) => {
+        whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
+            .filter((config) => !isParamable(config))
+            .forEach((config) => {
+            validateCollectionConfig(config, [], errors);
+        });
+    }));
     return {
         ...modelInput,
         models: childModels,
@@ -51,34 +73,17 @@ export function validateModelStructure(input, resolve, errors) {
         components,
         collections
     };
-    function walkEntries(entries, entryKind) {
+    function walkEntries(entries, validateBranches) {
         const seen = new Set();
         const items = [];
-        errors.scope(`${entryKind}s`, () => {
-            entries.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
-                    const resolved = resolveEntry(entry, seen);
-                    if (resolved != null) {
-                        items.push(resolved);
-                    }
-                });
-            });
-        });
-        return items;
-    }
-    function walkCollections() {
-        const seen = new Set();
-        const items = [];
-        errors.scope('collections', () => {
-            modelInput.collections.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
-                    const resolved = resolveEntry(entry, seen);
-                    if (resolved == null) {
-                        return;
-                    }
-                    checkCollectionBounds(resolved);
-                    items.push(resolved);
-                });
+        entries.forEach((entry, entryIndex) => {
+            errors.scope(entryIndex, () => {
+                const resolved = resolveEntry(entry, seen);
+                if (resolved == null) {
+                    return;
+                }
+                validateBranches(resolved);
+                items.push(resolved);
             });
         });
         return items;
@@ -135,14 +140,4 @@ export function validateModelStructure(input, resolve, errors) {
             });
         }
     }
-    function checkCollectionBounds(collection) {
-        resolveCollections(collection).forEach(({ min, max }) => {
-            if (typeof min !== 'number' || typeof max !== 'number') {
-                return;
-            }
-            if (min < 0 || max <= 0 || max < min) {
-                errors.invalidCollectionBounds(collection.name, min, max);
-            }
-        });
-    }
 }

package/dist/validate/paths.d.ts

@@ -1,4 +1,3 @@
-import type { BuilderModelSerialised } from '../entities/index';
-import type { BuilderPath } from '../paths';
-import type { BuilderValidateErrors } from './errors';
+import type { BuilderModelSerialised, BuilderPath } from '../entities/index';
+import type { BuilderValidateErrors } from '../errors/index';
 export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderValidateErrors): void;

package/dist/validate/paths.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
 import { BuilderModelSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 const NumberSchema = v.number();
 const StringSchema = v.string();

package/dist/validate/pricing.d.ts

@@ -1,7 +1,6 @@
-import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderReferences } from '../entities/index';
+import type { BuilderModelSerialised, BuilderPricingSerialised, BuilderPricingValidated, BuilderReferences, ValidationResult } from '../entities/index';
 import type { BuilderResolve } from './resolve';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderPricingValidationResult = ValidationResult<BuilderPricingValidated>;
 export declare function validatePricing(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
 export declare function validatePricingStructure(input: BuilderPricingSerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderPricingSerialised;

package/dist/validate/pricing.js

@@ -1,14 +1,13 @@
 import * as v from 'valibot';
-import { check } from '../check.js';
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { resolver } from './resolve.js';
 const EMPTY_PRICING = validate(serialise.pricing(pricing()));
 const NumberSchema = v.number();
 export function validatePricing(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
-        errors.invalidInput('pricing');
+        errors.invalidEntity('pricing');
         return [EMPTY_PRICING, errors.errors];
     }
     const resolve = resolver(errors, references);

package/dist/validate/resolve.d.ts

@@ -1,4 +1,4 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
-import type { BuilderValidateErrors } from './errors';
+import type { BuilderValidateErrors } from '../errors/index';
 export type BuilderResolve = (value: unknown) => unknown;
 export declare function resolver(errors: BuilderValidateErrors, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -1,5 +1,5 @@
-import { check } from '../check.js';
 import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
 export function resolver(errors, references = [], bindings = {}) {

package/dist/validate/ui.d.ts

@@ -1,7 +1,6 @@
-import type { BuilderModelSerialised, BuilderReferences, BuilderUISerialised, BuilderUIValidated } from '../entities/index';
+import type { BuilderModelSerialised, BuilderReferences, BuilderUISerialised, BuilderUIValidated, ValidationResult } from '../entities/index';
 import type { BuilderResolve } from './resolve';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
 export declare function validateUI(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderUIValidationResult;
 export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderUIValidated;

package/dist/validate/ui.js

@@ -1,14 +1,13 @@
-import { check } from '../check.js';
-import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis } from '../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
-        errors.invalidInput('ui');
+        errors.invalidEntity('ui');
         return [validate(serialise.ui(uis())), errors.errors];
     }
     const resolve = resolver(errors, references);
@@ -40,6 +39,15 @@ export function validateUIStructure(ui, resolve, errors) {
         }));
     }
     function walkUIItem(item) {
+        if (item.type === 'page') {
+            validateUIPage(item, [], errors);
+        }
+        else if (item.type === 'pages') {
+            validateUIPages(item, [], errors);
+        }
+        else if (item.type === 'describe') {
+            validateUIDescribe(item, [], errors);
+        }
         const label = errors.scope('label', () => resolve(item.label) ?? item.label);
         if (item.type === 'pages') {
             const innerItems = errors.scope('items', () => {
@@ -65,6 +73,7 @@ export function validateUIStructure(ui, resolve, errors) {
         }));
     }
     function walkInput(value) {
+        validateUIInput(value, [], errors);
         const path = errors.scope('path', () => resolve(value.path) ?? value.path);
         const displayName = value.displayName &&
             errors.scope('displayName', () => resolve(value.displayName) ?? value.displayName);

package/dist/validate/variants.d.ts

@@ -1,8 +1,7 @@
-import type { BuilderComponentVariantsValidated, BuilderModelValidated } from '../entities/index';
-import type { ValidationResult } from './result';
-import { BuilderValidateErrors } from './errors.js';
+import type { BuilderModelValidated, BuilderVariantsValidated, ValidationResult } from '../entities/index';
+import { BuilderValidateErrors } from '../errors/index.js';
 export type BuilderVariantsValidationOptions = {
     readonly partial?: boolean;
 };
-export type BuilderComponentVariantsValidationResult = ValidationResult<BuilderComponentVariantsValidated>;
-export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderComponentVariantsValidationResult;
+export type BuilderVariantsValidationResult = ValidationResult<BuilderVariantsValidated>;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderVariantsValidationResult;

package/dist/validate/variants.js

@@ -1,12 +1,11 @@
-import { check } from '../check.js';
 import { BuilderComponentConfigSerialisedSchema, detailValueSchema } from '../entities/index.js';
-import { BuilderComponentVariantsSchema } from '../instance.js';
+import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderVariantsSchema } from '../instance.js';
 import { createVariants } from '../mappers/index.js';
 import { validate } from './brand.js';
-import { BuilderValidateErrors } from './errors.js';
 export function validateVariants(model, input, options = {}, errors = new BuilderValidateErrors()) {
-    if (!check.is(BuilderComponentVariantsSchema, input)) {
-        errors.invalidInput('variants');
+    if (!check.is(BuilderVariantsSchema, input)) {
+        errors.invalidVariants();
         return [validate({}), errors.errors];
     }
     const variants = input;