@builder-builder/builder 0.0.12 → 0.0.14

package/dist/validate/errors.js

@@ -0,0 +1,141 @@
+import { builderError } from '../exception.js';
+export class BuilderValidateErrors {
+    #errors = [];
+    #location = [];
+    get errors() {
+        return this.#errors;
+    }
+    scope(part, fn) {
+        this.#location = [...this.#location, part];
+        try {
+            return fn();
+        }
+        finally {
+            this.#location = this.#location.slice(0, -1);
+        }
+    }
+    invalidInput(target) {
+        return this.#addError({
+            ...builderError('invalid-input', this.#location),
+            target
+        });
+    }
+    invalidOption(name, value) {
+        return this.#addError({
+            ...builderError('invalid-option', this.#location),
+            name,
+            value
+        });
+    }
+    invalidCollection(name) {
+        return this.#addError({
+            ...builderError('invalid-collection', this.#location),
+            name
+        });
+    }
+    duplicateName(name) {
+        return this.#addError({
+            ...builderError('duplicate-name', this.#location),
+            name
+        });
+    }
+    invalidCollectionBounds(name, min, max) {
+        return this.#addError({
+            ...builderError('invalid-collection-bounds', this.#location),
+            name,
+            min,
+            max
+        });
+    }
+    invalidPath(reason) {
+        return this.#addError({
+            ...builderError('invalid-path', this.#location),
+            reason
+        });
+    }
+    invalidSelectMapKey(key) {
+        return this.#addError({
+            ...builderError('invalid-select-map-key', this.#location),
+            key
+        });
+    }
+    unboundParameter(name) {
+        return this.#addError({
+            ...builderError('unbound-parameter', this.#location),
+            name
+        });
+    }
+    missingReference(id) {
+        return this.#addError({
+            ...builderError('missing-reference', this.#location),
+            id
+        });
+    }
+    unmetExpectation(expectationKind, name) {
+        return this.#addError({
+            ...builderError('unmet-expectation', this.#location),
+            expectationKind,
+            name
+        });
+    }
+    unvalidated(value) {
+        return this.#addError({
+            ...builderError('unvalidated', this.#location),
+            value
+        });
+    }
+    missingComponent(component) {
+        return this.#addError({
+            ...builderError('missing-component', this.#location),
+            component
+        });
+    }
+    unexpectedComponent(component) {
+        return this.#addError({
+            ...builderError('unexpected-component', this.#location),
+            component
+        });
+    }
+    missingVariant(component, instance) {
+        return this.#addError({
+            ...builderError('missing-variant', this.#location),
+            component,
+            instance
+        });
+    }
+    invalidVariant(component, instance) {
+        return this.#addError({
+            ...builderError('invalid-variant', this.#location),
+            component,
+            instance
+        });
+    }
+    missingDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('missing-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    unexpectedDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('unexpected-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    invalidDetail(component, detail, instance) {
+        return this.#addError({
+            ...builderError('invalid-detail', this.#location),
+            component,
+            detail,
+            instance
+        });
+    }
+    #addError(error) {
+        this.#errors = [...this.#errors, error];
+        return error;
+    }
+}

package/dist/validate/expectations.d.ts

@@ -1,10 +1,3 @@
-import type { BuilderExpectationKind, BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
-export declare function builderErrorUnmetExpectation(expectationKind: BuilderExpectationKind, name: string, location?: BuilderErrorLocation): {
-    expectationKind: "option" | "component" | "collection";
-    name: string;
-    kind: "unmet-expectation";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorUnmetExpectation = ReturnType<typeof builderErrorUnmetExpectation>;
-export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, location: BuilderErrorLocation): BuilderErrors;
+import type { BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderValidateErrors } from './errors';
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, errors: BuilderValidateErrors): void;

package/dist/validate/expectations.js

