@builder-builder/builder 0.0.14 → 0.0.15

package/dist/mappers/pricing.js

@@ -0,0 +1,101 @@
+import * as v from 'valibot';
+import { check } from '../check.js';
+import { BuilderPricingSchema } from '../entities/index.js';
+import { BuilderVariantSchema } from '../instance.js';
+import { resolveRef } from './resolve.js';
+export function pricing(model, pricingInput, order, refs = []) {
+    const resolved = resolveRef(pricingInput, refs);
+    check.assert(BuilderPricingSchema, resolved, 'Pricing did not resolve to a pricing entity! ❌');
+    const { rates, formula } = resolved;
+    const modelTags = model.tags ?? [];
+    const variants = collectVariants(order);
+    return evaluate(formula);
+    function evaluate(expression, currentVariant = null) {
+        switch (expression.kind) {
+            case 'num':
+                return expression.value;
+            case 'variantPrice':
+                return variantPrice(currentVariant);
+            case 'rate':
+                return evaluateRate(expression, currentVariant);
+            case 'variants':
+                return evaluateVariants(expression);
+            case 'add':
+                return (evaluate(expression.left, currentVariant) + evaluate(expression.right, currentVariant));
+            case 'sub':
+                return (evaluate(expression.left, currentVariant) - evaluate(expression.right, currentVariant));
+            case 'mul':
+                return (evaluate(expression.left, currentVariant) * evaluate(expression.right, currentVariant));
+            case 'div':
+                return (evaluate(expression.left, currentVariant) / evaluate(expression.right, currentVariant));
+        }
+    }
+    function evaluateRate(expression, currentVariant) {
+        const table = rates[expression.rate];
+        check.truthy(table, `Pricing: rate '${expression.rate}' not found! ❌`);
+        const tagOrTags = resolveTagExpression(expression.tag, currentVariant);
+        const keys = Array.isArray(tagOrTags) ? tagOrTags : [tagOrTags];
+        const matches = keys
+            .map((key) => table[key])
+            .filter((value) => typeof value === 'number');
+        check.truthy(matches.length > 0, `Pricing: rate '${expression.rate}' has no entry for keys [${keys.join(', ')}]! ❌`);
+        return reduceValues(matches, expression.reduce ?? 'product');
+    }
+    function evaluateVariants(expression) {
+        const { tag } = expression;
+        const candidates = tag ? variants.filter((variant) => matchesFilter(variant, tag)) : variants;
+        const results = candidates.map((variant) => evaluate(expression.expression, variant));
+        return reduceValues(results, expression.reduce ?? 'sum');
+    }
+    function resolveTagExpression(tag, currentVariant) {
+        switch (tag.kind) {
+            case 'tag':
+                return tag.value;
+            case 'modelTags':
+                return modelTags;
+            case 'variantTags':
+                check.truthy(currentVariant, 'Pricing: variantTags used outside variants iteration! ❌');
+                return currentVariant.tags ?? [];
+        }
+    }
+    function matchesFilter(variant, filter) {
+        if (filter.kind === 'tag') {
+            return (variant.tags ?? []).includes(filter.value);
+        }
+        if (filter.kind === 'modelTags') {
+            return (variant.tags ?? []).some((tag) => modelTags.includes(tag));
+        }
+        check.falsy(true, 'Pricing: variantTags is not a valid variants.tag filter! ❌');
+        return false;
+    }
+}
+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"! ❌');
+    return values[0];
+}
+function variantPrice(variant) {
+    check.truthy(variant, 'Pricing: variantPrice used outside variants iteration! ❌');
+    const price = variant.details?.price;
+    check.assert(v.number(), price, 'Pricing: variant missing numeric price detail! ❌');
+    return price;
+}
+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,6 +3,7 @@ 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 { resolver } from './resolve.js';
 import { checkUIExpectations, validateUIStructure } from './ui.js';
 export function validateBuilder(input, references = [], errors = new BuilderValidateErrors()) {
@@ -20,8 +21,11 @@ export function validateBuilder(input, references = [], errors = new BuilderVali
     errors.scope('ui', () => {
         checkUIExpectations(mergedModel, validatedUI, errors);
     });
+    if (input.pricing) {
+        errors.scope('pricing', () => validatePricingStructure(resolve(input.pricing) ?? input.pricing, errors));
+    }
     const data = validate({
-        ...serialise.builder(builder()),
+        ...input,
         model: mergedModel,
         ui: validatedUI
     });

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' | 'missing-rate' | 'invalid-filter';
 export declare class BuilderValidateErrors {
     #private;
     get errors(): BuilderErrors;
@@ -109,6 +110,12 @@ export declare class BuilderValidateErrors {
         kind: "invalid-detail";
         location: BuilderErrorLocation;
     };
+    invalidPricing(reason: BuilderErrorInvalidPricingReason, detail?: string): {
+        reason: BuilderErrorInvalidPricingReason;
+        detail: string | undefined;
+        kind: "invalid-pricing";
+        location: BuilderErrorLocation;
+    };
 }
 export type BuilderErrorInvalidInput = ReturnType<BuilderValidateErrors['invalidInput']>;
 export type BuilderErrorInvalidOption = ReturnType<BuilderValidateErrors['invalidOption']>;
@@ -128,3 +135,4 @@ 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']>;

package/dist/validate/errors.js

@@ -134,6 +134,13 @@ export class BuilderValidateErrors {
             instance
         });
     }
