@builder-builder/builder 0.0.24 → 0.0.25

package/dist/client/client.d.ts

@@ -1,7 +1,9 @@
-import type { BuilderBuilderClientOptions, BuilderBuilderGetResponse } from './schema.js';
+import type { BuilderBuilderClientOptions, BuilderBuilderGetResponse, BuilderBuilderPriceResponse } from './schema.js';
+import type { BuilderInstance } from '../instance.js';
 export type BuilderBuilderClient = {
     builder: {
         get(id: string): Promise<BuilderBuilderGetResponse>;
+        price(id: string, instance: BuilderInstance): Promise<BuilderBuilderPriceResponse>;
     };
 };
 export declare function client(options: BuilderBuilderClientOptions): BuilderBuilderClient;

package/dist/client/client.js

@@ -1,29 +1,38 @@
 import * as v from 'valibot';
 import { BuilderException } from '../errors/index.js';
-import { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
+import { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema, BuilderBuilderPriceResponseSchema } from './schema.js';
 export function client(options) {
     const { url, apiKey, headers } = v.parse(BuilderBuilderClientOptionsSchema, options);
+    const baseHeaders = {
+        ...headers,
+        'X-Builder-Builder-Key': apiKey
+    };
     return {
         builder: {
-            get: async (id) => {
-                const requestUrl = `${url}/api/builder/${id}`;
-                const response = await fetch(requestUrl, {
-                    headers: {
-                        ...headers,
-                        'X-Builder-Builder-Key': apiKey
-                    }
-                });
-                if (!response.ok) {
-                    throw new BuilderException({
-                        category: 'request',
-                        url: requestUrl,
-                        status: response.status,
-                        statusText: response.statusText,
-                        body: await response.text()
-                    });
-                }
-                return v.parse(BuilderBuilderGetResponseSchema, await response.json());
-            }
+            get: (id) => request(BuilderBuilderGetResponseSchema, `${url}/api/builder/${id}`, {
+                headers: baseHeaders
+            }),
+            price: (id, instance) => request(BuilderBuilderPriceResponseSchema, `${url}/api/builder/${id}/price`, {
+                method: 'POST',
+                headers: {
+                    ...baseHeaders,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ instance })
+            })
         }
     };
 }
+async function request(schema, requestUrl, init) {
+    const response = await fetch(requestUrl, init);
+    if (!response.ok) {
+        throw new BuilderException({
+            category: 'request',
+            url: requestUrl,
+            status: response.status,
+            statusText: response.statusText,
+            body: await response.text()
+        });
+    }
+    return v.parse(schema, await response.json());
+}

package/dist/client/index.d.ts

@@ -1,4 +1 @@
-export type { BuilderBuilderClientOptions, BuilderBuilderGetResponse } from './schema.js';
-export type { BuilderBuilderClient } from './client.js';
-export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
-export { client } from './client.js';
+export * from './public.js';

package/dist/client/index.js

@@ -1,2 +1 @@
-export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema } from './schema.js';
-export { client } from './client.js';
+export * from './public.js';

package/dist/client/public.d.ts

@@ -0,0 +1,4 @@
+export type { BuilderBuilderClientOptions, BuilderBuilderGetResponse, BuilderBuilderPriceRequest, BuilderBuilderPriceResponse } from './schema.js';
+export type { BuilderBuilderClient } from './client.js';
+export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema, BuilderBuilderPriceRequestSchema, BuilderBuilderPriceResponseSchema } from './schema.js';
+export { client } from './client.js';

package/dist/client/public.js

@@ -0,0 +1,2 @@
+export { BuilderBuilderClientOptionsSchema, BuilderBuilderGetResponseSchema, BuilderBuilderPriceRequestSchema, BuilderBuilderPriceResponseSchema } from './schema.js';
+export { client } from './client.js';

package/dist/client/schema.d.ts

