@builder-builder/builder 0.0.27 → 0.0.29

package/dist/public.d.ts

@@ -1,37 +1,37 @@
 export type { BB, BBOptions, BuilderEntityValidators } from './bb';
-export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEnableConfig, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues, BuilderSerialised, BuilderTags, BuilderToggleConfig, BuilderToggleConfigSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { Builder, BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionCondition, BuilderCollectionConditionSerialised, BuilderComponent, BuilderComponentConfig, BuilderComponentConfigSerialised, BuilderComponentDetail, BuilderComponentDetailKind, BuilderComponentDetails, BuilderComponentDetailSerialised, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentCondition, BuilderComponentConditionSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderInstanceValidated, BuilderMatchConfig, BuilderMatchSelectMap, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionCondition, BuilderOptionConditionSerialised, BuilderPath, BuilderPaths, BuilderPricing, BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingSerialised, BuilderReference, BuilderReferences, BuilderSelectConfig, BuilderSerialised, BuilderTags, BuilderValueConfig, BuilderValueConfigSerialised, BuilderValueKind, BuilderValueOptionLabels, BuilderValueOptions, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIInput, BuilderUIInputMetadata, BuilderUIInputMetadataSerialised, BuilderUIInputs, BuilderUIInputSerialised, BuilderUIInputsSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUISerialised, BuilderUIsSerialised, BuilderUIValidated, BuilderUnlessConfig, BuilderValidated, BuilderVariantsValidated, BuilderCondition, BuilderConditionConfig, BuilderConditionSerialised } from './entities/index';
 export type { BuilderEnvironment } from './environment';
-export type { BuilderError, BuilderErrorLocation, BuilderErrors } from './errors/index';
-export type { BuilderErrorKind } from './errors/index.js';
-export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariants } from './instance';
+export type { BuilderIssue, BuilderIssueLocation, BuilderIssues } from './errors/index';
+export type { BuilderIssueKind } from './errors/index.js';
+export type { BuilderComponentVariant, BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariantDetail, BuilderVariants } from './instance';
 export type { BuilderOrder, BuilderRenderCollection, BuilderRenderCollectionAddRemove, BuilderRenderCollections, BuilderRenderMetadata, BuilderRenderOption, BuilderRenderOptions, BuilderRenderOptionUpdate, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult } from './mappers/index';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
 export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
 export type { BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderPricingValidationResult, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions, BuilderVariantsValidationResult } from './validate/index';
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, input, match, model, pricing, serialise, unless } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';
-import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, optionExpectation, uis } from './entities/index.js';
-export declare const collection: typeof collectionConfig & {
-    enable: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
-};
-export declare const component: typeof componentConfig & {
-    enable: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(payload?: Payload) => import("./public").BuilderEnableConfig<Payload>;
-    match: <const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderComponentConfig>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>, const Payload extends import("./references").Paramable<import("./public").BuilderComponentConfig>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./public").BuilderUnlessConfig<Payload, UnlessPath>;
-};
+import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, detailBoolean, detailImage, detailNumber, detailPrice, detailString, optionExpectation, valueBoolean, valueNumber, valueSelect, valueString, uis } from './entities/index.js';
+export declare const collection: typeof collectionConfig;
+export declare const component: typeof componentConfig;
 export declare const has: {
     collection: typeof collectionExpectation;
     component: typeof componentExpectation;
     option: typeof optionExpectation;
 };
-export declare const option: {
-    enable: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./public").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./public").BuilderPath>, const SelectMap extends import("./references").Paramable<import("./public").BuilderMatchSelectMap<import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./public").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Paramable<import("./public").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./public").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./public").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./public").BuilderUnlessConfig<Values, UnlessPath>;
+export declare const detail: {
+    boolean: typeof detailBoolean;
+    image: typeof detailImage;
+    number: typeof detailNumber;
+    price: typeof detailPrice;
+    string: typeof detailString;
 };
 export declare const ui: typeof uis;
