@builder-builder/builder 0.0.24 → 0.0.25

package/dist/validate/paths.js

@@ -5,47 +5,71 @@ import { resolveCollections } from '../mappers/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 (path.length === 0) {
+        errors.pathEmpty();
+        return;
+    }
+    const lastIndex = path.length - 1;
+    const models = walkPath([model], path.slice(0, -1), 0, errors);
     if (models == null) {
         return;
     }
     const optionName = path.at(-1);
     if (!check.is(StringSchema, optionName)) {
-        errors.invalidPath('shape');
+        errors.scope(lastIndex, () => errors.pathInvalidSegment());
         return;
     }
-    if (!models.some((model) => model.options.some((option) => option.name === optionName))) {
-        errors.invalidPath('option-not-found');
+    if (models.some((model) => model.options.some((option) => option.name === optionName))) {
+        return;
+    }
+    const isCollection = models.some((model) => model.collections.some((entry) => entry.name === optionName));
+    if (isCollection) {
+        errors.scope(lastIndex, () => errors.pathTargetIsCollection());
+        return;
     }
+    const isComponent = models.some((model) => model.components.some((entry) => entry.name === optionName));
+    if (isComponent) {
+        errors.scope(lastIndex, () => errors.pathTargetIsComponent());
+        return;
+    }
+    errors.scope(lastIndex, () => errors.pathMissingOption());
 }
