@builder-builder/builder 0.0.24 → 0.0.26

package/dist/validate/paths.js

@@ -1,51 +1,73 @@
-import * as v from 'valibot';
 import { BuilderModelSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
-const NumberSchema = v.number();
-const StringSchema = v.string();
+import { NameSchema, NumberSchema } from '../primitive.js';
 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');
+    if (!check.is(NameSchema, optionName)) {
+        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(NameSchema, 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,12 @@
-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 { NumberSchema } from '../primitive.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,18 +14,23 @@ 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 resolved = resolve(entry);
-        return v.is(BuilderRatesSchema, resolved) ? [resolved] : [];
-    });
+    const rates = errors.scope('rates', () => input.rates.flatMap((entry, index) => {
+        const resolved = resolve(entry, BuilderRatesSchema);
+        if (resolved != null) {
+            return [resolved];
+        }
+        errors.scope(index, () => errors.pricingInvalidRateValue());
+        return [];
+    }));
     const formula = input.formula == null ? null : resolveExpression(input.formula);
     if (formula != null) {
         walkExpression(formula, false);
     }
     return { rates, formula };
     function resolveExpression(input) {
-        const resolved = resolve(input);
-        if (!check.is(BuilderPricingExpressionSchema, resolved)) {
+        const resolved = resolve(input, BuilderPricingExpressionSchema);
+        if (resolved == null) {
+            errors.pricingMalformedExpression();
             return null;
         }
         if (check.is(NumberSchema, resolved)) {
@@ -50,24 +54,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 +90,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 +117,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,5 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
-import type { BuilderValidateErrors } from '../errors/index';
-export type BuilderResolve = (value: unknown) => unknown;
-export declare function resolver(errors: BuilderValidateErrors, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;
+import type { BuilderErrorsScope } from '../errors/index';
+import * as v from 'valibot';
+export type BuilderResolve = <S extends v.GenericSchema = v.GenericSchema<unknown>>(value: unknown, schema?: S) => v.InferOutput<S> | null;
+export declare function resolver(errors: BuilderErrorsScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -1,86 +1,111 @@
-import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import * as v from 'valibot';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
+import { NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema } from '../references.js';
 import { validateModelStructure } from './model.js';
 export function resolver(errors, references = [], bindings = {}) {
-    function resolve(value) {
+    const resolving = new Set();
+    function resolve(value, schema = v.unknown()) {
+        const errorsBefore = errors.errors.length;
+        const resolved = dispatch(value, schema);
+        if (check.is(schema, resolved)) {
+            return resolved;
+        }
+        if (errors.errors.length === errorsBefore) {
+            errors.referenceInvalid();
+        }
+        return null;
+    }
+    function dispatch(value, schema) {
         if (check.is(BuilderParameterSerialisedSchema, value)) {
-            return resolveParameter(value);
+            return resolveParameter(value, schema);
         }
         if (check.is(BuilderRefSerialisedSchema, value)) {
-            return resolveReference(value);
+            return resolveReference(value, schema);
         }
         if (check.is(BuilderWhenSerialisedSchema, value)) {
-            return resolveWhen(value);
+            return resolveWhen(value, schema);
         }
         if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
             return resolveCollectionConfig(value);
         }
         return value;
-        function resolveReference(reference) {
-            const found = references.find((entry) => entry.id === reference.id);
-            if (found == null) {
-                errors.missingReference(reference.id);
-                return reference;
-            }
-            return found.serialised;
+    }
+    function resolveReference(reference, schema) {
+        if (resolving.has(reference.id)) {
+            errors.referenceCircular();
+            return reference;
         }
-        function resolveParameter(parameter) {
-            if (!(parameter.name in bindings)) {
-                errors.unboundParameter(parameter.name);
-                return null;
-            }
-            const binding = bindings[parameter.name];
-            if (!check.is(BuilderRefSerialisedSchema, binding)) {
-                return binding;
-            }
-            return resolveReference(binding);
+        const found = references.find((entry) => entry.id === reference.id);
+        if (found == null) {
+            errors.referenceMissing();
+            return reference;
         }
-        function resolveWhen(when) {
-            if (when.type === 'enable') {
-                const payload = errors.scope('payload', () => resolve(when.payload));
-                return { ...when, payload: payload ?? when.payload };
-            }
-            if (when.type === 'unless') {
-                const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath));
-                const payload = errors.scope('payload', () => resolve(when.payload));
-                return {
-                    ...when,
-                    unlessPath: unlessPath ?? when.unlessPath,
-                    payload: payload ?? when.payload
-                };
-            }
-            const matchPath = errors.scope('matchPath', () => resolve(when.matchPath));
-            const map = errors.scope('selectMap', () => resolve(when.selectMap));
-            if (map == null || typeof map !== 'object') {
-                return { ...when, matchPath: matchPath ?? when.matchPath };
-            }
-            const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
-                if (entryValue == null) {
-                    return { ...values, [key]: null };
-                }
-                const resolved = errors.scope(key, () => resolve(entryValue));
-                return { ...values, [key]: resolved ?? entryValue };
-            }, {}));
-            return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+        resolving.add(reference.id);
+        try {
+            return dispatch(found.serialised, schema);
         }
-        function resolveCollectionConfig(config) {
-            const model = errors.scope('model', () => {
-                const resolved = resolve(config.model);
-                if (check.is(BuilderModelSerialisedSchema, resolved)) {
-                    return validateModelStructure(resolved, resolve, errors);
-                }
-                return resolved;
-            });
-            const min = errors.scope('min', () => resolve(config.min));
-            const max = errors.scope('max', () => resolve(config.max));
+        finally {
+            resolving.delete(reference.id);
+        }
+    }
+    function resolveParameter(parameter, schema) {
+        if (!(parameter.name in bindings)) {
+            errors.referenceUnboundParameter();
+            return null;
+        }
+        const binding = bindings[parameter.name];
+        if (!check.is(BuilderRefSerialisedSchema, binding)) {
+            return binding;
+        }
+        return resolveReference(binding, schema);
+    }
+    function resolveWhen(when, payloadSchema) {
+        if (when.type === 'enable') {
+            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
+            return { ...when, payload: payload ?? when.payload };
+        }
+        if (when.type === 'unless') {
+            const unlessPath = errors.scope('unlessPath', () => resolve(when.unlessPath, BuilderPathSchema));
+            const payload = errors.scope('payload', () => resolve(when.payload, payloadSchema));
             return {
-                ...config,
-                model: model ?? config.model,
-                min: min ?? config.min,
-                max: max ?? config.max
+                ...when,
+                unlessPath: unlessPath ?? when.unlessPath,
+                payload: payload ?? when.payload
             };
         }
+        const matchPath = errors.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
+        const selectMapSchema = v.record(StringSchema, v.nullable(v.unknown()));
+        const map = errors.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
+        if (map == null) {
+            return { ...when, matchPath: matchPath ?? when.matchPath };
+        }
+        const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
+            if (entryValue == null) {
+                return { ...values, [key]: null };
+            }
+            const resolved = errors.scope(key, () => resolve(entryValue, payloadSchema));
+            return { ...values, [key]: resolved ?? entryValue };
+        }, {}));
+        return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+    }
+    function resolveCollectionConfig(config) {
+        const model = errors.scope('model', () => {
+            const resolved = resolve(config.model, BuilderModelSerialisedSchema);
+            if (resolved == null) {
+                return null;
+            }
+            return validateModelStructure(resolved, resolve, errors);
+        });
+        const min = errors.scope('min', () => resolve(config.min, NumberSchema));
+        const max = errors.scope('max', () => resolve(config.max, NumberSchema));
+        return {
+            ...config,
+            model: model ?? config.model,
+            min: min ?? config.min,
+            max: max ?? config.max
+        };
     }
     return resolve;
 }

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,14 @@
-import { BuilderModelSerialisedSchema, BuilderUIInputMetadataSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
-import { BuilderValidateErrors, check } from '../errors/index.js';
+import { BuilderModelSerialisedSchema, BuilderPathSchema, BuilderUIInputMetadataSchema, BuilderUIInputSerialisedSchema, BuilderUIInputsSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUISerialisedSchema, modelsMerge, serialise, uis, validateUIDescribe, validateUIInput, validateUIPage, validateUIPages } from '../entities/index.js';
+import { BuilderErrorsScope, check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
+import { StringSchema } from '../primitive.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);
@@ -25,8 +26,8 @@ export function validateUIStructure(ui, resolve, errors) {
     return data;
     function walkChildUIs() {
         return errors.scope('uis', () => ui.uis.flatMap((part, partIndex) => errors.scope(partIndex, () => {
-            const resolved = resolve(part);
-            if (resolved == null || !check.is(BuilderUISerialisedSchema, resolved)) {
+            const resolved = resolve(part, BuilderUISerialisedSchema);
+            if (resolved == null) {
                 return [];
             }
             return [validateUIStructure(resolved, resolve, errors)];
@@ -34,7 +35,7 @@ export function validateUIStructure(ui, resolve, errors) {
     }
     function walkItems(parts) {
         return parts.map((item, itemIndex) => errors.scope(itemIndex, () => {
-            const resolved = resolve(item);
+            const resolved = resolve(item, BuilderUIItemSerialisedSchema);
             return walkUIItem((resolved ?? item));
         }));
     }
@@ -48,17 +49,17 @@ export function validateUIStructure(ui, resolve, errors) {
         else if (item.type === 'describe') {
             validateUIDescribe(item, [], errors);
         }
-        const label = errors.scope('label', () => resolve(item.label) ?? item.label);
+        const label = errors.scope('label', () => resolve(item.label, StringSchema) ?? item.label);
         if (item.type === 'pages') {
             const innerItems = errors.scope('items', () => {
-                const resolved = resolve(item.items);
+                const resolved = resolve(item.items, BuilderUIItemsSerialisedSchema);
                 const resolvedItems = (Array.isArray(resolved) ? resolved : item.items);
                 return walkItems(resolvedItems);
             });
             return { ...item, label, items: innerItems };
         }
         const inputs = errors.scope('inputs', () => {
-            const resolved = resolve(item.inputs);
+            const resolved = resolve(item.inputs, BuilderUIInputsSerialisedSchema);
             if (!Array.isArray(resolved)) {
                 return resolved ?? item.inputs;
             }
@@ -68,22 +69,22 @@ export function validateUIStructure(ui, resolve, errors) {
     }
     function walkInputs(inputs) {
         return inputs.map((entry, entryIndex) => errors.scope(entryIndex, () => {
-            const resolvedEntry = resolve(entry);
+            const resolvedEntry = resolve(entry, BuilderUIInputSerialisedSchema);
             return walkInput((resolvedEntry ?? entry));
         }));
     }
     function walkInput(value) {
         validateUIInput(value, [], errors);
-        const path = errors.scope('path', () => resolve(value.path) ?? value.path);
+        const path = errors.scope('path', () => resolve(value.path, BuilderPathSchema) ?? value.path);
         const displayName = value.displayName &&
-            errors.scope('displayName', () => resolve(value.displayName) ?? value.displayName);
-        const kind = value.kind && errors.scope('kind', () => resolve(value.kind) ?? value.kind);
+            errors.scope('displayName', () => resolve(value.displayName, StringSchema) ?? value.displayName);
+        const kind = value.kind && errors.scope('kind', () => resolve(value.kind, StringSchema) ?? value.kind);
         const metadata = value.metadata && errors.scope('metadata', () => walkMetadata(value.metadata));
         return { ...value, path, displayName, kind, metadata };
     }
     function walkMetadata(rawMetadata) {
-        const resolved = resolve(rawMetadata);
-        if (!check.is(BuilderUIInputMetadataSchema, resolved)) {
+        const resolved = resolve(rawMetadata, BuilderUIInputMetadataSchema);
+        if (resolved == null) {
             return rawMetadata;
         }
         return Object.entries(resolved).reduce((entries, [key, entryValue]) => {

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.26",
   "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"
   },