@builder-builder/builder 0.0.15 → 0.0.16

package/dist/entities/serialise.js

@@ -1,63 +1,64 @@
 import * as v from 'valibot';
+import { check } from '../check.js';
 import { BuilderPathSchema, BuilderPathsSchema } from '../paths.js';
 import { BuilderParameterSchema, BuilderRefSchema, isParamable } from '../references.js';
-import { check } from '../check.js';
+import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection/index.js';
 import { BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
-import { BuilderPricingSchema } from './pricing.js';
 import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema } from './option/index.js';
+import { BuilderPricingSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema } from './pricing/index.js';
 import { BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIInputSchema, BuilderUIInputSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
-import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 export const entitiesMap = {
     builder: { runtime: BuilderSchema, serialised: BuilderSerialisedSchema },
     model: { runtime: BuilderModelSchema, serialised: BuilderModelSerialisedSchema },
-    ui: { runtime: BuilderUISchema, serialised: BuilderUISerialisedSchema },
     select: { runtime: BuilderSelectTypeSchema, serialised: BuilderSelectTypeSerialisedSchema },
     toggle: { runtime: BuilderToggleTypeSchema, serialised: BuilderToggleTypeSerialisedSchema },
-    uiPage: { runtime: BuilderUIPageSchema, serialised: BuilderUIPageSerialisedSchema },
-    uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
-    uiPages: { runtime: BuilderUIPagesSchema, serialised: BuilderUIPagesSerialisedSchema },
-    uiInput: { runtime: BuilderUIInputSchema, serialised: BuilderUIInputSerialisedSchema },
-    pricing: { runtime: BuilderPricingSchema, serialised: BuilderPricingSchema },
-    componentDetails: {
-        runtime: BuilderComponentDetailsSchema,
-        serialised: BuilderComponentDetailsSerialisedSchema
-    },
-    collectionConfig: {
-        runtime: BuilderCollectionConfigSchema,
-        serialised: BuilderCollectionConfigSerialisedSchema
-    },
-    expectations: {
-        runtime: BuilderExpectationsSchema,
-        serialised: BuilderExpectationsSerialisedSchema
+    optionSelectMap: {
+        runtime: BuilderOptionSelectMapSerialisedSchema,
+        serialised: BuilderOptionSelectMapSerialisedSchema
     },
-    uiItems: { runtime: BuilderUIItemsSerialisedSchema, serialised: BuilderUIItemsSerialisedSchema },
     optionWhen: {
         runtime: BuilderOptionWhenSerialisedSchema,
         serialised: BuilderOptionWhenSerialisedSchema
     },
-    componentWhen: {
-        runtime: BuilderComponentWhenSerialisedSchema,
-        serialised: BuilderComponentWhenSerialisedSchema
-    },
-    collectionWhen: {
-        runtime: BuilderCollectionWhenSerialisedSchema,
-        serialised: BuilderCollectionWhenSerialisedSchema
-    },
-    optionSelectMap: {
-        runtime: BuilderOptionSelectMapSerialisedSchema,
-        serialised: BuilderOptionSelectMapSerialisedSchema
+    componentDetails: {
+        runtime: BuilderComponentDetailsSchema,
+        serialised: BuilderComponentDetailsSerialisedSchema
     },
     componentSelectMap: {
         runtime: BuilderComponentSelectMapSerialisedSchema,
         serialised: BuilderComponentSelectMapSerialisedSchema
     },
+    componentWhen: {
+        runtime: BuilderComponentWhenSerialisedSchema,
+        serialised: BuilderComponentWhenSerialisedSchema
+    },
+    collectionConfig: {
+        runtime: BuilderCollectionConfigSchema,
+        serialised: BuilderCollectionConfigSerialisedSchema
+    },
     collectionSelectMap: {
         runtime: BuilderCollectionSelectMapSerialisedSchema,
         serialised: BuilderCollectionSelectMapSerialisedSchema
     },
+    collectionWhen: {
+        runtime: BuilderCollectionWhenSerialisedSchema,
+        serialised: BuilderCollectionWhenSerialisedSchema
+    },
+    ui: { runtime: BuilderUISchema, serialised: BuilderUISerialisedSchema },
+    uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
+    uiItems: { runtime: BuilderUIItemsSerialisedSchema, serialised: BuilderUIItemsSerialisedSchema },
+    uiPage: { runtime: BuilderUIPageSchema, serialised: BuilderUIPageSerialisedSchema },
+    uiPages: { runtime: BuilderUIPagesSchema, serialised: BuilderUIPagesSerialisedSchema },
+    uiInput: { runtime: BuilderUIInputSchema, serialised: BuilderUIInputSerialisedSchema },
+    pricing: { runtime: BuilderPricingSchema, serialised: BuilderPricingSerialisedSchema },
+    pricingRates: { runtime: BuilderRatesSchema, serialised: BuilderRatesSchema },
+    expectations: {
+        runtime: BuilderExpectationsSchema,
+        serialised: BuilderExpectationsSerialisedSchema
+    },
     paths: { runtime: BuilderPathsSchema, serialised: BuilderPathsSchema },
     path: { runtime: BuilderPathSchema, serialised: BuilderPathSchema },
     number: { runtime: v.number(), serialised: v.number() },
@@ -97,7 +98,7 @@ const serialiserMap = [
         ui: serialiseValue(value.ui),
         bindings: serialiseRecord(value.bindings),
         tags: value.tags,
-        pricing: value.pricing
+        pricing: value.pricing == null ? value.pricing : serialiseValue(value.pricing)
     })),
     serialiser(BuilderModelSchema, (value) => ({
         models: value.models.map(serialiseValue),
@@ -132,6 +133,10 @@ const serialiserMap = [
         items: serialiseValue(value.items),
         tags: value.tags
     })),
+    serialiser(BuilderPricingSchema, (value) => ({
+        rates: value.rates.map(serialiseValue),
+        formula: serialiseValue(value.formula)
+    })),
     serialiser(BuilderUIInputSchema, (value) => serialiseRecord({ ...value })),
     serialiser(BuilderOptionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentSchema, serialiseNamedEntry),

package/dist/entities/validated.d.ts

@@ -7,9 +7,9 @@ import type { BuilderCollectionConfigSerialised, BuilderCollectionSerialised, Bu
 import type { BuilderComponentDetailsSerialised, BuilderComponentSerialised, BuilderComponentsSerialised } from './component/index';
 import type { BuilderModelSerialised } from './model/index';
 import type { BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValuesSerialised } from './option/index';
-import type { BuilderPricing } from './pricing';
+import type { BuilderPricingSerialised } from './pricing/index';
 import type { BuilderUIDescribeSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderUISerialised } from './ui/index';
-export type Validated<Input> = Input extends BuilderComponentVariants | BuilderInstance | BuilderModelSerialised | BuilderPricing | BuilderSerialised | BuilderUISerialised ? Validate<Input> & BuilderValidatedBrand : Validate<Input>;
+export type Validated<Input> = Input extends BuilderComponentVariants | 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;
@@ -32,7 +32,7 @@ export type BuilderComponentDetailsValidated = Prettify<Validated<BuilderCompone
 export type BuilderCollectionValidated = Prettify<Validated<BuilderCollectionSerialised>>;
 export type BuilderCollectionsValidated = Prettify<Validated<BuilderCollectionsSerialised>>;
 export type BuilderCollectionConfigValidated = Prettify<Validated<BuilderCollectionConfigSerialised>>;
-export type BuilderPricingValidated = Prettify<Validated<BuilderPricing>>;
+export type BuilderPricingValidated = Prettify<Validated<BuilderPricingSerialised>>;
 export type BuilderUIItemsValidated = Prettify<Validated<BuilderUIItemsSerialised>>;
 export type BuilderUIPageValidated = Prettify<Validated<BuilderUIPageSerialised>>;
 export type BuilderUIDescribeValidated = Prettify<Validated<BuilderUIDescribeSerialised>>;

package/dist/environment.d.ts

@@ -2,4 +2,4 @@ import type { BuilderErrors } from './exception';
 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 'production' ? EntityType : readonly [EntityType, BuilderErrors];
+export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'development' ? readonly [EntityType, BuilderErrors] : EntityType;

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 export type { BB, BBOptions } from './bb';
-export type { BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderRefEntities, BuilderRefEntity, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderPricing, BuilderPricingExpression, BuilderPricingReduce, BuilderPricingTagExpression, BuilderSerialised, BuilderTags, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputsSerialised, BuilderUIInputSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUIsSerialised, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderEnableConfig, BuilderMatchConfig, BuilderMatchSelectMap, BuilderUnlessConfig, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, 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, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderRefEntities, BuilderRefEntity, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderTags, BuilderToggleType, BuilderToggleTypeSerialised, 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 { BuilderEnvironment } from './environment';
 export type { BuilderError, BuilderErrorBase, BuilderErrorLocation, BuilderErrors } from './exception';
-export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidPricingReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from './mappers/index';
 export type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariant, BuilderVariants } from './instance';
+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, BuilderOrder, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from './mappers/index';
 export type { BuilderPath, BuilderPaths } from './paths';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
 export { bb } from './bb.js';
-export { Builder, builder, detailBoolean, detailNumber, detailString, input, model, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.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 { ordinal } from './mappers/index.js';
 import { collectionConfig, collectionExpectation, componentDetails, componentExpectation, optionExpectation, uis } from './entities/index.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { bb } from './bb.js';
-export { Builder, builder, detailBoolean, detailNumber, detailString, input, model, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.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 { ordinal } from './mappers/index.js';
 import { collectionConfig, collectionExpectation, collectionWhen, componentDetails, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';

package/dist/mappers/index.d.ts

@@ -1,4 +1,4 @@
-export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidPricingReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from '../validate/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 { BuilderOrder } from './order';
 export type { BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './render/index';
 export { assertValidated, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from '../validate/index.js';
@@ -6,6 +6,6 @@ export type { BuilderOptionGraph } from './variants/index.js';
 export { createInstance } from './instance.js';
 export { createVariants, optionGraph, variantsFor } from './variants/index.js';
 export { order } from './order.js';
-export { pricing } from './pricing.js';
+export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
 export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';

package/dist/mappers/index.js

@@ -2,6 +2,6 @@ export { assertValidated, validateBuilder, validateInstance, validateModel, vali
 export { createInstance } from './instance.js';
 export { createVariants, optionGraph, variantsFor } from './variants/index.js';
 export { order } from './order.js';
-export { pricing } from './pricing.js';
+export { price } from './price.js';
 export { ordinal, render } from './render/index.js';
 export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';

package/dist/mappers/price.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderPricingValidated } from '../entities/index';
+import type { BuilderOrder } from './order';
+export declare function price(pricingInput: BuilderPricingValidated, order: BuilderOrder): number | null;

package/dist/mappers/price.js

@@ -0,0 +1,111 @@
+import * as v from 'valibot';
+import { check } from '../check.js';
+import { BuilderPricingExpressionSchema } from '../entities/index.js';
+import { BuilderVariantSchema } from '../instance.js';
+const NumberSchema = v.number();
+export function price(pricingInput, order) {
+    const { rates, formula } = pricingInput;
+    if (formula == null) {
+        return null;
+    }
+    const variants = collectVariants(order);
+    return evaluate(formula);
+    function evaluate(expression, currentVariant = null) {
+        check.assert(BuilderPricingExpressionSchema, expression);
+        if (check.is(NumberSchema, expression)) {
+            return expression;
+        }
+        switch (expression.kind) {
+            case 'variantPrice':
+                return variantPrice(currentVariant);
+            case 'lookup':
+                return evaluateLookup(expression, currentVariant);
+            case 'variants':
+                return evaluateVariants(expression);
+            case 'add':
+                return combine(expression.left, expression.right, currentVariant, (l, r) => l + r);
+            case 'sub':
+                return combine(expression.left, expression.right, currentVariant, (l, r) => l - r);
+            case 'mul':
+                return combine(expression.left, expression.right, currentVariant, (l, r) => l * r);
+            case 'div':
+                return combine(expression.left, expression.right, currentVariant, (l, r) => l / r);
+        }
+    }
+    function combine(left, right, currentVariant, operation) {
+        const leftValue = evaluate(left, currentVariant);
+        const rightValue = evaluate(right, currentVariant);
+        if (leftValue == null || rightValue == null) {
+            return null;
+        }
+        return operation(leftValue, rightValue);
+    }
+    function lookupRate(rate, key) {
+        let value = null;
+        rates.forEach((entry) => {
+            const candidate = entry[rate]?.[key];
+            if (check.is(NumberSchema, candidate)) {
+                value = candidate;
+            }
+        });
+        return value;
+    }
+    function variantPrice(variant) {
+        const candidate = variant?.details?.price;
+        return check.is(NumberSchema, candidate) ? candidate : null;
+    }
+    function evaluateLookup(expression, currentVariant) {
+        const keys = resolveKey(expression.key, currentVariant);
+        const matches = keys
+            .map((key) => lookupRate(expression.rate, key))
+            .filter((value) => value != null);
+        if (matches.length === 0) {
+            return null;
+        }
+        return reduceValues(matches, expression.reduce ?? 'product');
+    }
+    function evaluateVariants(expression) {
+        const { tag } = expression;
+        const candidates = tag == null ? variants : variants.filter((variant) => (variant.tags ?? []).includes(tag));
+        const results = candidates.map((variant) => evaluate(expression.expression, variant));
+        if (results.some((value) => value == null)) {
+            return null;
+        }
+        return reduceValues(results, expression.reduce ?? 'sum');
+    }
+    function resolveKey(key, currentVariant) {
+        switch (key.kind) {
+            case 'variantTags':
+                return currentVariant?.tags ?? [];
+            case 'option': {
+                const value = currentVariant?.instance?.[key.name];
+                return value == null ? [] : [String(value)];
+            }
+        }
+    }
+}
+function reduceValues(values, mode) {
+    if (mode === 'product') {
+        return values.reduce((accumulator, value) => accumulator * value, 1);
+    }
+    if (mode === 'sum') {
+        return values.reduce((accumulator, value) => accumulator + value, 0);
+    }
+    check.truthy(values.length > 0, 'Pricing: cannot reduce empty set with "first"! ❌');
+    const [first] = values;
+    return first;
+}
+function collectVariants(order) {
+    return Object.values(order).flatMap((value) => {
+        if (value == null) {
+            return [];
+        }
+        if (check.is(BuilderVariantSchema, value)) {
+            return [value];
+        }
+        if (Array.isArray(value)) {
+            return value.flatMap(collectVariants);
+        }
+        return collectVariants(value);
+    });
+}

package/dist/validate/builder.js

@@ -3,31 +3,36 @@ import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../ent
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
-import { validatePricingStructure } from './pricing.js';
+import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
 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');
-        return [validate(serialise.builder(builder())), errors.errors];
+        return [EMPTY_BUILDER, errors.errors];
     }
     const resolve = resolver(errors, references, input.bindings);
     const validatedModel = errors.scope('model', () => validateModelStructure(input.model, resolve, errors));
-    const validatedUI = errors.scope('ui', () => validateUIStructure(input.ui, resolve, errors));
     const mergedModel = modelsMerge(validatedModel);
     errors.scope('model', () => {
         checkModelExpectations(mergedModel, validatedModel, errors);
     });
-    errors.scope('ui', () => {
-        checkUIExpectations(mergedModel, validatedUI, errors);
+    const validatedUI = errors.scope('ui', () => {
+        const validated = validateUIStructure(input.ui, resolve, errors);
+        checkUIExpectations(mergedModel, validated, errors);
+        return validated;
+    });
+    const validatedPricing = errors.scope('pricing', () => {
+        const validated = validatePricingStructure(input.pricing, resolve, errors);
+        checkPricingExpectations(mergedModel, validated, errors);
+        return validated;
     });
-    if (input.pricing) {
-        errors.scope('pricing', () => validatePricingStructure(resolve(input.pricing) ?? input.pricing, errors));
-    }
     const data = validate({
         ...input,
-        model: mergedModel,
-        ui: validatedUI
+        model: validate(mergedModel),
+        ui: validate(validatedUI),
+        pricing: validate(validatedPricing)
     });
     return [data, errors.errors];
 }

package/dist/validate/errors.d.ts

@@ -3,7 +3,7 @@ import type { BuilderErrorLocation, BuilderErrors } from '../exception';
 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' | 'missing-rate' | 'invalid-filter';
+export type BuilderErrorInvalidPricingReason = 'scope' | 'nested-variants';
 export declare class BuilderValidateErrors {
     #private;
     get errors(): BuilderErrors;
@@ -110,12 +110,20 @@ export declare class BuilderValidateErrors {
         kind: "invalid-detail";
         location: BuilderErrorLocation;
     };
-    invalidPricing(reason: BuilderErrorInvalidPricingReason, detail?: string): {
+    invalidPricing(reason: BuilderErrorInvalidPricingReason): {
         reason: BuilderErrorInvalidPricingReason;
-        detail: string | undefined;
         kind: "invalid-pricing";
         location: BuilderErrorLocation;
     };
+    missingRate(rate: string): {
+        rate: string;
+        kind: "missing-rate";
+        location: BuilderErrorLocation;
+    };
+    noComponents(): {
+        kind: "no-components";
+        location: BuilderErrorLocation;
+    };
 }
 export type BuilderErrorInvalidInput = ReturnType<BuilderValidateErrors['invalidInput']>;
 export type BuilderErrorInvalidOption = ReturnType<BuilderValidateErrors['invalidOption']>;
@@ -136,3 +144,5 @@ export type BuilderErrorMissingDetail = ReturnType<BuilderValidateErrors['missin
 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']>;

package/dist/validate/errors.js

@@ -134,13 +134,21 @@ export class BuilderValidateErrors {
             instance
         });
     }
-    invalidPricing(reason, detail) {
+    invalidPricing(reason) {
         return this.#addError({
             ...builderError('invalid-pricing', this.#location),
-            reason,
-            detail
+            reason
         });
     }
+    missingRate(rate) {
+        return this.#addError({
+            ...builderError('missing-rate', this.#location),
+            rate
+        });
+    }
+    noComponents() {
+        return this.#addError(builderError('no-components', this.#location));
+    }
     #addError(error) {
         this.#errors = [...this.#errors, error];
         return error;

package/dist/validate/index.d.ts

@@ -1,5 +1,5 @@
 export type { BuilderValidationResult } from './builder';
-export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidPricing, BuilderErrorInvalidPricingReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInvalidInputTarget } from './errors';
+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';

package/dist/validate/model.js

@@ -1,8 +1,9 @@
 import { check } from '../check.js';
-import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
+import { BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema, model, modelsMerge, serialise } from '../entities/index.js';
 import { validate } from './brand.js';
 import { BuilderValidateErrors } from './errors.js';
 import { checkExpectations } from './expectations.js';
+import { checkPath, collectionConfigs } from './paths.js';
 import { resolver } from './resolve.js';
 const EMPTY_MODEL = validate(serialise.model(model()));
 export function validateModel(input, references = [], errors = new BuilderValidateErrors()) {
@@ -106,23 +107,13 @@ export function validateModelStructure(input, resolve, errors) {
             errors.scope('paths', () => {
                 paths.forEach((path, pathIndex) => {
                     errors.scope(pathIndex, () => {
-                        checkPath(path);
+                        checkPath(modelInput, path, errors);
                     });
                 });
             });
         }
         checkWhenPaths(payload);
     }
-    function checkPath(path) {
-        const reached = walkPath([modelInput], path.slice(0, -1));
-        if (reached == null) {
-            return;
-        }
-        const optionName = path.at(-1);
-        if (!reached.some((candidate) => candidate.options.some((option) => option.name === optionName))) {
-            errors.invalidPath('option-not-found');
-        }
-    }
     function checkWhenPaths(payload) {
         if (!check.is(BuilderWhenSerialisedSchema, payload)) {
             return;
@@ -130,7 +121,7 @@ export function validateModelStructure(input, resolve, errors) {
         if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
             errors.scope('payload', () => {
                 errors.scope('matchPath', () => {
-                    checkPath(payload.matchPath);
+                    checkPath(modelInput, payload.matchPath, errors);
                 });
             });
             return;
@@ -138,42 +129,11 @@ export function validateModelStructure(input, resolve, errors) {
         if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
             errors.scope('payload', () => {
                 errors.scope('unlessPath', () => {
-                    checkPath(payload.unlessPath);
+                    checkPath(modelInput, payload.unlessPath, errors);
                 });
             });
         }
     }
-    function walkPath(candidates, remaining) {
-        if (remaining.length === 0) {
-            return candidates;
-        }
-        const [collectionName, index, ...rest] = remaining;
-        if (typeof collectionName !== 'string' || typeof index !== 'number') {
-            errors.invalidPath('shape');
-            return null;
-        }
-        const matchedConfigs = candidates.flatMap((current) => {
-            const collection = current.collections.find((entry) => entry.name === collectionName);
-            return collection == null ? [] : [collectionConfigs(collection)];
-        });
-        if (matchedConfigs.length === 0) {
-            errors.invalidPath('missing-collection');
-            return null;
-        }
-        const anyOutOfBounds = matchedConfigs.some((configs) => configs.length > 0 && configs.every(({ max }) => typeof max === 'number' && index >= max));
-        if (anyOutOfBounds) {
-            errors.invalidPath('out-of-bounds');
-            return null;
-        }
-        const next = matchedConfigs.flatMap((configs) => configs
-            .filter(({ max }) => typeof max !== 'number' || index < max)
-            .flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []));
-        if (next.length === 0) {
-            errors.invalidPath('missing-collection');
-            return null;
-        }
-        return walkPath(next, rest);
-    }
     function checkCollectionBounds(collection) {
         collectionConfigs(collection).forEach(({ min, max }) => {
             if (typeof min !== 'number' || typeof max !== 'number') {
@@ -185,20 +145,3 @@ export function validateModelStructure(input, resolve, errors) {
         });
     }
 }
-function collectionConfigs(collection) {
-    const { payload } = collection;
-    if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
-        return [payload];
-    }
-    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
-        return [];
-    }
-    if (payload.type === 'match') {
-        return Object.entries(payload.selectMap).flatMap(([, value]) => check.is(BuilderCollectionConfigSerialisedSchema, value)
-            ? [value]
-            : []);
-    }
-    return check.is(BuilderCollectionConfigSerialisedSchema, payload.payload)
-        ? [payload.payload]
-        : [];
-}

package/dist/validate/paths.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderCollectionConfigSerialised, BuilderCollectionSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderPath } from '../paths';
+import type { BuilderValidateErrors } from './errors';
+export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderValidateErrors): void;
+export declare function collectionConfigs(collection: BuilderCollectionSerialised): ReadonlyArray<BuilderCollectionConfigSerialised>;

package/dist/validate/paths.js

@@ -0,0 +1,68 @@
+import * as v from 'valibot';
+import { check } from '../check.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+const NumberSchema = v.number();
+const StringSchema = v.string();
+export function checkPath(model, path, errors) {
+    const models = walkPath([model], path.slice(0, -1), errors);
+    if (models == null) {
+        return;
+    }
+    const optionName = path.at(-1);
+    if (!check.is(StringSchema, optionName)) {
+        errors.invalidPath('shape');
+        return;
+    }
+    if (!models.some((model) => model.options.some((option) => option.name === optionName))) {
+        errors.invalidPath('option-not-found');
+    }
+}
+export function collectionConfigs(collection) {
+    const { payload } = collection;
+    if (check.is(BuilderCollectionConfigSerialisedSchema, payload)) {
+        return [payload];
+    }
+    if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+        return [];
+    }
+    if (payload.type === 'match') {
+        if (!check.is(BuilderCollectionSelectMapSerialisedSchema, payload.selectMap)) {
+            return [];
+        }
+        return Object.values(payload.selectMap).flatMap((value) => check.is(BuilderCollectionConfigSerialisedSchema, value) ? [value] : []);
+    }
+    return check.is(BuilderCollectionConfigSerialisedSchema, payload.payload)
+        ? [payload.payload]
+        : [];
+}
+function walkPath(candidates, remaining, errors) {
+    if (remaining.length === 0) {
+        return candidates;
+    }
+    const [collectionName, index, ...rest] = remaining;
+    if (!check.is(StringSchema, collectionName) || !check.is(NumberSchema, index)) {
+        errors.invalidPath('shape');
+        return null;
+    }
+    const matchedConfigs = candidates.flatMap((current) => {
+        const collection = current.collections.find((entry) => entry.name === collectionName);
+        return collection == null ? [] : [collectionConfigs(collection)];
+    });
+    if (matchedConfigs.length === 0) {
+        errors.invalidPath('missing-collection');
+        return null;
+    }
+    const anyOutOfBounds = matchedConfigs.some((configs) => configs.length > 0 && configs.every(({ max }) => check.is(NumberSchema, max) && index >= max));
+    if (anyOutOfBounds) {
+        errors.invalidPath('out-of-bounds');
+        return null;
+    }
+    const next = matchedConfigs.flatMap((configs) => configs
+        .filter(({ max }) => !check.is(NumberSchema, max) || index < max)
+        .flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []));
+    if (next.length === 0) {
+        errors.invalidPath('missing-collection');
+        return null;
+    }
+    return walkPath(next, rest, errors);
+}