-function walkPath(candidates, remaining, errors) {
+function walkPath(models, remaining, offset, errors) {
     if (remaining.length === 0) {
-        return candidates;
+        return models;
     }
     const [collectionName, index, ...rest] = remaining;
-    if (!check.is(StringSchema, collectionName) || !check.is(NumberSchema, index)) {
-        errors.invalidPath('shape');
+    if (!check.is(StringSchema, collectionName)) {
+        errors.scope(offset, () => errors.pathInvalidSegment());
+        return null;
+    }
+    if (!check.is(NumberSchema, index)) {
+        errors.scope(offset + 1, () => errors.pathInvalidSegment());
         return null;
     }
-    const matchedConfigs = candidates.flatMap((current) => {
-        const collection = current.collections.find((entry) => entry.name === collectionName);
-        return collection == null ? [] : [resolveCollections(collection)];
+    const collectionConfigs = models.flatMap((model) => {
+        const collection = model.collections.find((entry) => entry.name === collectionName);
+        return collection == null ? [] : resolveCollections(collection);
     });
-    if (matchedConfigs.length === 0) {
-        errors.invalidPath('missing-collection');
+    if (collectionConfigs.length === 0) {
+        errors.scope(offset, () => errors.pathMissingCollection());
         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');
+    const indexableConfigs = collectionConfigs.filter(({ max }) => !check.is(NumberSchema, max) || index < max);
+    if (indexableConfigs.length === 0) {
+        const max = collectionConfigs.reduce((highest, { max }) => {
+            if (!check.is(NumberSchema, max)) {
+                return highest;
+            }
+            return max > highest ? max : highest;
+        }, 0);
+        errors.scope(offset + 1, () => errors.pathInvalidIndex(max));
         return null;
     }
-    const next = matchedConfigs.flatMap((configs) => configs
-        .filter(({ max }) => !check.is(NumberSchema, max) || index < max)
-        .flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []));
+    const next = indexableConfigs.flatMap((collectionConfig) => check.is(BuilderModelSerialisedSchema, collectionConfig.model) ? [collectionConfig.model] : []);
     if (next.length === 0) {
-        errors.invalidPath('missing-collection');
+        errors.scope(offset, () => errors.pathMissingCollection());
         return null;
     }
-    return walkPath(next, rest, errors);
+    return walkPath(next, rest, offset + 2, errors);
 }

package/dist/validate/pricing.d.ts

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

package/dist/validate/pricing.js

@@ -1,13 +1,13 @@
 import * as v from 'valibot';
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { validate } from './brand.js';
 import { resolver } from './resolve.js';
 const EMPTY_PRICING = validate(serialise.pricing(pricing()));
 const NumberSchema = v.number();
-export function validatePricing(input, references = [], errors = new BuilderValidateErrors()) {
+export function validatePricing(input, references = [], errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
-        errors.invalidEntity('pricing');
+        errors.entityInvalid('pricing');
         return [EMPTY_PRICING, errors.errors];
     }
     const resolve = resolver(errors, references);
@@ -15,10 +15,14 @@ export function validatePricing(input, references = [], errors = new BuilderVali
     return [validate(structure), errors.errors];
 }
 export function validatePricingStructure(input, resolve, errors) {
-    const rates = input.rates.flatMap((entry) => {
+    const rates = errors.scope('rates', () => input.rates.flatMap((entry, index) => {
         const resolved = resolve(entry);
-        return v.is(BuilderRatesSchema, resolved) ? [resolved] : [];
-    });
+        if (v.is(BuilderRatesSchema, resolved)) {
+            return [resolved];
+        }
+        errors.scope(index, () => errors.pricingInvalidRateValue());
+        return [];
+    }));
     const formula = input.formula == null ? null : resolveExpression(input.formula);
     if (formula != null) {
         walkExpression(formula, false);
@@ -27,6 +31,7 @@ export function validatePricingStructure(input, resolve, errors) {
     function resolveExpression(input) {
         const resolved = resolve(input);
         if (!check.is(BuilderPricingExpressionSchema, resolved)) {
+            errors.pricingMalformedExpression();
             return null;
         }
         if (check.is(NumberSchema, resolved)) {
@@ -50,24 +55,29 @@ export function validatePricingStructure(input, resolve, errors) {
         switch (expression.kind) {
             case 'variantPrice':
                 if (!insideVariants) {
-                    errors.invalidPricing('scope');
+                    errors.pricingInvalidScope();
                 }
                 return;
             case 'lookup':
                 errors.scope('lookup', () => {
-                    const exists = rates.some((entry) => entry[expression.rate] != null);
-                    if (!exists) {
-                        errors.missingRate(expression.rate);
+                    if (rates.length === 0) {
+                        errors.pricingEmptyRates();
+                    }
+                    else {
+                        const exists = rates.some((entry) => entry[expression.rate] != null);
+                        if (!exists) {
+                            errors.pricingMissingRate();
+                        }
                     }
                     if (!insideVariants) {
-                        errors.invalidPricing('scope');
+                        errors.pricingInvalidScope();
                     }
                 });
                 return;
             case 'variants':
                 errors.scope('variants', () => {
                     if (insideVariants) {
-                        errors.invalidPricing('nested-variants');
+                        errors.pricingNestedVariants();
                     }
                     const inner = expression.expression;
                     check.assert(BuilderPricingExpressionSchema, inner);
@@ -81,6 +91,9 @@ export function validatePricingStructure(input, resolve, errors) {
                 const { left, right } = expression;
                 check.assert(BuilderPricingExpressionSchema, left);
                 check.assert(BuilderPricingExpressionSchema, right);
+                if (expression.kind === 'div' && check.is(NumberSchema, right) && right === 0) {
+                    errors.pricingDivideByZero();
+                }
                 errors.scope('left', () => walkExpression(left, insideVariants));
                 errors.scope('right', () => walkExpression(right, insideVariants));
                 return;
@@ -105,7 +118,7 @@ export function checkPricingExpectations(model, pricing, errors) {
             case 'lookup':
                 errors.scope('lookup', () => {
                     if (expression.key.kind === 'option' && !optionNames.has(expression.key.name)) {
-                        errors.unmetExpectation('option', expression.key.name);
+                        errors.pricingMissingOption();
                     }
                 });
                 return;

package/dist/validate/resolve.d.ts

@@ -1,4 +1,4 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
-import type { BuilderValidateErrors } from '../errors/index';
+import type { BuilderErrorsScope } from '../errors/index';
 export type BuilderResolve = (value: unknown) => unknown;
-export declare function resolver(errors: BuilderValidateErrors, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;
+export declare function resolver(errors: BuilderErrorsScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -3,6 +3,7 @@ import { check } from '../errors/index.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
 export function resolver(errors, references = [], bindings = {}) {
+    const resolving = new Set();
     function resolve(value) {
         if (check.is(BuilderParameterSerialisedSchema, value)) {
             return resolveParameter(value);
@@ -18,16 +19,26 @@ export function resolver(errors, references = [], bindings = {}) {
         }
         return value;
         function resolveReference(reference) {
+            if (resolving.has(reference.id)) {
+                errors.referenceCircular();
+                return reference;
+            }
             const found = references.find((entry) => entry.id === reference.id);
             if (found == null) {
-                errors.missingReference(reference.id);
+                errors.referenceMissing();
                 return reference;
             }
-            return found.serialised;
+            resolving.add(reference.id);
+            try {
+                return resolve(found.serialised);
+            }
+            finally {
+                resolving.delete(reference.id);
+            }
         }
         function resolveParameter(parameter) {
             if (!(parameter.name in bindings)) {
-                errors.unboundParameter(parameter.name);
+                errors.referenceUnboundParameter();
                 return null;
             }
             const binding = bindings[parameter.name];

package/dist/validate/ui.d.ts

@@ -1,7 +1,7 @@
 import type { BuilderModelSerialised, BuilderReferences, BuilderUISerialised, BuilderUIValidated, ValidationResult } from '../entities/index';
 import type { BuilderResolve } from './resolve';
-import { BuilderValidateErrors } from '../errors/index.js';
+import { BuilderErrorsScope } from '../errors/index.js';
 export type BuilderUIValidationResult = ValidationResult<BuilderUIValidated>;
-export declare function validateUI(input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors): BuilderUIValidationResult;
-export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderUIValidated;
-export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, errors: BuilderValidateErrors): void;
+export declare function validateUI(input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope): BuilderUIValidationResult;
+export declare function validateUIStructure(ui: BuilderUISerialised, resolve: BuilderResolve, errors: BuilderErrorsScope): BuilderUIValidated;
+export declare function checkUIExpectations(mergedModel: BuilderModelSerialised, ui: BuilderUIValidated, errors: BuilderErrorsScope): void;

package/dist/validate/ui.js

@@ -1,13 +1,13 @@
 import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 import { validate } from './brand.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
-export function validateUI(input, references = [], errors = new BuilderValidateErrors()) {
+export function validateUI(input, references = [], errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
-        errors.invalidEntity('ui');
+        errors.entityInvalid('ui');
         return [validate(serialise.ui(uis())), errors.errors];
     }
     const resolve = resolver(errors, references);

package/dist/validate/variants.d.ts

@@ -1,7 +1,7 @@
 import type { BuilderModelValidated, BuilderVariantsValidated, ValidationResult } from '../entities/index';
-import { BuilderValidateErrors } from '../errors/index.js';
+import { BuilderErrorsScope } from '../errors/index.js';
 export type BuilderVariantsValidationOptions = {
     readonly partial?: boolean;
 };
 export type BuilderVariantsValidationResult = ValidationResult<BuilderVariantsValidated>;
-export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderValidateErrors): BuilderVariantsValidationResult;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, errors?: BuilderErrorsScope): BuilderVariantsValidationResult;

package/dist/validate/variants.js

@@ -1,17 +1,17 @@
 import { BuilderComponentConfigSerialisedSchema, detailValueSchema } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { BuilderVariantsSchema } from '../instance.js';
 import { createVariants } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function validateVariants(model, input, options = {}, errors = new BuilderValidateErrors()) {
+export function validateVariants(model, input, options = {}, errors = new BuilderErrorsScope(input)) {
     if (!check.is(BuilderVariantsSchema, input)) {
-        errors.invalidVariants();
+        errors.variantsInvalid();
         return [validate({}), errors.errors];
     }
     const variants = input;
     const expected = createVariants(model);
     if (Object.keys(expected).length === 0) {
-        errors.noComponents();
+        errors.modelEmptyComponents();
         return [validate({}), errors.errors];
     }
     errors.scope('variants', () => {
@@ -21,26 +21,26 @@ export function validateVariants(model, input, options = {}, errors = new Builde
         function checkVariants() {
             Object.entries(expected).forEach(([component, expectedVariants]) => {
                 const componentVariants = variants[component];
-                if (componentVariants == null) {
-                    if (options.partial !== false) {
-                        errors.missingComponent(component);
-                    }
-                    return;
-                }
                 errors.scope(component, () => {
+                    if (componentVariants == null) {
+                        if (options.partial !== false) {
+                            errors.variantsMissingComponent();
+                        }
+                        return;
+                    }
                     const expectedKeys = new Map(expectedVariants.map(({ instance }) => [sortedKey(instance), instance]));
                     const actualKeys = new Set(componentVariants.map(({ instance }) => sortedKey(instance)));
                     componentVariants.forEach((variant, index) => {
                         errors.scope(index, () => {
                             const { instance } = variant;
                             if (!expectedKeys.has(sortedKey(instance))) {
-                                errors.invalidVariant(component, instance);
+                                errors.variantsInvalidVariant();
                             }
                         });
                     });
                     Array.from(expectedKeys).forEach(([key, instance]) => {
                         if (!actualKeys.has(key)) {
-                            errors.missingVariant(component, instance);
+                            errors.variantsMissingVariant(instance);
                         }
                     });
                 });
@@ -50,7 +50,7 @@ export function validateVariants(model, input, options = {}, errors = new Builde
             Object.keys(variants).forEach((component) => {
                 errors.scope(component, () => {
                     if (expected[component] == null) {
-                        errors.unexpectedComponent(component);
+                        errors.variantsUnexpectedComponent();
                     }
                 });
             });
@@ -72,18 +72,18 @@ export function validateVariants(model, input, options = {}, errors = new Builde
                                 fields.forEach(({ name, valueType, isOptional }) => {
                                     errors.scope(name, () => {
                                         if (!(name in details)) {
-                                            errors.missingDetail(component, name, instance);
+                                            errors.variantsMissingDetail();
                                             return;
                                         }
                                         if (!check.is(detailValueSchema(valueType, isOptional), details[name])) {
-                                            errors.invalidDetail(component, name, instance);
+                                            errors.variantsInvalidDetail();
                                         }
                                     });
                                 });
                                 Object.keys(details).forEach((detail) => {
                                     if (!expectedNames.has(detail)) {
                                         errors.scope(detail, () => {
-                                            errors.unexpectedDetail(component, detail, instance);
+                                            errors.variantsUnexpectedDetail();
                                         });
                                     }
                                 });

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "@builder-builder/builder",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "type": "module",
   "engines": {
     "node": ">=24"
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/public.d.ts",
+      "default": "./dist/public.js"
     },
     "./client": {
-      "types": "./dist/client/index.d.ts",
-      "default": "./dist/client/index.js"
+      "types": "./dist/client/public.d.ts",
+      "default": "./dist/client/public.js"
+    },
+    "./errors": {
+      "types": "./dist/errors/public.d.ts",
+      "default": "./dist/errors/public.js"
     }
   },
   "files": [
     "dist"
   ],
-  "svelte": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "svelte": "./dist/public.js",
+  "types": "./dist/public.d.ts",
   "publishConfig": {
     "access": "public"
   },

package/dist/private.d.ts

@@ -1,3 +0,0 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
-export { BuilderEnvironmentSchema } from './environment.js';
-export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';

package/dist/private.js

@@ -1,3 +0,0 @@
-export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderPathSchema, BuilderPathsSchema, BuilderReferenceSchema, BuilderReferencesSchema, BuilderSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
-export { BuilderEnvironmentSchema } from './environment.js';
-export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';