@builder-builder/builder 0.0.27 → 0.0.29

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

package/dist/validate/pricing.js

@@ -1,25 +1,25 @@
 import { BuilderPricingExpressionSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema, pricing, serialise } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderIssuesScope, 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()));
-export function validatePricing(input, references = [], errors = new BuilderErrorsScope(input)) {
+export function validatePricing(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderPricingSerialisedSchema, input)) {
-        errors.entityInvalid('pricing');
-        return [EMPTY_PRICING, errors.errors];
+        issues.entityInvalid('pricing');
+        return [EMPTY_PRICING, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references);
-    const structure = validatePricingStructure(input, resolve, errors);
-    return [validate(structure), errors.errors];
+    const resolve = resolver(issues, references);
+    const structure = validatePricingStructure(input, resolve, issues);
+    return [validate(structure), issues.errors, issues.warnings];
 }
-export function validatePricingStructure(input, resolve, errors) {
-    const rates = errors.scope('rates', () => input.rates.flatMap((entry, index) => {
+export function validatePricingStructure(input, resolve, issues) {
+    const rates = issues.scope('rates', () => input.rates.flatMap((entry, index) => {
         const resolved = resolve(entry, BuilderRatesSchema);
         if (resolved != null) {
             return [resolved];
         }
-        errors.scope(index, () => errors.pricingInvalidRateValue());
+        issues.scope(index, () => issues.pricingInvalidRateValue());
         return [];
     }));
     const formula = input.formula == null ? null : resolveExpression(input.formula);
@@ -30,7 +30,7 @@ export function validatePricingStructure(input, resolve, errors) {
     function resolveExpression(input) {
         const resolved = resolve(input, BuilderPricingExpressionSchema);
         if (resolved == null) {
-            errors.pricingMalformedExpression();
+            issues.pricingMalformedExpression();
             return null;
         }
         if (check.is(NumberSchema, resolved)) {
@@ -40,11 +40,11 @@ export function validatePricingStructure(input, resolve, errors) {
             return resolved;
         }
         if (resolved.kind === 'variants') {
-            const inner = errors.scope('expression', () => resolveExpression(resolved.expression));
+            const inner = issues.scope('expression', () => resolveExpression(resolved.expression));
             return { ...resolved, expression: inner ?? resolved.expression };
         }
-        const left = errors.scope('left', () => resolveExpression(resolved.left));
-        const right = errors.scope('right', () => resolveExpression(resolved.right));
+        const left = issues.scope('left', () => resolveExpression(resolved.left));
+        const right = issues.scope('right', () => resolveExpression(resolved.right));
         return { ...resolved, left: left ?? resolved.left, right: right ?? resolved.right };
     }
     function walkExpression(expression, insideVariants) {
@@ -54,33 +54,33 @@ export function validatePricingStructure(input, resolve, errors) {
         switch (expression.kind) {
             case 'variantPrice':
                 if (!insideVariants) {
-                    errors.pricingInvalidScope();
+                    issues.pricingInvalidScope();
                 }
                 return;
             case 'lookup':
-                errors.scope('lookup', () => {
+                issues.scope('lookup', () => {
                     if (rates.length === 0) {
-                        errors.pricingEmptyRates();
+                        issues.pricingEmptyRates();
                     }
                     else {
                         const exists = rates.some((entry) => entry[expression.rate] != null);
                         if (!exists) {
-                            errors.pricingMissingRate();
+                            issues.pricingMissingRate();
                         }
                     }
                     if (!insideVariants) {
-                        errors.pricingInvalidScope();
+                        issues.pricingInvalidScope();
                     }
                 });
                 return;
             case 'variants':
-                errors.scope('variants', () => {
+                issues.scope('variants', () => {
                     if (insideVariants) {
-                        errors.pricingNestedVariants();
+                        issues.pricingNestedVariants();
                     }
                     const inner = expression.expression;
                     check.assert(BuilderPricingExpressionSchema, inner);
-                    errors.scope('expression', () => walkExpression(inner, true));
+                    issues.scope('expression', () => walkExpression(inner, true));
                 });
                 return;
             case 'add':
@@ -91,16 +91,16 @@ export function validatePricingStructure(input, resolve, errors) {
                 check.assert(BuilderPricingExpressionSchema, left);
                 check.assert(BuilderPricingExpressionSchema, right);
                 if (expression.kind === 'div' && check.is(NumberSchema, right) && right === 0) {
-                    errors.pricingDivideByZero();
+                    issues.pricingDivideByZero();
                 }
-                errors.scope('left', () => walkExpression(left, insideVariants));
-                errors.scope('right', () => walkExpression(right, insideVariants));
+                issues.scope('left', () => walkExpression(left, insideVariants));
+                issues.scope('right', () => walkExpression(right, insideVariants));
                 return;
             }
         }
     }
 }
-export function checkPricingExpectations(model, pricing, errors) {
+export function checkPricingExpectations(model, pricing, issues) {
     if (pricing.formula == null) {
         return;
     }
@@ -115,21 +115,21 @@ export function checkPricingExpectations(model, pricing, errors) {
         }
         switch (expression.kind) {
             case 'lookup':
-                errors.scope('lookup', () => {
+                issues.scope('lookup', () => {
                     if (expression.key.kind === 'option' && !optionNames.has(expression.key.name)) {
-                        errors.pricingMissingOption();
+                        issues.pricingMissingOption();
                     }
                 });
                 return;
             case 'variants':
-                errors.scope('variants', () => errors.scope('expression', () => walkExpression(expression.expression)));
+                issues.scope('variants', () => issues.scope('expression', () => walkExpression(expression.expression)));
                 return;
             case 'add':
             case 'sub':
             case 'mul':
             case 'div':
-                errors.scope('left', () => walkExpression(expression.left));
-                errors.scope('right', () => walkExpression(expression.right));
+                issues.scope('left', () => walkExpression(expression.left));
+                issues.scope('right', () => walkExpression(expression.right));
                 return;
             default:
                 return;

package/dist/validate/resolve.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderBindings, BuilderReferences } from '../entities/index';
-import type { BuilderErrorsScope } from '../errors/index';
+import type { BuilderIssuesScope } 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;
+export declare function resolver(issues: BuilderIssuesScope, references?: BuilderReferences, bindings?: BuilderBindings): BuilderResolve;

package/dist/validate/resolve.js

@@ -1,19 +1,19 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderWhenSerialisedSchema } from '../entities/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderPathSchema, BuilderConditionSerialisedSchema } 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 = {}) {
+export function resolver(issues, references = [], bindings = {}) {
     const resolving = new Set();
     function resolve(value, schema = v.unknown()) {
-        const errorsBefore = errors.errors.length;
+        const errorsBefore = issues.errors.length;
         const resolved = dispatch(value, schema);
         if (check.is(schema, resolved)) {
             return resolved;
         }
-        if (errors.errors.length === errorsBefore) {
-            errors.referenceInvalid();
+        if (issues.errors.length === errorsBefore) {
+            issues.referenceInvalid();
         }
         return null;
     }
@@ -24,8 +24,8 @@ export function resolver(errors, references = [], bindings = {}) {
         if (check.is(BuilderRefSerialisedSchema, value)) {
             return resolveReference(value, schema);
         }
-        if (check.is(BuilderWhenSerialisedSchema, value)) {
-            return resolveWhen(value, schema);
+        if (check.is(BuilderConditionSerialisedSchema, value)) {
+            return resolveCondition(value, schema);
         }
         if (check.is(BuilderCollectionConfigSerialisedSchema, value)) {
             return resolveCollectionConfig(value);
@@ -34,12 +34,12 @@ export function resolver(errors, references = [], bindings = {}) {
     }
     function resolveReference(reference, schema) {
         if (resolving.has(reference.id)) {
-            errors.referenceCircular();
+            issues.referenceCircular();
             return reference;
         }
         const found = references.find((entry) => entry.id === reference.id);
         if (found == null) {
-            errors.referenceMissing();
+            issues.referenceMissing();
             return reference;
         }
         resolving.add(reference.id);
@@ -52,7 +52,7 @@ export function resolver(errors, references = [], bindings = {}) {
     }
     function resolveParameter(parameter, schema) {
         if (!(parameter.name in bindings)) {
-            errors.referenceUnboundParameter();
+            issues.referenceUnboundParameter();
             return null;
         }
         const binding = bindings[parameter.name];
@@ -61,45 +61,41 @@ export function resolver(errors, references = [], bindings = {}) {
         }
         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));
+    function resolveCondition(condition, payloadSchema) {
+        if (condition.type === 'unless') {
+            const unlessPath = issues.scope('unlessPath', () => resolve(condition.unlessPath, BuilderPathSchema));
+            const payload = issues.scope('payload', () => resolve(condition.payload, payloadSchema));
             return {
-                ...when,
-                unlessPath: unlessPath ?? when.unlessPath,
-                payload: payload ?? when.payload
+                ...condition,
+                unlessPath: unlessPath ?? condition.unlessPath,
+                payload: payload ?? condition.payload
             };
         }
-        const matchPath = errors.scope('matchPath', () => resolve(when.matchPath, BuilderPathSchema));
+        const matchPath = issues.scope('matchPath', () => resolve(condition.matchPath, BuilderPathSchema));
         const selectMapSchema = v.record(StringSchema, v.nullable(v.unknown()));
-        const map = errors.scope('selectMap', () => resolve(when.selectMap, selectMapSchema));
+        const map = issues.scope('selectMap', () => resolve(condition.selectMap, selectMapSchema));
         if (map == null) {
-            return { ...when, matchPath: matchPath ?? when.matchPath };
+            return { ...condition, matchPath: matchPath ?? condition.matchPath };
         }
-        const selectMap = errors.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
+        const selectMap = issues.scope('selectMap', () => Object.entries(map).reduce((values, [key, entryValue]) => {
             if (entryValue == null) {
                 return { ...values, [key]: null };
             }
-            const resolved = errors.scope(key, () => resolve(entryValue, payloadSchema));
+            const resolved = issues.scope(key, () => resolve(entryValue, payloadSchema));
             return { ...values, [key]: resolved ?? entryValue };
         }, {}));
-        return { ...when, matchPath: matchPath ?? when.matchPath, selectMap };
+        return { ...condition, matchPath: matchPath ?? condition.matchPath, selectMap };
     }
     function resolveCollectionConfig(config) {
-        const model = errors.scope('model', () => {
+        const model = issues.scope('model', () => {
             const resolved = resolve(config.model, BuilderModelSerialisedSchema);
             if (resolved == null) {
                 return null;
             }
-            return validateModelStructure(resolved, resolve, errors);
+            return validateModelStructure(resolved, resolve, issues);
         });
-        const min = errors.scope('min', () => resolve(config.min, NumberSchema));
-        const max = errors.scope('max', () => resolve(config.max, NumberSchema));
+        const min = issues.scope('min', () => resolve(config.min, NumberSchema));
+        const max = issues.scope('max', () => resolve(config.max, NumberSchema));
         return {
             ...config,
             model: model ?? config.model,

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

package/dist/validate/ui.js

@@ -1,23 +1,23 @@
 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 { BuilderIssuesScope, 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 BuilderErrorsScope(input)) {
+export function validateUI(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderUISerialisedSchema, input)) {
-        errors.entityInvalid('ui');
-        return [validate(serialise.ui(uis())), errors.errors];
+        issues.entityInvalid('ui');
+        return [validate(serialise.ui(uis())), issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references);
-    const structure = validateUIStructure(input, resolve, errors);
-    return [validate(structure), errors.errors];
+    const resolve = resolver(issues, references);
+    const structure = validateUIStructure(input, resolve, issues);
+    return [validate(structure), issues.errors, issues.warnings];
 }
-export function validateUIStructure(ui, resolve, errors) {
+export function validateUIStructure(ui, resolve, issues) {
     const childUIs = walkChildUIs();
-    const items = errors.scope('items', () => walkItems(ui.items));
+    const items = issues.scope('items', () => walkItems(ui.items));
     const data = {
         ...ui,
         uis: childUIs,
@@ -25,40 +25,40 @@ export function validateUIStructure(ui, resolve, errors) {
     };
     return data;
     function walkChildUIs() {
-        return errors.scope('uis', () => ui.uis.flatMap((part, partIndex) => errors.scope(partIndex, () => {
+        return issues.scope('uis', () => ui.uis.flatMap((part, partIndex) => issues.scope(partIndex, () => {
             const resolved = resolve(part, BuilderUISerialisedSchema);
             if (resolved == null) {
                 return [];
             }
-            return [validateUIStructure(resolved, resolve, errors)];
+            return [validateUIStructure(resolved, resolve, issues)];
         })));
     }
     function walkItems(parts) {
-        return parts.map((item, itemIndex) => errors.scope(itemIndex, () => {
+        return parts.map((item, itemIndex) => issues.scope(itemIndex, () => {
             const resolved = resolve(item, BuilderUIItemSerialisedSchema);
             return walkUIItem((resolved ?? item));
         }));
     }
     function walkUIItem(item) {
         if (item.type === 'page') {
-            validateUIPage(item, [], errors);
+            validateUIPage(item, [], issues);
         }
         else if (item.type === 'pages') {
-            validateUIPages(item, [], errors);
+            validateUIPages(item, [], issues);
         }
         else if (item.type === 'describe') {
-            validateUIDescribe(item, [], errors);
+            validateUIDescribe(item, [], issues);
         }
-        const label = errors.scope('label', () => resolve(item.label, StringSchema) ?? item.label);
+        const label = issues.scope('label', () => resolve(item.label, StringSchema) ?? item.label);
         if (item.type === 'pages') {
-            const innerItems = errors.scope('items', () => {
+            const innerItems = issues.scope('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 inputs = issues.scope('inputs', () => {
             const resolved = resolve(item.inputs, BuilderUIInputsSerialisedSchema);
             if (!Array.isArray(resolved)) {
                 return resolved ?? item.inputs;
@@ -68,18 +68,18 @@ export function validateUIStructure(ui, resolve, errors) {
         return { ...item, label, inputs };
     }
     function walkInputs(inputs) {
-        return inputs.map((entry, entryIndex) => errors.scope(entryIndex, () => {
+        return inputs.map((entry, entryIndex) => issues.scope(entryIndex, () => {
             const resolvedEntry = resolve(entry, BuilderUIInputSerialisedSchema);
             return walkInput((resolvedEntry ?? entry));
         }));
     }
     function walkInput(value) {
-        validateUIInput(value, [], errors);
-        const path = errors.scope('path', () => resolve(value.path, BuilderPathSchema) ?? value.path);
+        validateUIInput(value, [], issues);
+        const path = issues.scope('path', () => resolve(value.path, BuilderPathSchema) ?? value.path);
         const displayName = value.displayName &&
-            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));
+            issues.scope('displayName', () => resolve(value.displayName, StringSchema) ?? value.displayName);
+        const kind = value.kind && issues.scope('kind', () => resolve(value.kind, StringSchema) ?? value.kind);
+        const metadata = value.metadata && issues.scope('metadata', () => walkMetadata(value.metadata));
         return { ...value, path, displayName, kind, metadata };
     }
     function walkMetadata(rawMetadata) {
@@ -88,28 +88,28 @@ export function validateUIStructure(ui, resolve, errors) {
             return rawMetadata;
         }
         return Object.entries(resolved).reduce((entries, [key, entryValue]) => {
-            const resolvedValue = errors.scope(key, () => resolve(entryValue));
+            const resolvedValue = issues.scope(key, () => resolve(entryValue));
             return { ...entries, [key]: resolvedValue ?? entryValue };
         }, {});
     }
 }
-export function checkUIExpectations(mergedModel, ui, errors) {
+export function checkUIExpectations(mergedModel, ui, issues) {
     const expectedOptionNames = collectExpectedOptionNames(ui);
-    errors.scope('expectations', () => {
-        checkExpectations(mergedModel, ui.expectations, errors);
+    issues.scope('expectations', () => {
+        checkExpectations(mergedModel, ui.expectations, issues);
     });
-    errors.scope('items', () => walkItems(mergedModel, ui.items));
-    errors.scope('uis', () => {
+    issues.scope('items', () => walkItems(mergedModel, ui.items));
+    issues.scope('uis', () => {
         ui.uis.forEach((nested, nestedIndex) => {
-            errors.scope(nestedIndex, () => {
-                checkUIExpectations(mergedModel, nested, errors);
+            issues.scope(nestedIndex, () => {
+                checkUIExpectations(mergedModel, nested, issues);
             });
         });
     });
     function walkItems(model, items) {
         items.forEach((entry, itemIndex) => {
             const item = entry;
-            errors.scope(itemIndex, () => {
+            issues.scope(itemIndex, () => {
                 if (item.type === 'pages') {
                     walkPages(model, item);
                     return;
@@ -118,8 +118,8 @@ export function checkUIExpectations(mergedModel, ui, errors) {
                 if (!Array.isArray(inputs)) {
                     return;
                 }
-                errors.scope('inputs', () => inputs.forEach((input, entryIndex) => {
-                    errors.scope(entryIndex, () => walkInput(model, input));
+                issues.scope('inputs', () => inputs.forEach((input, entryIndex) => {
+                    issues.scope(entryIndex, () => walkInput(model, input));
                 }));
             });
         });
@@ -132,7 +132,7 @@ export function checkUIExpectations(mergedModel, ui, errors) {
         const innerModels = resolveCollections(collection).flatMap(({ model: configModel }) => check.is(BuilderModelSerialisedSchema, configModel) ? [configModel] : []);
         innerModels.forEach((innerModel) => {
             const mergedInnerModel = modelsMerge(innerModel);
-            errors.scope('items', () => walkItems(mergedInnerModel, pages.items));
+            issues.scope('items', () => walkItems(mergedInnerModel, pages.items));
         });
     }
     function walkInput(model, input) {
@@ -144,8 +144,8 @@ export function checkUIExpectations(mergedModel, ui, errors) {
         if (typeof leaf === 'string' && expectedOptionNames.has(leaf)) {
             return;
         }
-        errors.scope('path', () => {
-            checkPath(model, path, errors);
+        issues.scope('path', () => {
+            checkPath(model, path, issues);
         });
     }
 }

package/dist/validate/variants.d.ts

@@ -1,7 +1,7 @@
-import type { BuilderModelValidated, BuilderVariantsValidated, ValidationResult } from '../entities/index';
-import { BuilderErrorsScope } from '../errors/index.js';
+import type { BuilderModelValidated, BuilderReferences, BuilderVariantsValidated, ValidationResult } from '../entities/index';
+import { BuilderIssuesScope } 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?: BuilderErrorsScope): BuilderVariantsValidationResult;
+export declare function validateVariants(model: BuilderModelValidated, input: unknown, options?: BuilderVariantsValidationOptions, references?: BuilderReferences, issues?: BuilderIssuesScope): BuilderVariantsValidationResult;

package/dist/validate/variants.js

@@ -1,46 +1,46 @@
 import { BuilderComponentConfigSerialisedSchema, detailValueSchema } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderIssuesScope, 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 BuilderErrorsScope(input)) {
+export function validateVariants(model, input, options = {}, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderVariantsSchema, input)) {
-        errors.variantsInvalid();
-        return [validate({}), errors.errors];
+        issues.variantsInvalid();
+        return [validate({}), issues.errors, issues.warnings];
     }
     const variants = input;
-    const expected = createVariants(model);
+    const expected = createVariants(model, references);
     if (Object.keys(expected).length === 0) {
-        errors.modelEmptyComponents();
-        return [validate({}), errors.errors];
+        issues.modelEmptyComponents();
+        return [validate({}), issues.errors, issues.warnings];
     }
-    errors.scope('variants', () => {
+    issues.scope('variants', () => {
         checkVariants();
         checkComponents();
         checkDetails();
         function checkVariants() {
             Object.entries(expected).forEach(([component, expectedVariants]) => {
                 const componentVariants = variants[component];
-                errors.scope(component, () => {
+                issues.scope(component, () => {
                     if (componentVariants == null) {
                         if (options.partial !== false) {
-                            errors.variantsMissingComponent();
+                            issues.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, () => {
+                        issues.scope(index, () => {
                             const { instance } = variant;
                             if (!expectedKeys.has(sortedKey(instance))) {
-                                errors.variantsInvalidVariant();
+                                issues.variantsInvalidVariant();
                             }
                         });
                     });
                     Array.from(expectedKeys).forEach(([key, instance]) => {
                         if (!actualKeys.has(key)) {
-                            errors.variantsMissingVariant(instance);
+                            issues.variantsMissingVariant(instance);
                         }
                     });
                 });
@@ -48,9 +48,9 @@ export function validateVariants(model, input, options = {}, errors = new Builde
         }
         function checkComponents() {
             Object.keys(variants).forEach((component) => {
-                errors.scope(component, () => {
+                issues.scope(component, () => {
                     if (expected[component] == null) {
-                        errors.variantsUnexpectedComponent();
+                        issues.variantsUnexpectedComponent();
                     }
                 });
             });
@@ -58,32 +58,33 @@ export function validateVariants(model, input, options = {}, errors = new Builde
         function checkDetails() {
             const componentByName = new Map(model.components.map((entry) => [entry.name, entry]));
             Object.entries(variants).forEach(([component, componentVariants]) => {
-                errors.scope(component, () => {
+                issues.scope(component, () => {
                     const entry = componentByName.get(component);
                     if (entry == null) {
                         return;
                     }
                     componentVariants.forEach(({ instance, details = {} }, index) => {
-                        errors.scope(index, () => {
+                        issues.scope(index, () => {
                             const resolved = variantDetails(entry, instance);
-                            const fields = resolved?.fields ?? [];
-                            const expectedNames = new Set(fields.map(({ name }) => name));
-                            errors.scope('details', () => {
-                                fields.forEach(({ name, valueType, isOptional }) => {
-                                    errors.scope(name, () => {
-                                        if (!(name in details)) {
-                                            errors.variantsMissingDetail();
+                            const expected = resolved?.details ?? [];
+                            const expectedNames = new Set(expected.map(({ name }) => name));
+                            issues.scope('details', () => {
+                                expected.forEach(({ name, kind, isOptional }) => {
+                                    issues.scope(name, () => {
+                                        const detail = details[name];
+                                        if (detail == null) {
+                                            issues.variantsMissingDetail();
                                             return;
                                         }
-                                        if (!check.is(detailValueSchema(valueType, isOptional), details[name])) {
-                                            errors.variantsInvalidDetail();
+                                        if (!check.is(detailValueSchema(kind, isOptional), detail.value)) {
+                                            issues.variantsInvalidDetail();
                                         }
                                     });
                                 });
-                                Object.keys(details).forEach((detail) => {
-                                    if (!expectedNames.has(detail)) {
-                                        errors.scope(detail, () => {
-                                            errors.variantsUnexpectedDetail();
+                                Object.keys(details).forEach((name) => {
+                                    if (!expectedNames.has(name)) {
+                                        issues.scope(name, () => {
+                                            issues.variantsUnexpectedDetail();
                                         });
                                     }
                                 });
@@ -94,7 +95,7 @@ export function validateVariants(model, input, options = {}, errors = new Builde
             });
         }
     });
-    return [validate(variants), errors.errors];
+    return [validate(variants), issues.errors, issues.warnings];
 }
 function variantDetails(component, variantInstance) {
     const { payload } = component;