@builder-builder/builder 0.0.14 → 0.0.16

package/dist/entities/option/select.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 export class BuilderSelectType {
     type = 'select';
     options;
@@ -7,22 +8,31 @@ export class BuilderSelectType {
     defaultValue;
     isOptional;
     optionLabels;
-    constructor(values, defaultValue, optional = false, optionLabels = {}) {
+    tags;
+    constructor(values, defaultValue, optional = false, optionLabels = {}, tags) {
         this.options = values;
         this.valueSchema = selectValueSchema(values, optional);
         this.defaultValue = defaultValue;
         this.isOptional = optional;
         this.optionLabels = optionLabels;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderSelectType(this.options, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.optionLabels ?? this.optionLabels, patch.tags ?? this.tags);
     }
     default(newDefault) {
-        return new BuilderSelectType(this.options, newDefault, this.isOptional, this.optionLabels);
+        return this.#next({ defaultValue: newDefault });
     }
     optional() {
-        const { options, defaultValue } = this;
-        return new BuilderSelectType(options, defaultValue, true, this.optionLabels);
+        return this.#next({ optional: true });
     }
     labels(optionLabels) {
-        return new BuilderSelectType(this.options, this.defaultValue, this.isOptional, optionLabels);
+        return this.#next({ optionLabels });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export function select(values) {
@@ -35,7 +45,8 @@ export const BuilderSelectTypeSerialisedSchema = serialisable(v.object({
     options: v.pipe(v.tupleWithRest([v.string()], v.string()), v.readonly()),
     defaultValue: v.nullable(v.string()),
     isOptional: v.boolean(),
-    optionLabels: v.record(v.string(), v.string())
+    optionLabels: v.record(v.string(), v.string()),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function selectValueSchema(options, optional) {
     const baseSchema = v.union(options.map((value) => v.literal(value)));

package/dist/entities/option/toggle.d.ts

@@ -1,17 +1,21 @@
 import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export declare const BuilderToggleValueTypeSchema: v.PicklistSchema<["string", "boolean", "number"], undefined>;
 export type BuilderToggleValueType = v.InferOutput<typeof BuilderToggleValueTypeSchema>;
 export declare class BuilderToggleType<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    #private;
     readonly value: v.InferOutput<ValueSchema>;
     readonly type: "toggle";
     readonly valueType: BuilderToggleValueType;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    readonly tags?: BuilderTags;
+    constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
     default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
     optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderToggleType<ValueSchema>;
 }
 export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
 export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
@@ -22,11 +26,13 @@ export declare const BuilderToggleTypeSerialisedSchema: v.SchemaWithPipe<readonl
     readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
     readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
     readonly isOptional: v.BooleanSchema<undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderToggleTypeSerialised = v.InferOutput<typeof BuilderToggleTypeSerialisedSchema>;
 export declare function toggleValueSchema(valueType: BuilderToggleValueType, optional: boolean): v.GenericSchema;

package/dist/entities/option/toggle.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 export const BuilderToggleValueTypeSchema = v.picklist(['string', 'boolean', 'number']);
 export class BuilderToggleType {
     type = 'toggle';
@@ -7,17 +8,27 @@ export class BuilderToggleType {
     valueSchema;
     defaultValue;
     isOptional;
-    constructor(valueType, defaultValue, optional) {
+    tags;
+    constructor(valueType, defaultValue, optional, tags) {
         this.valueType = valueType;
         this.valueSchema = toggleValueSchema(valueType, optional || false);
         this.defaultValue = defaultValue;
         this.isOptional = optional || false;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderToggleType(this.valueType, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
     }
     default(newDefault) {
-        return new BuilderToggleType(this.valueType, newDefault, this.isOptional);
+        return this.#next({ defaultValue: newDefault });
     }
     optional() {
-        return new BuilderToggleType(this.valueType, this.defaultValue, true);
+        return this.#next({ optional: true });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export function toggleString() {
@@ -34,7 +45,8 @@ export const BuilderToggleTypeSerialisedSchema = serialisable(v.object({
     type: v.literal('toggle'),
     valueType: BuilderToggleValueTypeSchema,
     defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
-    isOptional: v.boolean()
+    isOptional: v.boolean(),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function toggleValueSchema(valueType, optional) {
     const baseSchema = valueType === 'string' ? v.string() : valueType === 'boolean' ? v.boolean() : v.number();

package/dist/entities/option/values.d.ts

@@ -7,6 +7,7 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     readonly isOptional: v.BooleanSchema<undefined>;
     readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "select";
     readonly options: readonly [string, ...string[]];
@@ -15,16 +16,19 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     optionLabels: {
         [x: string]: string;
     };
+    tags?: readonly string[] | undefined;
 }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"toggle", undefined>;
     readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
     readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
     readonly isOptional: v.BooleanSchema<undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>]>], undefined>, v.ReadonlyAction<Readonly<{
     type: "select";
     readonly options: readonly [string, ...string[]];
@@ -33,11 +37,13 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     optionLabels: {
         [x: string]: string;
     };
+    tags?: readonly string[] | undefined;
 }> | Readonly<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>>]>;
 export type BuilderOptionValuesSerialised = v.InferOutput<typeof BuilderOptionValuesSerialisedSchema>;
 export declare function optionValueSchema(payload: BuilderOptionValuesSerialised): v.GenericSchema;

package/dist/entities/pricing/expression.d.ts

@@ -0,0 +1,70 @@
+import type { Paramable, ParamableSerialised } from '../../references';
+import * as v from 'valibot';
+export declare const BuilderPricingReduceSchema: v.PicklistSchema<["product", "sum", "first"], undefined>;
+export type BuilderPricingReduce = v.InferOutput<typeof BuilderPricingReduceSchema>;
+export type BuilderPricingLookupKey = {
+    readonly kind: 'variantTags';
+} | {
+    readonly kind: 'option';
+    readonly name: string;
+};
+export declare const BuilderPricingLookupKeySchema: v.GenericSchema<BuilderPricingLookupKey>;
+export type BuilderPricingExpression = number | {
+    readonly kind: 'variantPrice';
+} | {
+    readonly kind: 'lookup';
+    readonly rate: string;
+    readonly key: BuilderPricingLookupKey;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'variants';
+    readonly tag?: string;
+    readonly expression: Paramable<BuilderPricingExpression>;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'add';
+    readonly left: Paramable<BuilderPricingExpression>;
+    readonly right: Paramable<BuilderPricingExpression>;
+} | {
+    readonly kind: 'sub';
+    readonly left: Paramable<BuilderPricingExpression>;
+    readonly right: Paramable<BuilderPricingExpression>;
+} | {
+    readonly kind: 'mul';
+    readonly left: Paramable<BuilderPricingExpression>;
+    readonly right: Paramable<BuilderPricingExpression>;
+} | {
+    readonly kind: 'div';
+    readonly left: Paramable<BuilderPricingExpression>;
+    readonly right: Paramable<BuilderPricingExpression>;
+};
+export type BuilderPricingExpressionSerialised = number | {
+    readonly kind: 'variantPrice';
+} | {
+    readonly kind: 'lookup';
+    readonly rate: string;
+    readonly key: BuilderPricingLookupKey;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'variants';
+    readonly tag?: string;
+    readonly expression: ParamableSerialised<BuilderPricingExpressionSerialised>;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'add';
+    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
+    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
+} | {
+    readonly kind: 'sub';
+    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
+    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
+} | {
+    readonly kind: 'mul';
+    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
+    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
+} | {
+    readonly kind: 'div';
+    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
+    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
+};
+export declare const BuilderPricingExpressionSchema: v.GenericSchema<BuilderPricingExpression>;

package/dist/entities/pricing/expression.js

@@ -0,0 +1,43 @@
+import * as v from 'valibot';
+import { paramable } from '../../references.js';
+export const BuilderPricingReduceSchema = v.picklist(['product', 'sum', 'first']);
+export const BuilderPricingLookupKeySchema = v.variant('kind', [
+    v.object({ kind: v.literal('variantTags') }),
+    v.object({ kind: v.literal('option'), name: v.string() })
+]);
+export const BuilderPricingExpressionSchema = v.lazy(() => v.union([
+    v.number(),
+    v.object({ kind: v.literal('variantPrice') }),
+    v.object({
+        kind: v.literal('lookup'),
+        rate: v.string(),
+        key: BuilderPricingLookupKeySchema,
+        reduce: v.optional(BuilderPricingReduceSchema)
+    }),
+    v.object({
+        kind: v.literal('variants'),
+        tag: v.optional(v.string()),
+        expression: paramable(BuilderPricingExpressionSchema),
+        reduce: v.optional(BuilderPricingReduceSchema)
+    }),
+    v.object({
+        kind: v.literal('add'),
+        left: paramable(BuilderPricingExpressionSchema),
+        right: paramable(BuilderPricingExpressionSchema)
+    }),
+    v.object({
+        kind: v.literal('sub'),
+        left: paramable(BuilderPricingExpressionSchema),
+        right: paramable(BuilderPricingExpressionSchema)
+    }),
+    v.object({
+        kind: v.literal('mul'),
+        left: paramable(BuilderPricingExpressionSchema),
+        right: paramable(BuilderPricingExpressionSchema)
+    }),
+    v.object({
+        kind: v.literal('div'),
+        left: paramable(BuilderPricingExpressionSchema),
+        right: paramable(BuilderPricingExpressionSchema)
+    })
+]));

package/dist/entities/pricing/index.d.ts

@@ -0,0 +1,6 @@
+export type { BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce } from './expression';
+export type { BuilderRates } from './rates';
+export type { BuilderPricingSerialised } from './pricing';
+export { BuilderPricingExpressionSchema, BuilderPricingLookupKeySchema, BuilderPricingReduceSchema } from './expression.js';
+export { BuilderRatesSchema } from './rates.js';
+export { BuilderPricing, BuilderPricingSchema, BuilderPricingSerialisedSchema, pricing } from './pricing.js';

package/dist/entities/pricing/index.js

@@ -0,0 +1,3 @@
+export { BuilderPricingExpressionSchema, BuilderPricingLookupKeySchema, BuilderPricingReduceSchema } from './expression.js';
+export { BuilderRatesSchema } from './rates.js';
+export { BuilderPricing, BuilderPricingSchema, BuilderPricingSerialisedSchema, pricing } from './pricing.js';

package/dist/entities/pricing/pricing.d.ts

@@ -0,0 +1,17 @@
+import type { Paramable, ParamableSerialised } from '../../references';
+import type { BuilderPricingExpression } from './expression';
+import type { BuilderRates } from './rates';
+import * as v from 'valibot';
+export declare class BuilderPricing {
+    readonly type: 'pricing';
+    readonly rates: ReadonlyArray<Paramable<BuilderRates>>;
+    readonly formula: BuilderPricingExpression | null;
+    constructor(formula?: BuilderPricingExpression | null, rates?: ReadonlyArray<Paramable<BuilderRates>>);
+}
+export declare const BuilderPricingSchema: v.InstanceSchema<typeof BuilderPricing, undefined>;
+export interface BuilderPricingSerialised {
+    readonly rates: ReadonlyArray<ParamableSerialised<BuilderRates>>;
+    readonly formula: BuilderPricingExpression | null;
+}
+export declare const BuilderPricingSerialisedSchema: v.GenericSchema<BuilderPricingSerialised>;
+export declare function pricing(formula?: BuilderPricingExpression | null, rates?: ReadonlyArray<Paramable<BuilderRates>>): BuilderPricing;

package/dist/entities/pricing/pricing.js

@@ -0,0 +1,21 @@
+import * as v from 'valibot';
+import { paramable } from '../../references.js';
+import { serialisable } from '../../serialisable.js';
+import { BuilderPricingExpressionSchema } from './expression.js';
+import { BuilderRatesSchema } from './rates.js';
+export class BuilderPricing {
+    rates;
+    formula;
+    constructor(formula = null, rates) {
+        this.formula = formula;
+        this.rates = rates ?? [];
+    }
+}
+export const BuilderPricingSchema = v.instance(BuilderPricing);
+export const BuilderPricingSerialisedSchema = serialisable(v.object({
+    rates: v.pipe(v.array(paramable(BuilderRatesSchema)), v.readonly()),
+    formula: v.nullable(BuilderPricingExpressionSchema)
+}));
+export function pricing(formula = null, rates) {
+    return new BuilderPricing(formula, rates);
+}

package/dist/entities/pricing/rates.d.ts

@@ -0,0 +1,3 @@
+import * as v from 'valibot';
+export type BuilderRates = Record<string, Record<string, number>>;
+export declare const BuilderRatesSchema: v.GenericSchema<BuilderRates>;

package/dist/entities/pricing/rates.js

@@ -0,0 +1,3 @@
+import * as v from 'valibot';
+import { serialisable } from '../../serialisable.js';
+export const BuilderRatesSchema = serialisable(v.record(v.string(), v.record(v.string(), v.number())));