@@ -7,10 +7,10 @@ export declare const BuilderBuilderClientOptionsSchema: v.ObjectSchema<{
 export type BuilderBuilderClientOptions = v.InferOutput<typeof BuilderBuilderClientOptionsSchema>;
 export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
-    readonly serialised: v.GenericSchema<import("../index.js").BuilderSerialised>;
+    readonly serialised: v.GenericSchema<import("../public.js").BuilderSerialised>;
     readonly references: v.ArraySchema<v.ObjectSchema<{
         readonly id: v.StringSchema<undefined>;
-        readonly serialised: v.GenericSchema<string | number | boolean | readonly (string | number)[] | readonly (readonly (string | number)[])[] | import("../index.js").BuilderSerialised | import("../index.js").BuilderModelSerialised | Readonly<{
+        readonly serialised: v.GenericSchema<string | number | boolean | readonly (string | number)[] | readonly (readonly (string | number)[])[] | import("../public.js").BuilderSerialised | import("../public.js").BuilderModelSerialised | Readonly<{
             type: "select";
             readonly options: readonly [string, ...string[]];
             defaultValue: string | null;
@@ -25,7 +25,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
-        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+        }> | import("../public.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
@@ -44,7 +44,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
-        }>>> | import("../index.js").BuilderWhenSerialised<Readonly<Readonly<{
+        }>>> | import("../public.js").BuilderWhenSerialised<Readonly<Readonly<{
             type: "select";
             readonly options: readonly [string, ...string[]];
             defaultValue: string | null;
@@ -75,7 +75,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
-        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+        }> | import("../public.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
@@ -95,7 +95,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
-        }>> | import("../index.js").BuilderWhenSerialised<Readonly<{
+        }>> | import("../public.js").BuilderWhenSerialised<Readonly<{
             fields: Readonly<{
                 type: "parameter";
                 id: string;
@@ -119,7 +119,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
             }> | Readonly<{
                 type: "ref";
                 id: string;
-            }> | import("../index.js").BuilderModelSerialised;
+            }> | import("../public.js").BuilderModelSerialised;
             min: number | Readonly<{
                 type: "parameter";
                 id: string;
@@ -137,7 +137,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 id: string;
             }>;
             tags?: readonly string[] | undefined;
-        }> | import("../index.js").BuilderMatchSelectMap<Readonly<{
+        }> | import("../public.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
@@ -149,7 +149,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
             }> | Readonly<{
                 type: "ref";
                 id: string;
-            }> | import("../index.js").BuilderModelSerialised;
+            }> | import("../public.js").BuilderModelSerialised;
             min: number | Readonly<{
                 type: "parameter";
                 id: string;
@@ -167,7 +167,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 id: string;
             }>;
             tags?: readonly string[] | undefined;
-        }>> | import("../index.js").BuilderWhenSerialised<Readonly<{
+        }>> | import("../public.js").BuilderWhenSerialised<Readonly<{
             model: Readonly<{
                 type: "parameter";
                 id: string;
@@ -175,7 +175,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
             }> | Readonly<{
                 type: "ref";
                 id: string;
-            }> | import("../index.js").BuilderModelSerialised;
+            }> | import("../public.js").BuilderModelSerialised;
             min: number | Readonly<{
                 type: "parameter";
                 id: string;
@@ -193,7 +193,7 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 id: string;
             }>;
             tags?: readonly string[] | undefined;
-        }>> | import("../index.js").BuilderUISerialised | Readonly<{
+        }>> | import("../public.js").BuilderUISerialised | Readonly<{
             type: "input";
             path: readonly (string | number)[] | Readonly<{
                 type: "parameter";
@@ -356,14 +356,14 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
                 tags?: readonly string[] | undefined;
             }>)[];
             tags?: readonly string[] | undefined;