+export declare const value: {
+    boolean: typeof valueBoolean;
+    number: typeof valueNumber;
+    select: typeof valueSelect;
+    string: typeof valueString;
+};

package/dist/public.js

@@ -1,19 +1,27 @@
 export { bb } from './bb.js';
-export { builder, detailBoolean, detailNumber, detailString, input, model, pricing, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { builder, input, match, model, pricing, serialise, unless } from './entities/index.js';
 export { BuilderException } from './errors/index.js';
 export { ordinal } from './mappers/index.js';
 export { parameter, ref } from './references.js';
-import { collectionConfig, collectionExpectation, collectionWhen, componentConfig, componentExpectation, componentWhen, optionExpectation, optionWhen, uis } from './entities/index.js';
-export const collection = Object.assign(collectionConfig, {
-    ...collectionWhen
-});
-export const component = Object.assign(componentConfig, {
-    ...componentWhen
-});
+import { collectionConfig, collectionExpectation, componentConfig, componentExpectation, detailBoolean, detailImage, detailNumber, detailPrice, detailString, optionExpectation, valueBoolean, valueNumber, valueSelect, valueString, uis } from './entities/index.js';
+export const collection = collectionConfig;
+export const component = componentConfig;
 export const has = {
     collection: collectionExpectation,
     component: componentExpectation,
     option: optionExpectation
 };
-export const option = optionWhen;
+export const detail = {
+    boolean: detailBoolean,
+    image: detailImage,
+    number: detailNumber,
+    price: detailPrice,
+    string: detailString
+};
 export const ui = uis;
+export const value = {
+    boolean: valueBoolean,
+    number: valueNumber,
+    select: valueSelect,
+    string: valueString
+};

package/dist/validate/builder.d.ts

@@ -1,4 +1,4 @@
 import type { BuilderReferences, BuilderValidated, ValidationResult } from '../entities/index';
-import { BuilderErrorsScope } from '../errors/index.js';
+import { BuilderIssuesScope } from '../errors/index.js';
 export type BuilderValidationResult = ValidationResult<BuilderValidated>;
-export declare function validateBuilder(input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope): BuilderValidationResult;
+export declare function validateBuilder(input: unknown, references?: BuilderReferences, issues?: BuilderIssuesScope): BuilderValidationResult;

package/dist/validate/builder.js

@@ -1,30 +1,30 @@
 import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
 import { validate } from './brand.js';
 import { checkModelExpectations, validateModelStructure } from './model.js';
 import { checkPricingExpectations, validatePricingStructure } from './pricing.js';
 import { resolver } from './resolve.js';
 import { checkUIExpectations, validateUIStructure } from './ui.js';
 const EMPTY_BUILDER = validate(serialise.builder(builder()));
-export function validateBuilder(input, references = [], errors = new BuilderErrorsScope(input)) {
+export function validateBuilder(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderSerialisedSchema, input)) {
-        errors.entityInvalid('builder');
-        return [EMPTY_BUILDER, errors.errors];
+        issues.entityInvalid('builder');
+        return [EMPTY_BUILDER, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references, input.bindings);
-    const validatedModel = errors.scope('model', () => validateModelStructure(input.model, resolve, errors));
+    const resolve = resolver(issues, references, input.bindings);
+    const validatedModel = issues.scope('model', () => validateModelStructure(input.model, resolve, issues));
     const mergedModel = modelsMerge(validatedModel);
-    errors.scope('model', () => {
-        checkModelExpectations(mergedModel, validatedModel, errors);
+    issues.scope('model', () => {
+        checkModelExpectations(mergedModel, validatedModel, issues);
     });
-    const validatedUI = errors.scope('ui', () => {
-        const validated = validateUIStructure(input.ui, resolve, errors);
-        checkUIExpectations(mergedModel, validated, errors);
+    const validatedUI = issues.scope('ui', () => {
+        const validated = validateUIStructure(input.ui, resolve, issues);
+        checkUIExpectations(mergedModel, validated, issues);
         return validated;
     });
-    const validatedPricing = errors.scope('pricing', () => {
-        const validated = validatePricingStructure(input.pricing, resolve, errors);
-        checkPricingExpectations(mergedModel, validated, errors);
+    const validatedPricing = issues.scope('pricing', () => {
+        const validated = validatePricingStructure(input.pricing, resolve, issues);
+        checkPricingExpectations(mergedModel, validated, issues);
         return validated;
     });
     const data = validate({
@@ -33,5 +33,5 @@ export function validateBuilder(input, references = [], errors = new BuilderErro
         ui: validate(validatedUI),
         pricing: validate(validatedPricing)
     });
-    return [data, errors.errors];
+    return [data, issues.errors, issues.warnings];
 }

package/dist/validate/expectations.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderErrorsScope } from '../errors/index';
-export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderErrorsScope): void;
+import type { BuilderIssuesScope } from '../errors/index';
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, issues: BuilderIssuesScope): void;

package/dist/validate/expectations.js

@@ -1,10 +1,28 @@
-export function checkExpectations(model, expectations, errors) {
-    expectations.forEach(({ kind, name }, index) => {
-        errors.scope(index, () => {
-            if (model[`${kind}s`].some((entry) => entry.name === name)) {
+import { BuilderOptionConfigSerialisedSchema } from '../entities/index.js';
+import { check } from '../errors/index.js';
+export function checkExpectations(model, expectations, issues) {
+    expectations.forEach(({ kind, name, payload }, index) => {
+        issues.scope(index, () => {
+            const entry = model[`${kind}s`].find((candidate) => candidate.name === name);
+            if (entry == null) {
+                issues.modelUnmetExpectation();
                 return;
             }
-            errors.modelUnmetExpectation();
+            if (payload != null && !isExpectedOption(entry.payload, payload)) {
+                issues.modelInvalidExpectation();
+            }
         });
     });
 }
+function isExpectedOption(payload, expectation) {
+    if (!check.is(BuilderOptionConfigSerialisedSchema, payload)) {
+        return true;
+    }
+    if (expectation.kind === 'select') {
+        if (payload.kind !== 'select') {
+            return false;
+        }
+        return expectation.options.every((option) => payload.options.includes(option));
+    }
+    return payload.kind === expectation.kind;
+}

package/dist/validate/instance.d.ts

@@ -1,5 +1,5 @@
 import type { BuilderInstanceValidated, BuilderModelValidated, ValidationResult } from '../entities/index';
 import type { BuilderInstance } from '../instance';
-import { BuilderErrorsScope } from '../errors/index.js';
+import { BuilderIssuesScope } from '../errors/index.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
-export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderErrorsScope): BuilderInstanceValidationResult;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, issues?: BuilderIssuesScope): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,15 +1,16 @@
-import { optionValueSchema } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { modelsMerge, optionValueSchema } from '../entities/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
 import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function validateInstance(model, instance, errors = new BuilderErrorsScope(instance)) {
-    errors.scope('instance', () => {
+export function validateInstance(model, instance, issues = new BuilderIssuesScope(instance)) {
+    issues.scope('instance', () => {
         checkInstance(model, instance);
     });
-    return [validate(instance), errors.errors];
+    return [validate(instance), issues.errors, issues.warnings];
     function checkInstance(scopeModel, scopeInstance) {
-        scopeModel.options.forEach((option) => {
+        const merged = modelsMerge(scopeModel);
+        merged.options.forEach((option) => {
             const { name } = option;
             const payload = resolveOption(option, scopeModel, scopeInstance);
             if (!payload) {
@@ -17,12 +18,12 @@ export function validateInstance(model, instance, errors = new BuilderErrorsScop
             }
             const value = scopeInstance[name];
             if (!check.is(optionValueSchema(payload), value)) {
-                errors.scope(name, () => {
-                    errors.instanceInvalidOption();
+                issues.scope(name, () => {
+                    issues.instanceInvalidOption();
                 });
             }
         });
-        scopeModel.collections.forEach((collection) => {
+        merged.collections.forEach((collection) => {
             const { name } = collection;
             const payload = resolveCollection(collection, scopeModel, scopeInstance);
             if (!payload) {
@@ -30,18 +31,35 @@ export function validateInstance(model, instance, errors = new BuilderErrorsScop
             }
             const existing = scopeInstance[name];
             if (!check.is(BuilderInstancesSchema, existing)) {
-                errors.scope(name, () => {
-                    errors.instanceInvalidCollection();
+                issues.scope(name, () => {
+                    issues.instanceInvalidCollection();
                 });
                 return;
             }
-            errors.scope(name, () => {
+            issues.scope(name, () => {
+                if (existing.length < payload.min) {
+                    issues.instanceInvalidCollectionMin();
+                }
+                else if (existing.length > payload.max) {
+                    issues.instanceInvalidCollectionMax();
+                }
                 existing.forEach((itemInstance, index) => {
-                    errors.scope(index, () => {
+                    issues.scope(index, () => {
                         checkInstance(payload.model, itemInstance);
                     });
                 });
             });
         });
+        const declaredNames = new Set([
+            ...merged.options.map((option) => option.name),
+            ...merged.collections.map((collection) => collection.name)
+        ]);
+        Object.keys(scopeInstance).forEach((key) => {
+            if (!declaredNames.has(key)) {
+                issues.scope(key, () => {
+                    issues.instanceUnexpectedKey();
+                });
+            }
+        });
     }
 }

package/dist/validate/model.d.ts

@@ -1,8 +1,8 @@
 import type { BuilderModelSerialised, BuilderModelValidated, BuilderReferences, ValidationResult } from '../entities/index';
 import type { ParamableSerialised } from '../references';
 import type { BuilderResolve } from './resolve';
-import { BuilderErrorsScope } from '../errors/index.js';
+import { BuilderIssuesScope } from '../errors/index.js';
 export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
-export declare function validateModel(input: unknown, references?: BuilderReferences, errors?: BuilderErrorsScope): BuilderModelValidationResult;
-export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, errors: BuilderErrorsScope): void;
-export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, errors: BuilderErrorsScope): BuilderModelValidated;
+export declare function validateModel(input: unknown, references?: BuilderReferences, issues?: BuilderIssuesScope): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, issues: BuilderIssuesScope): void;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, issues: BuilderIssuesScope): BuilderModelValidated;

package/dist/validate/model.js

@@ -1,40 +1,41 @@
 import * as v from 'valibot';
-import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderWhenSerialisedSchema, whenBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateSelect, validateToggle } from '../entities/index.js';
-import { BuilderErrorsScope, check } from '../errors/index.js';
+import { BuilderCollectionConfigSerialisedSchema, BuilderComponentConfigSerialisedSchema, BuilderModelSerialisedSchema, BuilderOptionConfigSerialisedSchema, BuilderPathsSchema, BuilderConditionSerialisedSchema, conditionBranches, model, modelsMerge, serialise, validateCollectionConfig, validateComponentConfig, validateValue } from '../entities/index.js';
+import { BuilderIssuesScope, check } from '../errors/index.js';
+import { dependencies } from '../mappers/index.js';
 import { isParamable } from '../references.js';
 import { validate } from './brand.js';
 import { checkExpectations } from './expectations.js';
 import { checkPath } from './paths.js';
 import { resolver } from './resolve.js';
 const EMPTY_MODEL = validate(serialise.model(model()));
-export function validateModel(input, references = [], errors = new BuilderErrorsScope(input)) {
+export function validateModel(input, references = [], issues = new BuilderIssuesScope(input)) {
     if (!check.is(BuilderModelSerialisedSchema, input)) {
-        errors.entityInvalid('model');
-        return [EMPTY_MODEL, errors.errors];
+        issues.entityInvalid('model');
+        return [EMPTY_MODEL, issues.errors, issues.warnings];
     }
-    const resolve = resolver(errors, references);
-    const structure = validateModelStructure(input, resolve, errors);
+    const resolve = resolver(issues, references);
+    const structure = validateModelStructure(input, resolve, issues);
     const merged = modelsMerge(structure);
     const data = validate(merged);
-    checkModelExpectations(data, structure, errors);
-    return [data, errors.errors];
+    checkModelExpectations(data, structure, issues);
+    return [data, issues.errors, issues.warnings];
 }
-export function checkModelExpectations(mergedModel, rootModel, errors) {
+export function checkModelExpectations(mergedModel, rootModel, issues) {
     recurse(rootModel);
     function recurse(node) {
-        errors.scope('expectations', () => {
-            checkExpectations(mergedModel, node.expectations, errors);
+        issues.scope('expectations', () => {
+            checkExpectations(mergedModel, node.expectations, issues);
         });
-        errors.scope('models', () => {
+        issues.scope('models', () => {
             node.models.forEach((nested, nestedIndex) => {
-                errors.scope(nestedIndex, () => {
+                issues.scope(nestedIndex, () => {
                     recurse(nested);
                 });
             });
         });
     }
 }
-export function validateModelStructure(input, resolve, errors) {
+export function validateModelStructure(input, resolve, issues) {
     const seenGlobal = {
         option: new Set(),
         component: new Set(),
@@ -47,41 +48,42 @@ export function validateModelStructure(input, resolve, errors) {
             return validate(serialise.model(model()));
         }
         const modelInput = resolved;
-        const skipPathValidation = modelInput.expectations.length > 0;
-        const childModels = errors.scope('models', () => modelInput.models.flatMap((part, partIndex) => errors.scope(partIndex, () => [walkStructure(part)])));
-        const options = errors.scope('options', () => walkEntries(modelInput.options, 'option', (resolved) => {
-            whenBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
+        const childModels = issues.scope('models', () => modelInput.models.flatMap((part, partIndex) => issues.scope(partIndex, () => [walkStructure(part)])));
+        const options = issues.scope('options', () => walkEntries(modelInput.options, 'option', (resolved) => {
+            conditionBranches(resolved.payload, BuilderOptionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                if (config.type === 'select') {
-                    validateSelect(config, [], errors);
-                }
-                else if (config.type === 'toggle') {
-                    validateToggle(config, [], errors);
+                if (config.type === 'value') {
+                    validateValue(config, [], issues);
                 }
             });
         }));
-        const components = errors.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
-            whenBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
+        const components = issues.scope('components', () => walkEntries(modelInput.components, 'component', (resolved) => {
+            conditionBranches(resolved.payload, BuilderComponentConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                validateComponentConfig(config, [], errors);
+                validateComponentConfig(config, [], issues);
             });
         }));
-        const collections = errors.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
-            whenBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
+        const collections = issues.scope('collections', () => walkEntries(modelInput.collections, 'collection', (resolved) => {
+            conditionBranches(resolved.payload, BuilderCollectionConfigSerialisedSchema)
                 .filter((config) => !isParamable(config))
                 .forEach((config) => {
-                validateCollectionConfig(config, [], errors);
+                validateCollectionConfig(config, [], issues);
             });
         }));
-        return {
+        const validatedModel = {
             ...modelInput,
             models: childModels,
             options,
             components,
             collections
         };
+        const ordered = new Set(dependencies(validatedModel));
+        if ([...options, ...collections, ...components].some((entry) => !ordered.has(entry.name))) {
+            issues.modelCircularDependency();
+        }
+        return validatedModel;
         function payloadSchemaFor(kind) {
             if (kind === 'option') {
                 return BuilderOptionConfigSerialisedSchema;
@@ -95,7 +97,7 @@ export function validateModelStructure(input, resolve, errors) {
             const seenLocal = new Set();
             const items = [];
             entries.forEach((entry, entryIndex) => {
-                errors.scope(entryIndex, () => {
+                issues.scope(entryIndex, () => {
                     const resolved = resolveEntry(entry, seenLocal, kind);
                     if (resolved == null) {
                         return;
@@ -109,33 +111,33 @@ export function validateModelStructure(input, resolve, errors) {
         function resolveEntry(entry, seenLocal, kind) {
             let paths = entry.paths;
             if (entry.paths != null) {
-                const resolvedPaths = errors.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
+                const resolvedPaths = issues.scope('paths', () => resolve(entry.paths, BuilderPathsSchema));
                 paths = resolvedPaths ?? entry.paths;
             }
-            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderWhenSerialisedSchema]);
-            const payload = errors.scope('payload', () => resolve(entry.payload, payloadSchema));
+            const payloadSchema = v.union([payloadSchemaFor(kind), BuilderConditionSerialisedSchema]);
+            const payload = issues.scope('payload', () => resolve(entry.payload, payloadSchema));
             const resolvedEntry = { ...entry, paths, payload: payload ?? entry.payload };
             if (seenLocal.has(resolvedEntry.name)) {
                 if (kind === 'option') {
-                    errors.modelDuplicateOption();
+                    issues.modelDuplicateOption();
                 }
                 else if (kind === 'component') {
-                    errors.modelDuplicateComponent();
+                    issues.modelDuplicateComponent();
                 }
                 else {
-                    errors.modelDuplicateCollection();
+                    issues.modelDuplicateCollection();
                 }
                 return null;
             }
             if (seenGlobal[kind].has(resolvedEntry.name)) {
                 if (kind === 'option') {
-                    errors.modelOverriddenOption();
+                    issues.modelOverriddenOption();
                 }
                 else if (kind === 'component') {
-                    errors.modelOverriddenComponent();
+                    issues.modelOverriddenComponent();
                 }
                 else {
-                    errors.modelOverriddenCollection();
+                    issues.modelOverriddenCollection();
                 }
             }
             seenLocal.add(resolvedEntry.name);
@@ -144,27 +146,31 @@ export function validateModelStructure(input, resolve, errors) {
             return resolvedEntry;
         }
         function checkPaths(entry) {
-            if (skipPathValidation) {
-                return;
-            }
             const { paths, payload } = entry;
             if (Array.isArray(paths)) {
-                errors.scope('paths', () => {
+                issues.scope('paths', () => {
                     paths.forEach((path, pathIndex) => {
-                        errors.scope(pathIndex, () => {
-                            checkPath(modelInput, path, errors);
+                        issues.scope(pathIndex, () => {
+                            checkPath(modelInput, path, issues);
                         });
                     });
                 });
             }
-            if (!check.is(BuilderWhenSerialisedSchema, payload)) {
+            if (!check.is(BuilderConditionSerialisedSchema, payload)) {
                 return;
             }
             if (payload.type === 'match' && Array.isArray(payload.matchPath)) {
-                errors.scope('payload', () => errors.scope('matchPath', () => checkPath(modelInput, payload.matchPath, errors)));
+                issues.scope('payload', () => issues.scope('matchPath', () => checkPath(modelInput, payload.matchPath, issues)));
             }
-            if (payload.type === 'unless' && Array.isArray(payload.unlessPath)) {
-                errors.scope('payload', () => errors.scope('unlessPath', () => checkPath(modelInput, payload.unlessPath, errors)));
+            if (payload.type === 'unless') {
+                if (payload.disabledValues.length === 0) {
+                    issues.scope('payload', () => issues.scope('disabledValues', () => {
+                        issues.entityEmptyDisabledValues();
+                    }));
+                }
+                if (Array.isArray(payload.unlessPath)) {
+                    issues.scope('payload', () => issues.scope('unlessPath', () => checkPath(modelInput, payload.unlessPath, issues)));
+                }
             }
         }
     }

package/dist/validate/paths.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderModelSerialised, BuilderPath } from '../entities/index';
-import type { BuilderErrorsScope } from '../errors/index';
-export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, errors: BuilderErrorsScope): void;
+import type { BuilderIssuesScope } from '../errors/index';
+export declare function checkPath(model: BuilderModelSerialised, path: BuilderPath, issues: BuilderIssuesScope): void;

package/dist/validate/paths.js

@@ -2,19 +2,24 @@ import { BuilderModelSerialisedSchema } from '../entities/index.js';
 import { check } from '../errors/index.js';
 import { resolveCollections } from '../mappers/index.js';
 import { NameSchema, NumberSchema } from '../primitive.js';
-export function checkPath(model, path, errors) {
+export function checkPath(model, path, issues) {
     if (path.length === 0) {
-        errors.pathEmpty();
+        issues.pathEmpty();
+        return;
+    }
+    const [firstSegment] = path;
+    if (check.is(NameSchema, firstSegment) &&
+        model.expectations.some((expectation) => expectation.name === firstSegment)) {
         return;
     }
     const lastIndex = path.length - 1;
-    const models = walkPath([model], path.slice(0, -1), 0, errors);
+    const models = walkPath([model], path.slice(0, -1), 0, issues);
     if (models == null) {
         return;
     }
     const optionName = path.at(-1);
     if (!check.is(NameSchema, optionName)) {
-        errors.scope(lastIndex, () => errors.pathInvalidSegment());
+        issues.scope(lastIndex, () => issues.pathInvalidSegment());
         return;
     }
     if (models.some((model) => model.options.some((option) => option.name === optionName))) {
@@ -22,27 +27,27 @@ export function checkPath(model, path, errors) {
     }
     const isCollection = models.some((model) => model.collections.some((entry) => entry.name === optionName));
     if (isCollection) {
-        errors.scope(lastIndex, () => errors.pathTargetIsCollection());
+        issues.scope(lastIndex, () => issues.pathTargetIsCollection());
         return;
     }
     const isComponent = models.some((model) => model.components.some((entry) => entry.name === optionName));
     if (isComponent) {
-        errors.scope(lastIndex, () => errors.pathTargetIsComponent());
+        issues.scope(lastIndex, () => issues.pathTargetIsComponent());
         return;
     }
-    errors.scope(lastIndex, () => errors.pathMissingOption());
+    issues.scope(lastIndex, () => issues.pathMissingOption());
 }
-function walkPath(models, remaining, offset, errors) {
+function walkPath(models, remaining, offset, issues) {
     if (remaining.length === 0) {
         return models;
     }
     const [collectionName, index, ...rest] = remaining;
     if (!check.is(NameSchema, collectionName)) {
-        errors.scope(offset, () => errors.pathInvalidSegment());
+        issues.scope(offset, () => issues.pathInvalidSegment());
         return null;
     }
     if (!check.is(NumberSchema, index)) {
-        errors.scope(offset + 1, () => errors.pathInvalidSegment());
+        issues.scope(offset + 1, () => issues.pathInvalidSegment());
         return null;
     }
     const collectionConfigs = models.flatMap((model) => {
@@ -50,7 +55,7 @@ function walkPath(models, remaining, offset, errors) {
         return collection == null ? [] : resolveCollections(collection);
     });
     if (collectionConfigs.length === 0) {
-        errors.scope(offset, () => errors.pathMissingCollection());
+        issues.scope(offset, () => issues.pathMissingCollection());
         return null;
     }
     const indexableConfigs = collectionConfigs.filter(({ max }) => !check.is(NumberSchema, max) || index < max);
@@ -61,13 +66,13 @@ function walkPath(models, remaining, offset, errors) {
             }
             return max > highest ? max : highest;
         }, 0);
-        errors.scope(offset + 1, () => errors.pathInvalidIndex(max));
+        issues.scope(offset + 1, () => issues.pathInvalidIndex(max));
         return null;
     }
     const next = indexableConfigs.flatMap((collectionConfig) => check.is(BuilderModelSerialisedSchema, collectionConfig.model) ? [collectionConfig.model] : []);
     if (next.length === 0) {
-        errors.scope(offset, () => errors.pathMissingCollection());
+        issues.scope(offset, () => issues.pathMissingCollection());
         return null;
     }
-    return walkPath(next, rest, offset + 2, errors);
+    return walkPath(next, rest, offset + 2, issues);
 }