@@ -1,12 +1,10 @@
-import { builderError } from '../exception.js';
-export function builderErrorUnmetExpectation(expectationKind, name, location = []) {
-    return { ...builderError('unmet-expectation', location), expectationKind, name };
-}
-export function checkExpectations(model, expectations, location) {
-    return expectations.flatMap(({ kind, name }, index) => {
-        if (model[`${kind}s`].some((entry) => entry.name === name)) {
-            return [];
-        }
-        return [builderErrorUnmetExpectation(kind, name, [...location, index])];
+export function checkExpectations(model, expectations, errors) {
+    expectations.forEach(({ kind, name }, index) => {
+        errors.scope(index, () => {
+            if (model[`${kind}s`].some((entry) => entry.name === name)) {
+                return;
+            }
+            errors.unmetExpectation(kind, name);
+        });
     });
 }

package/dist/validate/index.d.ts

@@ -1,18 +1,12 @@
-export type { BuilderErrorUnvalidated } from './brand';
 export type { BuilderValidationResult } from './builder';
-export type { BuilderErrorUnmetExpectation } from './expectations';
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderInstanceValidationResult } from './instance';
-export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderModelValidationResult } from './model';
-export type { BuilderErrorMissingReference, BuilderErrorUnboundParameter } from './resolve';
-export type { BuilderErrorInvalidInput } from './result';
+export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInvalidInputTarget } from './errors';
+export type { BuilderInstanceValidationResult } from './instance';
+export type { BuilderModelValidationResult } from './model';
 export type { BuilderUIValidationResult } from './ui';
-export type { BuilderComponentVariantsValidationResult, BuilderErrorInvalidDetail, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderVariantsValidationOptions } from './variants';
-export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export type { BuilderComponentVariantsValidationResult, BuilderVariantsValidationOptions } from './variants';
+export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
-export { builderErrorUnmetExpectation } from './expectations.js';
-export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
-export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
-export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
-export { builderErrorInvalidInput } from './result.js';
+export { validateInstance } from './instance.js';
+export { validateModel } from './model.js';
 export { validateUI } from './ui.js';
-export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';
+export { validateVariants } from './variants.js';

package/dist/validate/index.js

@@ -1,9 +1,6 @@
-export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { assertValidated } from './brand.js';
 export { validateBuilder } from './builder.js';
-export { builderErrorUnmetExpectation } from './expectations.js';
-export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
-export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
-export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
-export { builderErrorInvalidInput } from './result.js';
+export { validateInstance } from './instance.js';
+export { validateModel } from './model.js';
 export { validateUI } from './ui.js';
-export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';
+export { validateVariants } from './variants.js';

package/dist/validate/instance.d.ts

@@ -1,19 +1,6 @@
 import type { BuilderInstanceValidated, BuilderModelValidated } from '../entities/index';
-import type { BuilderErrorLocation } from '../exception';
 import type { BuilderInstance } from '../instance';
 import type { ValidationResult } from './result';
-export declare function builderErrorInvalidOption(name: string, value: unknown, location?: BuilderErrorLocation): {
-    name: string;
-    value: unknown;
-    kind: "invalid-option";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidOption = ReturnType<typeof builderErrorInvalidOption>;
-export declare function builderErrorInvalidCollection(name: string, location?: BuilderErrorLocation): {
-    name: string;
-    kind: "invalid-collection";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidCollection = ReturnType<typeof builderErrorInvalidCollection>;
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
-export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance): BuilderInstanceValidationResult;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance, errors?: BuilderValidateErrors): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -1,46 +1,48 @@
 import { check } from '../check.js';
 import { optionValueSchema } from '../entities/index.js';
-import { builderError } from '../exception.js';
+import { BuilderInstancesSchema } from '../instance.js';
 import { resolveCollection, resolveOption } from '../mappers/index.js';
 import { validate } from './brand.js';