-        }> | import("../index.js").BuilderUIPagesSerialised | readonly (Readonly<{
+        }> | import("../public.js").BuilderUIPagesSerialised | readonly (Readonly<{
             type: "parameter";
             id: string;
             name: string;
         }> | Readonly<{
             type: "ref";
             id: string;
-        }> | import("../entities/index.js").BuilderUIItemSerialised)[] | import("../index.js").BuilderPricingSerialised | import("../entities/index.js").BuilderRates | readonly Readonly<{
+        }> | import("../entities/index.js").BuilderUIItemSerialised)[] | import("../public.js").BuilderPricingSerialised | import("../entities/index.js").BuilderRates | readonly Readonly<{
             name: string;
             kind: "option" | "component" | "collection";
         }>[]>;
@@ -395,3 +395,11 @@ export declare const BuilderBuilderGetResponseSchema: v.ObjectSchema<{
     }>]>;
 }, undefined>;
 export type BuilderBuilderGetResponse = v.InferOutput<typeof BuilderBuilderGetResponseSchema>;
+export declare const BuilderBuilderPriceRequestSchema: v.ObjectSchema<{
+    readonly instance: v.GenericSchema<import("../instance.js").BuilderInstance>;
+}, undefined>;
+export type BuilderBuilderPriceRequest = v.InferOutput<typeof BuilderBuilderPriceRequestSchema>;
+export declare const BuilderBuilderPriceResponseSchema: v.ObjectSchema<{
+    readonly price: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type BuilderBuilderPriceResponse = v.InferOutput<typeof BuilderBuilderPriceResponseSchema>;

package/dist/client/schema.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { BuilderReferencesSchema, BuilderSerialisedSchema } from '../entities/index.js';
-import { BuilderVariantsSchema } from '../instance.js';
+import { BuilderInstanceSchema, BuilderVariantsSchema } from '../instance.js';
 export const BuilderBuilderClientOptionsSchema = v.object({
     url: v.string(),
     apiKey: v.string(),
@@ -12,3 +12,9 @@ export const BuilderBuilderGetResponseSchema = v.object({
     references: BuilderReferencesSchema,
     variants: BuilderVariantsSchema
 });
+export const BuilderBuilderPriceRequestSchema = v.object({
+    instance: BuilderInstanceSchema
+});
+export const BuilderBuilderPriceResponseSchema = v.object({
+    price: v.nullable(v.number())
+});

package/dist/entities/collection/collection.d.ts

@@ -86,7 +86,7 @@ export type BuilderCollectionSerialised = {
 export declare const BuilderCollectionSerialisedSchema: v.GenericSchema<BuilderCollectionSerialised>;
 export declare const BuilderCollectionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<BuilderCollectionSerialised[]>]>;
 export type BuilderCollectionsSerialised = ReadonlyArray<BuilderCollectionSerialised>;
-export declare const validateCollectionWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateCollectionWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "enable";
     readonly payload: {
         readonly model: {
@@ -603,7 +603,7 @@ export declare const validateCollectionWhen: (input: unknown, references?: impor
         readonly tags?: readonly string[] | undefined;
     };
 }>;
-export declare const validateCollectionSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateCollectionSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly [x: string]: {
         readonly model: {
             readonly models: readonly (/*elided*/ any & import("../../validate").BuilderValidatedBrand)[];

package/dist/entities/collection/config.d.ts

@@ -189,7 +189,7 @@ export declare const BuilderCollectionConfigsSerialisedSchema: v.SchemaWithPipe<
 }>[]>]>;
 export type BuilderCollectionConfigsSerialised = v.InferOutput<typeof BuilderCollectionConfigsSerialisedSchema>;
 export declare function collectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>>(model: Model, min: Min, max: Max): BuilderCollectionConfig<Model, Min, Max>;
-export declare const validateCollectionConfig: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateCollectionConfig: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly model: {
         readonly models: readonly (/*elided*/ any & import("../../validate").BuilderValidatedBrand)[];
         readonly options: readonly {

package/dist/entities/collection/config.js

@@ -36,6 +36,6 @@ export const validateCollectionConfig = createEntityValidator('collectionConfig'
         return;
     }
     if (min < 0 || max <= 0 || max < min) {
-        errors.invalidCollectionBounds(min, max);
+        errors.entityInvalidCollectionBounds();
     }
 });

package/dist/entities/component/component.d.ts

@@ -413,7 +413,7 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
     tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderComponentsSerialised = v.InferOutput<typeof BuilderComponentsSerialisedSchema>;
-export declare const validateComponentWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateComponentWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "enable";
     readonly payload: {
         readonly fields: readonly {
@@ -455,7 +455,7 @@ export declare const validateComponentWhen: (input: unknown, references?: import
         readonly tags?: readonly string[] | undefined;
     };
 }>;
-export declare const validateComponentSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateComponentSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly [x: string]: {
         readonly fields: readonly {
             readonly type: "component-field";

package/dist/entities/component/config.d.ts

@@ -133,7 +133,7 @@ export declare const BuilderComponentConfigsSerialisedSchema: v.SchemaWithPipe<r
 }>[]>]>;
 export type BuilderComponentConfigsSerialised = v.InferOutput<typeof BuilderComponentConfigsSerialisedSchema>;
 export declare function componentConfig<const Fields extends BuilderComponentFields>(...fields: Fields): BuilderComponentConfig<Fields>;
-export declare const validateComponentConfig: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../validate").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateComponentConfig: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors/errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly fields: readonly {
         readonly type: "component-field";
         readonly name: string;

package/dist/entities/component/config.js

@@ -35,7 +35,7 @@ export const validateComponentConfig = createEntityValidator('componentConfig',
             return;
         }
         if (seen.has(field.name)) {
-            errors.duplicateName(field.name);
+            errors.entityDuplicateField();
         }
         seen.add(field.name);
     });

package/dist/entities/expectation.d.ts

@@ -30,7 +30,7 @@ export declare const BuilderExpectationsSerialisedSchema: v.SchemaWithPipe<reado
     kind: "option" | "component" | "collection";
 }>[]>]>;
 export type BuilderExpectationsSerialised = v.InferOutput<typeof BuilderExpectationsSerialisedSchema>;
-export declare const validateExpectations: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderValidateErrors) => import("./validated.js").ValidationResult<readonly ({
+export declare const validateExpectations: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly ({
     readonly name: string;
     readonly kind: "option" | "component" | "collection";
 } & import("../validate/brand.js").BuilderValidatedBrand)[]>;

package/dist/entities/kind.d.ts

@@ -2,11 +2,11 @@ import type { BuilderReferences } from './references';
 import type { EntitiesMap } from './serialise';
 import type { BuilderValidatedMap, ValidationResult } from './validated';
 import type * as v from 'valibot';
-import { BuilderValidateErrors } from '../errors/index.js';
+import { BuilderErrorsScope } from '../errors/index.js';
 export declare const builderEntityKinds: readonly ["builder", "model", "select", "toggle", "optionSelectMap", "optionWhen", "componentConfig", "componentSelectMap", "componentWhen", "collectionConfig", "collectionSelectMap", "collectionWhen", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"];
 export type BuilderEntityKind = (typeof builderEntityKinds)[number];
 export type BuilderEntitySerialised = {
     [Kind in BuilderEntityKind]: v.InferOutput<EntitiesMap[Kind]['serialised']>;
 }[BuilderEntityKind];
-export type EntityValidate<Kind extends BuilderEntityKind> = (input: BuilderValidatedMap[Kind], errors: BuilderValidateErrors, references: BuilderReferences) => void;
-export declare function createEntityValidator<Kind extends BuilderEntityKind>(kind: Kind, schema: v.GenericSchema, validate?: EntityValidate<Kind>): (input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors) => ValidationResult<BuilderValidatedMap[Kind]>;
+export type EntityValidate<Kind extends BuilderEntityKind> = (input: BuilderValidatedMap[Kind], errors: BuilderErrorsScope, references: BuilderReferences) => void;
+export declare function createEntityValidator<Kind extends BuilderEntityKind>(kind: Kind, schema: v.GenericSchema, validate?: EntityValidate<Kind>): (input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope) => ValidationResult<BuilderValidatedMap[Kind]>;

package/dist/entities/kind.js

@@ -1,4 +1,4 @@
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 export const builderEntityKinds = [
     'builder',
     'model',
@@ -28,9 +28,9 @@ export const builderEntityKinds = [
     'boolean'
 ];
 export function createEntityValidator(kind, schema, validate) {
-    return (input, references = [], errors = new BuilderValidateErrors()) => {
+    return (input, references = [], errors = new BuilderErrorsScope(input)) => {
         if (!check.is(schema, input)) {
-            errors.invalidEntity(kind);
+            errors.entityInvalid(kind);
             return [input, errors.errors];
         }
         validate?.(input, errors, references);

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

@@ -387,7 +387,7 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
     tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderOptionsSerialised = v.InferOutput<typeof BuilderOptionsSerialisedSchema>;
-export declare const validateOptionWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateOptionWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "enable";
     readonly payload: {
         readonly type: "select";
@@ -447,7 +447,7 @@ export declare const validateOptionWhen: (input: unknown, references?: import(".
         readonly tags?: readonly string[] | undefined;
     };
 }>;
-export declare const validateOptionSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateOptionSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly [x: string]: {
         readonly type: "select";
         readonly options: readonly [string, ...string[]];

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

@@ -42,7 +42,7 @@ export declare const BuilderSelectConfigSerialisedSchema: v.SchemaWithPipe<reado
 }>]>;
 export type BuilderSelectConfigSerialised = v.InferOutput<typeof BuilderSelectConfigSerialisedSchema>;
 export declare function selectValueSchema(options: ReadonlyArray<string>, optional: boolean): v.GenericSchema<string | null>;
-export declare const validateSelect: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateSelect: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "select";
     readonly options: readonly [string, ...string[]];
     readonly defaultValue: string | null;

package/dist/entities/option/select.js

@@ -55,11 +55,13 @@ export function selectValueSchema(options, optional) {
 }
 export const validateSelect = createEntityValidator('select', BuilderSelectConfigSerialisedSchema, (input, errors) => {
     if (input.defaultValue != null && !input.options.includes(input.defaultValue)) {
-        errors.invalidSelectDefault(input.defaultValue);
+        errors.scope('defaultValue', () => errors.entityInvalidSelectDefault());
     }
-    Object.keys(input.optionLabels).forEach((key) => {
-        if (!input.options.includes(key)) {
-            errors.invalidSelectLabel(key);
-        }
+    errors.scope('optionLabels', () => {
+        Object.keys(input.optionLabels).forEach((key) => {
+            if (!input.options.includes(key)) {
+                errors.scope(key, () => errors.entityInvalidSelectLabel());
+            }
+        });
     });
 });

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

@@ -36,7 +36,7 @@ export declare const BuilderToggleConfigSerialisedSchema: v.SchemaWithPipe<reado
 }>]>;
 export type BuilderToggleConfigSerialised = v.InferOutput<typeof BuilderToggleConfigSerialisedSchema>;
 export declare function toggleValueSchema(valueType: BuilderToggleValueType, optional: boolean): v.GenericSchema;
-export declare const validateToggle: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../validate").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateToggle: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors/errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "toggle";
     readonly valueType: "string" | "number" | "boolean";
     readonly defaultValue: string | number | boolean | null;

package/dist/entities/option/toggle.js

@@ -60,6 +60,6 @@ export const validateToggle = createEntityValidator('toggle', BuilderToggleConfi
     }
     const valueSchema = toggleValueSchema(input.valueType, input.isOptional);
     if (!check.is(valueSchema, input.defaultValue)) {
-        errors.invalidToggleDefault(input.defaultValue, input.valueType);
+        errors.scope('defaultValue', () => errors.entityInvalidToggleDefault());
     }
 });

package/dist/entities/paths.d.ts

@@ -3,5 +3,5 @@ export declare const BuilderPathSchema: v.SchemaWithPipe<readonly [v.ArraySchema
 export type BuilderPath = v.InferOutput<typeof BuilderPathSchema>;
 export declare const BuilderPathsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
 export type BuilderPaths = v.InferOutput<typeof BuilderPathsSchema>;
-export declare const validatePath: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderValidateErrors) => import("./validated.js").ValidationResult<readonly (string | number)[]>;
-export declare const validatePaths: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderValidateErrors) => import("./validated.js").ValidationResult<readonly (readonly (string | number)[])[]>;
+export declare const validatePath: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly (string | number)[]>;
+export declare const validatePaths: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly (readonly (string | number)[])[]>;

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

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 export type BuilderRates = Record<string, Record<string, number>>;
 export declare const BuilderRatesSchema: v.GenericSchema<BuilderRates>;
-export declare const validatePricingRates: (input: unknown, references?: import("../references.js").BuilderReferences, errors?: import("../../errors/errors.js").BuilderValidateErrors) => import("../validated.js").ValidationResult<{
+export declare const validatePricingRates: (input: unknown, references?: import("../references.js").BuilderReferences, errors?: import("../../errors/errors.js").BuilderErrorsScope) => import("../validated.js").ValidationResult<{
     readonly [x: string]: {
         readonly [x: string]: number;
     } & import("../../validate/brand.js").BuilderValidatedBrand;

package/dist/entities/serialise.d.ts

@@ -1217,9 +1217,9 @@ export declare const entitiesMap: {
         readonly serialised: v.BooleanSchema<undefined>;
     };
 };
-export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../validate").BuilderValidateErrors) => import("./validated").ValidationResult<number>;
-export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../validate").BuilderValidateErrors) => import("./validated").ValidationResult<string>;
-export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../validate").BuilderValidateErrors) => import("./validated").ValidationResult<boolean>;
+export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<number>;
+export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<string>;
+export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<boolean>;
 export type EntitiesMap = typeof entitiesMap;
 export type EntitiesSerialisedSchemas = EntitiesMap[BuilderEntityKind]['serialised'];
 export declare const BuilderEntityKindSchema: v.PicklistSchema<readonly ["builder", "model", "select", "toggle", "optionSelectMap", "optionWhen", "componentConfig", "componentSelectMap", "componentWhen", "collectionConfig", "collectionSelectMap", "collectionWhen", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"], undefined>;

package/dist/entities/ui/describe.d.ts

@@ -287,7 +287,7 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIDescribeSerialised = v.InferOutput<typeof BuilderUIDescribeSerialisedSchema>;
-export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "describe";
     readonly label: string;
     readonly inputs: readonly {

package/dist/entities/ui/describe.js

@@ -29,9 +29,9 @@ export const BuilderUIDescribeSerialisedSchema = serialisable(v.object({
 }));
 export const validateUIDescribe = createEntityValidator('uiDescribe', BuilderUIDescribeSerialisedSchema, (input, errors) => {
     if (!isParamable(input.label) && input.label.length === 0) {
-        errors.emptyLabel();
+        errors.entityEmptyLabel();
     }
     if (!isParamable(input.inputs) && input.inputs.length === 0) {
-        errors.emptyInputs();
+        errors.entityEmptyInputs();
     }
 });

package/dist/entities/ui/input.d.ts

@@ -333,7 +333,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     tags?: readonly string[] | undefined;
 }>)[]>]>;
 export type BuilderUIInputsSerialised = v.InferOutput<typeof BuilderUIInputsSerialisedSchema>;
-export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "input";
     readonly path: readonly (string | number)[];
     readonly displayName?: string | undefined;

package/dist/entities/ui/page.d.ts

@@ -283,7 +283,7 @@ export declare const BuilderUIPageSerialisedSchema: v.SchemaWithPipe<readonly [v
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIPageSerialised = v.InferOutput<typeof BuilderUIPageSerialisedSchema>;
-export declare const validateUIPage: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateUIPage: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "page";
     readonly label: string;
     readonly inputs: readonly {

package/dist/entities/ui/page.js

@@ -27,9 +27,9 @@ export const BuilderUIPageSerialisedSchema = serialisable(v.object({
 }));
 export const validateUIPage = createEntityValidator('uiPage', BuilderUIPageSerialisedSchema, (input, errors) => {
     if (!isParamable(input.label) && input.label.length === 0) {
-        errors.emptyLabel();
+        errors.entityEmptyLabel();
     }
     if (!isParamable(input.inputs) && input.inputs.length === 0) {
-        errors.emptyInputs();
+        errors.entityEmptyInputs();
     }
 });

package/dist/entities/ui/pages.d.ts

@@ -48,7 +48,7 @@ export declare const BuilderUIItemsSerialisedSchema: v.SchemaWithPipe<readonly [
     type: "ref";
     id: string;
 }> | BuilderUIItemSerialised)[]>]>;
-export declare const validateUIPages: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+export declare const validateUIPages: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
     readonly type: "pages";
     readonly name: string;
     readonly label: string;
@@ -117,7 +117,7 @@ export declare const validateUIPages: (input: unknown, references?: import("..")
     })[];
     readonly tags?: readonly string[] | undefined;
 }>;
-export declare const validateUIItems: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<readonly ({
+export declare const validateUIItems: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<readonly ({
     readonly type: "page";
     readonly label: string;
     readonly inputs: readonly {

package/dist/entities/ui/pages.js

@@ -37,10 +37,10 @@ export const BuilderUIItemSerialisedSchema = v.union([
 export const BuilderUIItemsSerialisedSchema = v.pipe(v.array(paramable(BuilderUIItemSerialisedSchema)), v.readonly());
 export const validateUIPages = createEntityValidator('uiPages', BuilderUIPagesSerialisedSchema, (input, errors) => {
     if (input.name.length === 0) {
-        errors.emptyName();
+        errors.entityEmptyName();
     }
     if (!isParamable(input.label) && input.label.length === 0) {
-        errors.emptyLabel();
+        errors.entityEmptyLabel();
     }
 });
 export const validateUIItems = createEntityValidator('uiItems', BuilderUIItemsSerialisedSchema);

package/dist/errors/check.d.ts

@@ -1,9 +1,8 @@
 import * as v from 'valibot';
 declare class Check {
-    truthy<Input>(input: Input, message: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
-    falsy(input: unknown, message: `${string}! ❌`): void;
+    invariant<Input>(input: Input): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
     is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferOutput<Schema>;
-    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown, message?: `${string}! ❌`): asserts input is v.InferOutput<Schema>;
+    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): asserts input is v.InferOutput<Schema>;
 }
 export declare const check: Check;
 export {};

package/dist/errors/check.js

@@ -1,27 +1,22 @@
 import * as v from 'valibot';
-import { BuilderException, formatSchemaIssues } from './exception.js';
+import { BuilderException } from './exception.js';
 class Check {
-    truthy(input, message) {
+    invariant(input) {
         if (!input) {
-            throw new BuilderException({ category: 'assertion', summary: message });
-        }
-    }
-    falsy(input, message) {
-        if (input) {
-            throw new BuilderException({ category: 'assertion', summary: message });
+            throw new BuilderException({ category: 'invariant', value: input });
         }
     }
     is(schema, input) {
         return v.is(schema, input);
     }
-    assert(schema, input, message) {
+    assert(schema, input) {
         const result = v.safeParse(schema, input);
         if (result.success) {
             return;
         }
         throw new BuilderException({
             category: 'assertion',
-            summary: message ?? formatSchemaIssues(result.issues),
+            value: input,
             issues: result.issues
         });
     }