@builder-builder/builder 0.0.14 → 0.0.16

package/dist/entities/validated.d.ts

@@ -7,8 +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 { BuilderPricingSerialised } from './pricing/index';
 import type { BuilderUIDescribeSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderUISerialised } from './ui/index';
-export type Validated<Input> = Input extends BuilderComponentVariants | BuilderInstance | BuilderModelSerialised | 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;
@@ -31,6 +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<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/exception.d.ts

@@ -1,11 +1,11 @@
-import type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated } from './validate/index';
+import type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPricing, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated } from './validate/index';
 export type BuilderErrorLocation = ReadonlyArray<string | number>;
 export declare function builderError<Kind extends string>(kind: Kind, location: BuilderErrorLocation): {
     kind: Kind;
     location: BuilderErrorLocation;
 };
 export type BuilderErrorBase = ReturnType<typeof builderError>;
-export type BuilderError = BuilderErrorUnmetExpectation | BuilderErrorUnboundParameter | BuilderErrorMissingReference | BuilderErrorInvalidPath | BuilderErrorInvalidSelectMapKey | BuilderErrorDuplicateName | BuilderErrorInvalidCollectionBounds | BuilderErrorInvalidOption | BuilderErrorInvalidCollection | BuilderErrorMissingComponent | BuilderErrorUnexpectedComponent | BuilderErrorMissingVariant | BuilderErrorInvalidVariant | BuilderErrorMissingDetail | BuilderErrorUnexpectedDetail | BuilderErrorInvalidDetail | BuilderErrorInvalidInput | BuilderErrorUnvalidated;
+export type BuilderError = BuilderErrorUnmetExpectation | BuilderErrorUnboundParameter | BuilderErrorMissingReference | BuilderErrorInvalidPath | BuilderErrorInvalidPricing | BuilderErrorInvalidSelectMapKey | BuilderErrorDuplicateName | BuilderErrorInvalidCollectionBounds | BuilderErrorInvalidOption | BuilderErrorInvalidCollection | BuilderErrorMissingComponent | BuilderErrorUnexpectedComponent | BuilderErrorMissingVariant | BuilderErrorInvalidVariant | BuilderErrorMissingDetail | BuilderErrorUnexpectedDetail | BuilderErrorInvalidDetail | BuilderErrorInvalidInput | BuilderErrorUnvalidated;
 export type BuilderErrors = ReadonlyArray<BuilderError>;
 export declare class BuilderException extends globalThis.Error {
     readonly errors: BuilderErrors;

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, BuilderSerialised, 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, 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/instance.d.ts

@@ -10,47 +10,56 @@ export type BuilderInstanceInput = Readonly<Record<string, unknown>>;
 export declare const BuilderVariantSchema: 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>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
         [x: string]: string | number | boolean | null;
     } | 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<{
     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>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
         [x: string]: string | number | boolean | null;
     } | undefined;
+    tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     instance: BuilderInstance;
     details?: {
         [x: string]: string | number | boolean | null;
     } | 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<{
     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>;
 }, undefined>, v.ReadonlyAction<{
     instance: BuilderInstance;
     details?: {
         [x: string]: string | number | boolean | null;
     } | undefined;
+    tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     instance: BuilderInstance;
     details?: {
         [x: string]: string | number | boolean | null;
     } | undefined;
+    tags?: readonly string[] | undefined;
 }>[]>]>, undefined>, v.ReadonlyAction<{
     readonly [x: string]: readonly Readonly<{
         instance: BuilderInstance;
         details?: {
             [x: string]: string | number | boolean | null;
         } | undefined;
+        tags?: readonly string[] | undefined;
     }>[];
 }>]>;
 export type BuilderComponentVariants = v.InferOutput<typeof BuilderComponentVariantsSchema>;

package/dist/instance.js

@@ -1,10 +1,12 @@
 import * as v from 'valibot';
 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({
     instance: BuilderInstanceSchema,
-    details: v.optional(v.record(v.string(), BuilderPrimitiveSchema))
+    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());

package/dist/mappers/index.d.ts

@@ -1,10 +1,11 @@
-export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, 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, validateUI, validateVariants } from '../validate/index.js';
+export { assertValidated, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from '../validate/index.js';
 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 { price } from './price.js';
 export { ordinal, render } from './render/index.js';
 export { resolveCollection, resolveComponent, resolveOption } from './resolve.js';

package/dist/mappers/index.js

@@ -1,6 +1,7 @@
-export { assertValidated, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from '../validate/index.js';
+export { assertValidated, validateBuilder, validateInstance, validateModel, validatePricing, validateUI, validateVariants } from '../validate/index.js';
 export { createInstance } from './instance.js';
 export { createVariants, optionGraph, variantsFor } from './variants/index.js';
 export { order } from './order.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,27 +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 { 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;
     });
     const data = validate({
-        ...serialise.builder(builder()),
-        model: mergedModel,
-        ui: validatedUI
+        ...input,
+        model: validate(mergedModel),
+        ui: validate(validatedUI),
+        pricing: validate(validatedPricing)
     });
     return [data, errors.errors];
 }

package/dist/validate/errors.d.ts

@@ -1,8 +1,9 @@
 import type { BuilderExpectationKind } from '../entities/index';
 import type { BuilderErrorLocation, BuilderErrors } from '../exception';
 import type { BuilderInstance } from '../instance';
-export type BuilderInvalidInputTarget = 'builder' | 'model' | 'ui' | 'variants';
+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 declare class BuilderValidateErrors {
     #private;
     get errors(): BuilderErrors;
@@ -109,6 +110,20 @@ export declare class BuilderValidateErrors {
         kind: "invalid-detail";
         location: BuilderErrorLocation;
     };
+    invalidPricing(reason: BuilderErrorInvalidPricingReason): {
+        reason: BuilderErrorInvalidPricingReason;
+        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']>;
@@ -128,3 +143,6 @@ export type BuilderErrorInvalidVariant = ReturnType<BuilderValidateErrors['inval
 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']>;

package/dist/validate/errors.js

@@ -134,6 +134,21 @@ export class BuilderValidateErrors {
             instance
         });
     }
+    invalidPricing(reason) {
+        return this.#addError({
+            ...builderError('invalid-pricing', this.#location),
+            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,12 +1,14 @@
 export type { BuilderValidationResult } from './builder';
-export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, 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';
 export type { BuilderUIValidationResult } from './ui';
 export type { BuilderComponentVariantsValidationResult, BuilderVariantsValidationOptions } from './variants';
 export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';
 export { validateModel } from './model.js';
+export { validatePricing } from './pricing.js';
 export { validateUI } from './ui.js';
 export { validateVariants } from './variants.js';

package/dist/validate/index.js

@@ -2,5 +2,6 @@ export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
 export { validateInstance } from './instance.js';
 export { validateModel } from './model.js';
+export { validatePricing } from './pricing.js';
 export { validateUI } from './ui.js';
 export { validateVariants } from './variants.js';

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);
+}

package/dist/validate/pricing.d.ts

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