-export function builderErrorInvalidOption(name, value, location = []) {
-    return { ...builderError('invalid-option', location), name, value };
-}
-export function builderErrorInvalidCollection(name, location = []) {
-    return { ...builderError('invalid-collection', location), name };
-}
-export function validateInstance(model, instance) {
-    const errors = checkInstance(model, instance, ['instance']);
-    return [validate(instance), errors];
-}
-function checkInstance(model, instance, location) {
-    const { options, collections } = model;
-    const optionErrors = options.flatMap((option) => {
-        const { name } = option;
-        const payload = resolveOption(option, instance);
-        if (!payload) {
-            return [];
-        }
-        const value = instance[name];
-        if (!check.is(optionValueSchema(payload), value)) {
-            return [builderErrorInvalidOption(name, value, [...location, name])];
-        }
-        return [];
-    });
-    const collectionErrors = collections.flatMap((collection) => {
-        const { name } = collection;
-        const payload = resolveCollection(collection, instance);
-        if (!payload) {
-            return [];
-        }
-        const existing = instance[name];
-        if (!Array.isArray(existing)) {
-            return [builderErrorInvalidCollection(name, [...location, name])];
-        }
-        return existing.flatMap((itemInstance, index) => checkInstance(payload.model, itemInstance, [...location, name, index]).map((error) => ({
-            ...error,
-            name: `${name}[${index}].${error.name}`
-        })));
+import { BuilderValidateErrors } from './errors.js';
+export function validateInstance(model, instance, errors = new BuilderValidateErrors()) {
+    errors.scope('instance', () => {
+        checkInstance(model, instance);
     });
-    return [...optionErrors, ...collectionErrors];
+    return [validate(instance), errors.errors];
+    function checkInstance(scopeModel, scopeInstance, namePrefix = '') {
+        scopeModel.options.forEach((option) => {
+            const { name } = option;
+            const payload = resolveOption(option, scopeModel, scopeInstance);
+            if (!payload) {
+                return;
+            }
+            const value = scopeInstance[name];
+            if (!check.is(optionValueSchema(payload), value)) {
+                errors.scope(name, () => {
+                    errors.invalidOption(`${namePrefix}${name}`, value);
+                });
+            }
+        });
+        scopeModel.collections.forEach((collection) => {
+            const { name } = collection;
+            const payload = resolveCollection(collection, scopeModel, scopeInstance);
+            if (!payload) {
+                return;
+            }
+            const existing = scopeInstance[name];
+            if (!check.is(BuilderInstancesSchema, existing)) {
+                errors.scope(name, () => {
+                    errors.invalidCollection(`${namePrefix}${name}`);
+                });
+                return;
+            }
+            errors.scope(name, () => {
+                existing.forEach((itemInstance, index) => {
+                    errors.scope(index, () => {
+                        checkInstance(payload.model, itemInstance, `${namePrefix}${name}[${index}].`);
+                    });
+                });
+            });
+        });
+    }
 }

package/dist/validate/model.d.ts

@@ -1,36 +1,9 @@
 import type { BuilderModelSerialised, BuilderModelValidated, BuilderRefEntities } from '../entities/index';
-import type { BuilderErrorLocation, BuilderErrors } from '../exception';
 import type { ParamableSerialised } from '../references';
 import type { BuilderResolve } from './resolve';
 import type { ValidationResult } from './result';
+import { BuilderValidateErrors } from './errors.js';
 export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
-export declare function builderErrorDuplicateName(name: string, location?: BuilderErrorLocation): {
-    name: string;
-    kind: "duplicate-name";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorDuplicateName = ReturnType<typeof builderErrorDuplicateName>;
-export declare function builderErrorInvalidCollectionBounds(name: string, min: number, max: number, location?: BuilderErrorLocation): {
-    name: string;
-    min: number;
-    max: number;
-    kind: "invalid-collection-bounds";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidCollectionBounds = ReturnType<typeof builderErrorInvalidCollectionBounds>;
-export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
-export declare function builderErrorInvalidPath(reason: BuilderErrorInvalidPathReason, location?: BuilderErrorLocation): {
-    reason: BuilderErrorInvalidPathReason;
-    kind: "invalid-path";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidPath = ReturnType<typeof builderErrorInvalidPath>;
-export declare function builderErrorInvalidSelectMapKey(key: string, location?: BuilderErrorLocation): {
-    key: string;
-    kind: "invalid-select-map-key";
-    location: BuilderErrorLocation;
-};
-export type BuilderErrorInvalidSelectMapKey = ReturnType<typeof builderErrorInvalidSelectMapKey>;
-export declare function validateModel(input: unknown, references?: BuilderRefEntities): BuilderModelValidationResult;
-export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, model: BuilderModelSerialised, location: BuilderErrorLocation): BuilderErrors;
-export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, location: BuilderErrorLocation): BuilderModelValidationResult;
+export declare function validateModel(input: unknown, references?: BuilderRefEntities, errors?: BuilderValidateErrors): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, rootModel: BuilderModelSerialised, errors: BuilderValidateErrors): void;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, errors: BuilderValidateErrors): BuilderModelValidated;