+    invalidPricing(reason, detail) {
+        return this.#addError({
+            ...builderError('invalid-pricing', this.#location),
+            reason,
+            detail
+        });
+    }
     #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, BuilderErrorInvalidPricingReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, 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/pricing.d.ts

@@ -0,0 +1,6 @@
+import type { BuilderPricingValidated } from '../entities/index';
+import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
+export type BuilderPricingValidationResult = ValidationResult<BuilderPricingValidated>;
+export declare function validatePricing(input: unknown, errors?: BuilderValidateErrors): BuilderPricingValidationResult;
+export declare function validatePricingStructure(pricingInput: unknown, errors: BuilderValidateErrors): void;

package/dist/validate/pricing.js

@@ -0,0 +1,71 @@
+import { check } from '../check.js';
+import { BuilderPricingSchema } from '../entities/index.js';
+import { validate } from './brand.js';
+import { BuilderValidateErrors } from './errors.js';
+const EMPTY_PRICING = validate({
+    rates: {},
+    formula: { kind: 'num', value: 0 }
+});
+export function validatePricing(input, errors = new BuilderValidateErrors()) {
+    if (!check.is(BuilderPricingSchema, input)) {
+        errors.invalidInput('pricing');
+        return [EMPTY_PRICING, errors.errors];
+    }
+    validatePricingStructure(input, errors);
+    return [validate(input), errors.errors];
+}
+export function validatePricingStructure(pricingInput, errors) {
+    if (!check.is(BuilderPricingSchema, pricingInput)) {
+        return;
+    }
+    const pricing = pricingInput;
+    walkExpr(pricing.formula, false);
+    function walkExpr(expression, insideVariants) {
+        switch (expression.kind) {
+            case 'num':
+                return;
+            case 'variantPrice':
+                if (!insideVariants) {
+                    errors.invalidPricing('scope', 'variantPrice may only be used inside a variants.expression');
+                }
+                return;
+            case 'rate':
+                errors.scope('rate', () => {
+                    if (pricing.rates[expression.rate] == null) {
+                        errors.invalidPricing('missing-rate', `rate '${expression.rate}' is not defined`);
+                    }
+                    checkTagExpr(expression.tag, insideVariants);
+                });
+                return;
+            case 'variants':
+                errors.scope('variants', () => {
+                    if (insideVariants) {
+                        errors.invalidPricing('nested-variants', 'variants cannot nest inside variants');
+                    }
+                    const { tag } = expression;
+                    if (tag) {
+                        errors.scope('tag', () => checkFilterTagExpr(tag));
+                    }
+                    errors.scope('expression', () => walkExpr(expression.expression, true));
+                });
+                return;
+            case 'add':
+            case 'sub':
+            case 'mul':
+            case 'div':
+                errors.scope('left', () => walkExpr(expression.left, insideVariants));
+                errors.scope('right', () => walkExpr(expression.right, insideVariants));
+                return;
+        }
+    }
+    function checkTagExpr(tag, insideVariants) {
+        if (tag.kind === 'variantTags' && !insideVariants) {
+            errors.invalidPricing('scope', 'variantTags may only be used inside a variants.expression');
+        }
+    }
+    function checkFilterTagExpr(tag) {
+        if (tag.kind === 'variantTags') {
+            errors.invalidPricing('invalid-filter', 'variantTags is not a valid variants.tag filter');
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "type": "module",
   "exports": {
     ".": {