@builder-builder/builder 0.0.15 → 0.0.17

package/dist/entities/pricing.d.ts

@@ -1,64 +0,0 @@
-import * as v from 'valibot';
-export declare const BuilderPricingReduceSchema: v.PicklistSchema<["product", "sum", "first"], undefined>;
-export type BuilderPricingReduce = v.InferOutput<typeof BuilderPricingReduceSchema>;
-export type BuilderPricingTagExpression = {
-    readonly kind: 'tag';
-    readonly value: string;
-} | {
-    readonly kind: 'modelTags';
-} | {
-    readonly kind: 'variantTags';
-};
-export declare const BuilderPricingTagExpressionSchema: v.GenericSchema<BuilderPricingTagExpression>;
-export type BuilderPricingExpression = {
-    readonly kind: 'num';
-    readonly value: number;
-} | {
-    readonly kind: 'variantPrice';
-} | {
-    readonly kind: 'rate';
-    readonly rate: string;
-    readonly tag: BuilderPricingTagExpression;
-    readonly reduce?: BuilderPricingReduce;
-} | {
-    readonly kind: 'variants';
-    readonly tag?: BuilderPricingTagExpression;
-    readonly expression: BuilderPricingExpression;
-    readonly reduce?: BuilderPricingReduce;
-} | {
-    readonly kind: 'add';
-    readonly left: BuilderPricingExpression;
-    readonly right: BuilderPricingExpression;
-} | {
-    readonly kind: 'sub';
-    readonly left: BuilderPricingExpression;
-    readonly right: BuilderPricingExpression;
-} | {
-    readonly kind: 'mul';
-    readonly left: BuilderPricingExpression;
-    readonly right: BuilderPricingExpression;
-} | {
-    readonly kind: 'div';
-    readonly left: BuilderPricingExpression;
-    readonly right: BuilderPricingExpression;
-};
-export declare const BuilderPricingExpressionSchema: v.GenericSchema<BuilderPricingExpression>;
-export type BuilderPricing = {
-    readonly rates: Record<string, Record<string, number>>;
-    readonly formula: BuilderPricingExpression;
-};
-export declare const BuilderPricingSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly rates: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<{
-        [x: string]: {
-            [x: string]: number;
-        };
-    }>]>;
-    readonly formula: v.GenericSchema<BuilderPricingExpression>;
-}, undefined>, v.ReadonlyAction<{
-    readonly rates: Readonly<{
-        [x: string]: {
-            [x: string]: number;
-        };
-    }>;
-    formula: BuilderPricingExpression;
-}>]>;

package/dist/entities/pricing.js

@@ -1,48 +0,0 @@
-import * as v from 'valibot';
-import { serialisable } from '../serialisable.js';
-export const BuilderPricingReduceSchema = v.picklist(['product', 'sum', 'first']);
-export const BuilderPricingTagExpressionSchema = v.variant('kind', [
-    v.object({ kind: v.literal('tag'), value: v.string() }),
-    v.object({ kind: v.literal('modelTags') }),
-    v.object({ kind: v.literal('variantTags') })
-]);
-export const BuilderPricingExpressionSchema = v.lazy(() => v.variant('kind', [
-    v.object({ kind: v.literal('num'), value: v.number() }),
-    v.object({ kind: v.literal('variantPrice') }),
-    v.object({
-        kind: v.literal('rate'),
-        rate: v.string(),
-        tag: BuilderPricingTagExpressionSchema,
-        reduce: v.optional(BuilderPricingReduceSchema)
-    }),
-    v.object({
-        kind: v.literal('variants'),
-        tag: v.optional(BuilderPricingTagExpressionSchema),
-        expression: BuilderPricingExpressionSchema,
-        reduce: v.optional(BuilderPricingReduceSchema)
-    }),
-    v.object({
-        kind: v.literal('add'),
-        left: BuilderPricingExpressionSchema,
-        right: BuilderPricingExpressionSchema
-    }),
-    v.object({
-        kind: v.literal('sub'),
-        left: BuilderPricingExpressionSchema,
-        right: BuilderPricingExpressionSchema
-    }),
-    v.object({
-        kind: v.literal('mul'),
-        left: BuilderPricingExpressionSchema,
-        right: BuilderPricingExpressionSchema
-    }),
-    v.object({
-        kind: v.literal('div'),
-        left: BuilderPricingExpressionSchema,
-        right: BuilderPricingExpressionSchema
-    })
-]));
-export const BuilderPricingSchema = serialisable(v.object({
-    rates: v.pipe(v.record(v.string(), v.record(v.string(), v.number())), v.readonly()),
-    formula: BuilderPricingExpressionSchema
-}));

package/dist/mappers/pricing.d.ts

@@ -1,3 +0,0 @@
-import type { BuilderModelValidated, BuilderRefEntities } from '../entities/index';
-import type { BuilderOrder } from './order';
-export declare function pricing(model: BuilderModelValidated, pricingInput: unknown, order: BuilderOrder, refs?: BuilderRefEntities): number;

package/dist/mappers/pricing.js

@@ -1,101 +0,0 @@
-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);
-    });
-}