@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/validation/engine/utils/escapeHtml.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Derived from the upstream lib/escapeHtml.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeHtml = escapeHtml;
+const namedHtml = new Map([
+    [38, '&'],
+    [60, '<'],
+    [62, '>'],
+    [34, '"'],
+    [160, ' '],
+    [162, '¢'],
+    [163, '£'],
+    [164, '¤'],
+    [169, '©'],
+    [174, '®']
+]);
+const safeCharCodes = (() => {
+    const safe = new Set();
+    for (let i = 32; i < 123; ++i) {
+        if ((i >= 97) || // a-z
+            (i >= 65 && i <= 90) || // A-Z
+            (i >= 48 && i <= 57) || // 0-9
+            i === 32 || // space
+            i === 46 || // .
+            i === 44 || // ,
+            i === 45 || // -
+            i === 58 || // :
+            i === 95) { // _
+            safe.add(i);
+        }
+    }
+    return safe;
+})();
+/**
+ * Escape a character for HTML
+ * @param charCode
+ */
+function escapeHtmlChar(charCode) {
+    const namedEscape = namedHtml.get(charCode);
+    if (namedEscape)
+        return namedEscape;
+    if (charCode >= 256)
+        return '&#' + charCode + ';';
+    const hexValue = charCode.toString(16).padStart(2, '0');
+    return `&#x${hexValue};`;
+}
+/**
+ * Escape a string for HTML
+ * @param input
+ */
+function escapeHtml(input) {
+    if (!input)
+        return '';
+    let escaped = '';
+    for (let i = 0; i < input.length; ++i) {
+        const charCode = input.charCodeAt(i);
+        escaped += safeCharCodes.has(charCode) ? input[i] : escapeHtmlChar(charCode);
+    }
+    return escaped;
+}

package/dist/cjs/lib/validation/engine/utils/escapeRegex.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derived from the upstream lib/escapeRegex.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Escape a string for use in a regular expression: ^$.*+-?=!:|\/()[]{},
+ * @param string
+ */
+export declare function escapeRegex(string: string): string;

package/dist/cjs/lib/validation/engine/utils/escapeRegex.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Derived from the upstream lib/escapeRegex.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeRegex = escapeRegex;
+/**
+ * Escape a string for use in a regular expression: ^$.*+-?=!:|\/()[]{},
+ * @param string
+ */
+function escapeRegex(string) {
+    return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&');
+}

package/dist/cjs/lib/validation/engine/utils/ignore.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derived from the upstream lib/ignore.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * A no-op function
+ * @param _args
+ */
+export declare function ignore(..._args: unknown[]): void;

package/dist/cjs/lib/validation/engine/utils/ignore.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Derived from the upstream lib/ignore.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignore = ignore;
+/**
+ * A no-op function
+ * @param _args
+ */
+function ignore(..._args) {
+}

package/dist/cjs/lib/validation/engine/utils/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Subset of the upstream used by the validation engine (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+export { applyToDefaults, type ApplyToDefaultsOptions } from './applyToDefaults.js';
+export { assert } from './assert.js';
+export { AssertError } from './assertError.js';
+export { clone, type CloneOptions, type CloneSeen } from './clone.js';
+export { deepEqual, type DeepEqualOptions } from './deepEqual.js';
+export { escapeHtml } from './escapeHtml.js';
+export { escapeRegex } from './escapeRegex.js';
+export { ignore } from './ignore.js';
+export { merge, type MergeOptions } from './merge.js';
+export { reach, type ReachChain, type ReachOptions } from './reach.js';
+export { stringify } from './stringify.js';
+export { getInternalProto, type InternalProto, Types } from './types.js';
+export { type Indexable, isArray, keys, type KeysOptions } from './utils.js';

package/dist/cjs/lib/validation/engine/utils/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = exports.isArray = exports.Types = exports.getInternalProto = exports.stringify = exports.reach = exports.merge = exports.ignore = exports.escapeRegex = exports.escapeHtml = exports.deepEqual = exports.clone = exports.AssertError = exports.assert = exports.applyToDefaults = void 0;
+/**
+ * Subset of the upstream used by the validation engine (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+var applyToDefaults_js_1 = require("./applyToDefaults.js");
+Object.defineProperty(exports, "applyToDefaults", { enumerable: true, get: function () { return applyToDefaults_js_1.applyToDefaults; } });
+var assert_js_1 = require("./assert.js");
+Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return assert_js_1.assert; } });
+var assertError_js_1 = require("./assertError.js");
+Object.defineProperty(exports, "AssertError", { enumerable: true, get: function () { return assertError_js_1.AssertError; } });
+var clone_js_1 = require("./clone.js");
+Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return clone_js_1.clone; } });
+var deepEqual_js_1 = require("./deepEqual.js");
+Object.defineProperty(exports, "deepEqual", { enumerable: true, get: function () { return deepEqual_js_1.deepEqual; } });
+var escapeHtml_js_1 = require("./escapeHtml.js");
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return escapeHtml_js_1.escapeHtml; } });
+var escapeRegex_js_1 = require("./escapeRegex.js");
+Object.defineProperty(exports, "escapeRegex", { enumerable: true, get: function () { return escapeRegex_js_1.escapeRegex; } });
+var ignore_js_1 = require("./ignore.js");
+Object.defineProperty(exports, "ignore", { enumerable: true, get: function () { return ignore_js_1.ignore; } });
+var merge_js_1 = require("./merge.js");
+Object.defineProperty(exports, "merge", { enumerable: true, get: function () { return merge_js_1.merge; } });
+var reach_js_1 = require("./reach.js");
+Object.defineProperty(exports, "reach", { enumerable: true, get: function () { return reach_js_1.reach; } });
+var stringify_js_1 = require("./stringify.js");
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return stringify_js_1.stringify; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "getInternalProto", { enumerable: true, get: function () { return types_js_1.getInternalProto; } });
+Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return types_js_1.Types; } });
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "isArray", { enumerable: true, get: function () { return utils_js_1.isArray; } });
+Object.defineProperty(exports, "keys", { enumerable: true, get: function () { return utils_js_1.keys; } });

package/dist/cjs/lib/validation/engine/utils/merge.d.ts

@@ -0,0 +1,21 @@
+export interface MergeOptions {
+    /**
+     * Override the target value with null or undefined source values, defaults to true
+     */
+    readonly nullOverride?: boolean;
+    /**
+     * Append array source values to the target array instead of replacing them, defaults to true
+     */
+    readonly mergeArrays?: boolean;
+    /**
+     * Include symbol properties, defaults to true
+     */
+    readonly symbols?: boolean;
+}
+/**
+ * Merge all the properties of source into target (target is modified)
+ * @param target
+ * @param source
+ * @param options
+ */
+export declare function merge<T1 extends object, T2 extends object>(target: T1, source: T2 | null | undefined, options?: MergeOptions): T1 & T2;

package/dist/cjs/lib/validation/engine/utils/merge.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+/**
+ * Derived from the upstream lib/merge.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const assert_js_1 = require("./assert.js");
+const clone_js_1 = require("./clone.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Merge all the properties of source into target (target is modified)
+ * @param target
+ * @param source
+ * @param options
+ */
+function merge(target, source, options) {
+    (0, assert_js_1.assert)(target && typeof target === 'object', 'Invalid target value: must be an object');
+    (0, assert_js_1.assert)(source === null || source === undefined || typeof source === 'object', 'Invalid source value: must be null, undefined, or an object');
+    if (!source)
+        return target;
+    const settings = { nullOverride: true, mergeArrays: true, ...options };
+    if ((0, utils_js_1.isArray)(source)) {
+        (0, assert_js_1.assert)((0, utils_js_1.isArray)(target), 'Cannot merge array onto an object');
+        //Must not change target assignment
+        if (!settings.mergeArrays)
+            target.length = 0;
+        for (let i = 0; i < source.length; ++i)
+            target.push((0, clone_js_1.clone)(source[i], { symbols: settings.symbols }));
+        return target;
+    }
+    const targetRecord = target;
+    const sourceRecord = source;
+    const sourceKeys = (0, utils_js_1.keys)(source, settings);
+    for (let i = 0; i < sourceKeys.length; ++i) {
+        const key = sourceKeys[i];
+        if (key === '__proto__' || !Object.prototype.propertyIsEnumerable.call(source, key))
+            continue;
+        const value = sourceRecord[key];
+        if (value && typeof value === 'object') {
+            //Can occur for shallow merges
+            if (targetRecord[key] === value)
+                continue;
+            const targetValue = targetRecord[key];
+            if (!targetValue ||
+                typeof targetValue !== 'object' ||
+                ((0, utils_js_1.isArray)(targetValue) !== (0, utils_js_1.isArray)(value)) ||
+                value instanceof Date ||
+                Buffer.isBuffer(value) ||
+                value instanceof RegExp) {
+                targetRecord[key] = (0, clone_js_1.clone)(value, { symbols: settings.symbols });
+            }
+            else {
+                merge(targetValue, value, settings);
+            }
+        }
+        else {
+            //Explicit to preserve empty strings
+            if (value !== null && value !== undefined) {
+                targetRecord[key] = value;
+            }
+            else if (settings.nullOverride) {
+                targetRecord[key] = value;
+            }
+        }
+    }
+    return target;
+}

package/dist/cjs/lib/validation/engine/utils/reach.d.ts

@@ -0,0 +1,30 @@
+export interface ReachOptions {
+    /**
+     * String to split chain path on, defaults to '.'
+     */
+    readonly separator?: string;
+    /**
+     * Value to return if the path or value is not present, defaults to undefined
+     */
+    readonly default?: unknown;
+    /**
+     * Throw an error on missing member, defaults to false
+     */
+    readonly strict?: boolean;
+    /**
+     * Allow traversing functions for properties, defaults to true (false for a missing segment)
+     */
+    readonly functions?: boolean;
+    /**
+     * Traverse Set and Map objects, defaults to false
+     */
+    readonly iterables?: boolean;
+}
+export type ReachChain = string | (string | number)[] | false | null | undefined;
+/**
+ * Convert an object to a list of properties at the given path
+ * @param obj
+ * @param chain
+ * @param options
+ */
+export declare function reach(obj: unknown, chain: ReachChain, options?: ReachOptions | string): unknown;

package/dist/cjs/lib/validation/engine/utils/reach.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reach = reach;
+/**
+ * Derived from the upstream lib/reach.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const assert_js_1 = require("./assert.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Get the iterable type of a value
+ * @param ref
+ */
+function iterables(ref) {
+    if (ref instanceof Set)
+        return 'set';
+    if (ref instanceof Map)
+        return 'map';
+    return undefined;
+}
+/**
+ * Convert an object to a list of properties at the given path
+ * @param obj
+ * @param chain
+ * @param options
+ */
+function reach(obj, chain, options) {
+    if (chain === false || chain === null || chain === undefined)
+        return obj;
+    const settings = typeof options === 'string' ? { separator: options } : options || {};
+    const isChainArray = (0, utils_js_1.isArray)(chain);
+    (0, assert_js_1.assert)(!isChainArray || !settings.separator, 'Separator option is not valid for array-based chain');
+    const path = (0, utils_js_1.isArray)(chain) ? chain : chain.split(settings.separator || '.');
+    let ref = obj;
+    for (let i = 0; i < path.length; ++i) {
+        let key = path[i];
+        const type = settings.iterables ? iterables(ref) : undefined;
+        if ((0, utils_js_1.isArray)(ref) || type === 'set') {
+            const number = Number(key);
+            //Same as upstream: a negative index on a Set reads its (missing) length, which yields NaN
+            if (Number.isInteger(number))
+                key = number < 0 ? Number(ref.length) + number : number;
+        }
+        if (!ref ||
+            typeof ref === 'function' && settings.functions === false ||
+            !type && ref[key] === undefined) {
+            (0, assert_js_1.assert)(!settings.strict || i + 1 === path.length, 'Missing segment', key, 'in reach path ', chain);
+            (0, assert_js_1.assert)(typeof ref === 'object' || settings.functions === true || typeof ref !== 'function', 'Invalid segment', key, 'in reach path ', chain);
+            ref = settings.default;
+            break;
+        }
+        if (!type) {
+            ref = ref[key];
+        }
+        else if (type === 'set') {
+            ref = [...ref][key];
+        }
+        else {
+            ref = ref.get(key);
+        }
+    }
+    return ref;
+}

package/dist/cjs/lib/validation/engine/utils/stringify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derived from the upstream lib/stringify.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * JSON.stringify() which never throws
+ * @param args
+ */
+export declare function stringify(...args: Parameters<typeof JSON.stringify>): string;

package/dist/cjs/lib/validation/engine/utils/stringify.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Derived from the upstream lib/stringify.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = stringify;
+/**
+ * JSON.stringify() which never throws
+ * @param args
+ */
+function stringify(...args) {
+    try {
+        return JSON.stringify(...args);
+    }
+    catch (err) {
+        return '[Cannot display object: ' + err.message + ']';
+    }
+}

package/dist/cjs/lib/validation/engine/utils/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Derived from the upstream lib/types.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Prototypes of the built-in object types handled by clone() and deepEqual()
+ */
+export declare const Types: {
+    readonly array: any[];
+    readonly buffer: any;
+    readonly date: Date;
+    readonly error: Error;
+    readonly generic: Object;
+    readonly map: Map<any, any>;
+    readonly promise: Promise<any>;
+    readonly regex: RegExp;
+    readonly set: Set<any>;
+    readonly url: import("url").URL;
+    readonly weakMap: WeakMap<object, any>;
+    readonly weakSet: WeakSet<object>;
+};
+export type InternalProto = (typeof Types)[keyof typeof Types];
+/**
+ * Get the built-in prototype an object is based on
+ * @param obj
+ */
+export declare function getInternalProto(obj: object): InternalProto;

package/dist/cjs/lib/validation/engine/utils/types.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Derived from the upstream lib/types.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Types = void 0;
+exports.getInternalProto = getInternalProto;
+/**
+ * Prototypes of the built-in object types handled by clone() and deepEqual()
+ */
+exports.Types = {
+    array: Array.prototype,
+    buffer: Buffer.prototype,
+    date: Date.prototype,
+    error: Error.prototype,
+    generic: Object.prototype,
+    map: Map.prototype,
+    promise: Promise.prototype,
+    regex: RegExp.prototype,
+    set: Set.prototype,
+    url: URL.prototype,
+    weakMap: WeakMap.prototype,
+    weakSet: WeakSet.prototype
+};
+const typeMap = new Map([
+    ['[object Error]', exports.Types.error],
+    ['[object Map]', exports.Types.map],
+    ['[object Promise]', exports.Types.promise],
+    ['[object Set]', exports.Types.set],
+    ['[object URL]', exports.Types.url],
+    ['[object WeakMap]', exports.Types.weakMap],
+    ['[object WeakSet]', exports.Types.weakSet]
+]);
+/**
+ * Get the built-in prototype an object is based on
+ * @param obj
+ */
+function getInternalProto(obj) {
+    if (Array.isArray(obj))
+        return exports.Types.array;
+    if (obj instanceof Buffer)
+        return exports.Types.buffer;
+    if (obj instanceof Date)
+        return exports.Types.date;
+    if (obj instanceof RegExp)
+        return exports.Types.regex;
+    if (obj instanceof Error)
+        return exports.Types.error;
+    const objName = Object.prototype.toString.call(obj);
+    return typeMap.get(objName) || exports.Types.generic;
+}

package/dist/cjs/lib/validation/engine/utils/utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Derived from the upstream lib/utils.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * An object whose properties are accessed by key
+ */
+export type Indexable = Record<PropertyKey, unknown>;
+export interface KeysOptions {
+    /**
+     * Include symbol keys, defaults to true
+     */
+    readonly symbols?: boolean;
+}
+/**
+ * Get the own keys of an object
+ * @param obj
+ * @param options
+ */
+export declare function keys(obj: object, options?: KeysOptions): (string | symbol)[];
+/**
+ * Array.isArray() narrowing to unknown[] (the built-in narrows to any[])
+ * @param value
+ */
+export declare function isArray(value: unknown): value is unknown[];

package/dist/cjs/lib/validation/engine/utils/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Derived from the upstream lib/utils.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = keys;
+exports.isArray = isArray;
+/**
+ * Get the own keys of an object
+ * @param obj
+ * @param options
+ */
+function keys(obj, options = {}) {
+    return options.symbols !== false ? Reflect.ownKeys(obj) : Object.getOwnPropertyNames(obj);
+}
+/**
+ * Array.isArray() narrowing to unknown[] (the built-in narrows to any[])
+ * @param value
+ */
+function isArray(value) {
+    return Array.isArray(value);
+}

package/dist/cjs/lib/validation/exceptions/SchemaConversionException.d.ts

@@ -0,0 +1,7 @@
+import { SchemaException } from './SchemaException.js';
+/**
+ * A schema which cannot be converted (to a JSON schema or an OpenAPI schema object)
+ */
+export declare class SchemaConversionException extends SchemaException {
+    errno: string | number;
+}

package/dist/cjs/lib/validation/exceptions/SchemaConversionException.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaConversionException = void 0;
+const SchemaException_js_1 = require("./SchemaException.js");
+/**
+ * A schema which cannot be converted (to a JSON schema or an OpenAPI schema object)
+ */
+class SchemaConversionException extends SchemaException_js_1.SchemaException {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_SCHEMA_CONVERSION';
+    }
+}
+exports.SchemaConversionException = SchemaConversionException;

package/dist/cjs/lib/validation/exceptions/SchemaDefinitionException.d.ts

@@ -0,0 +1,7 @@
+import { SchemaException } from './SchemaException.js';
+/**
+ * An invalid schema definition: invalid rule arguments, options, templates, references or key dependencies
+ */
+export declare class SchemaDefinitionException extends SchemaException {
+    errno: string | number;
+}

package/dist/cjs/lib/validation/exceptions/SchemaDefinitionException.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDefinitionException = void 0;
+const SchemaException_js_1 = require("./SchemaException.js");
+/**
+ * An invalid schema definition: invalid rule arguments, options, templates, references or key dependencies
+ */
+class SchemaDefinitionException extends SchemaException_js_1.SchemaException {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_SCHEMA_DEFINITION';
+    }
+}
+exports.SchemaDefinitionException = SchemaDefinitionException;

package/dist/cjs/lib/validation/exceptions/SchemaException.d.ts

@@ -0,0 +1,6 @@
+import { Exception } from '../../foundation/Exception.js';
+/**
+ * Base class of the errors of the validation engine
+ */
+export declare abstract class SchemaException extends Exception {
+}

package/dist/cjs/lib/validation/exceptions/SchemaException.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaException = void 0;
+const Exception_js_1 = require("../../foundation/Exception.js");
+/**
+ * Base class of the errors of the validation engine
+ */
+class SchemaException extends Exception_js_1.Exception {
+}
+exports.SchemaException = SchemaException;

package/dist/cjs/lib/validation/exceptions/SchemaValidationException.d.ts

@@ -0,0 +1,36 @@
+import type { ErrorDetail } from '../engine/schema/model.js';
+import { SchemaException } from './SchemaException.js';
+/**
+ * A value which does not match its schema (errno `E_SCHEMA_VALIDATION`, HTTP 400). The validation engine creates it;
+ * `DTO.validate()` and `DTO.validateAsync()` throw an `InvalidValueException` (`E_INVALID_VALUE`) whose `cause` is
+ * this exception, with the details of the errors.
+ */
+export declare class SchemaValidationException extends SchemaException {
+    errno: string | number;
+    readonly statusCode: number;
+    /**
+     * The validation errors, one per failed rule (only the first one unless the `abortEarly` option is false): the
+     * message, the path of the invalid value, the error code (`type`, like `string.min`) and the context of the
+     * message.
+     */
+    details: ErrorDetail[];
+    /**
+     * The value as it was given to the validation.
+     */
+    _original: unknown;
+    constructor(message: string, details: ErrorDetail[], original: unknown);
+    /**
+     * Render the validated value as JSON with each error marked at its place, followed by the list of the error
+     * messages; a value which is not an object renders as the first error message.
+     * @param stripColorCodes Whether to leave out the ANSI color codes (red) marking the errors, for logs and files.
+     * Defaults to false (colored).
+     * @returns The annotated value, for the terminal or a log.
+     */
+    annotate(stripColorCodes?: boolean): string;
+    /**
+     * Whether an error is a schema validation exception.
+     * @param err The error to test, like the `cause` of an `InvalidValueException`.
+     * @returns True for a `SchemaValidationException` (a subclass included).
+     */
+    static isError(err: unknown): err is SchemaValidationException;
+}

package/dist/cjs/lib/validation/exceptions/SchemaValidationException.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidationException = void 0;
+const annotate_js_1 = require("../engine/schema/annotate.js");
+const SchemaException_js_1 = require("./SchemaException.js");
+/**
+ * A value which does not match its schema (errno `E_SCHEMA_VALIDATION`, HTTP 400). The validation engine creates it;
+ * `DTO.validate()` and `DTO.validateAsync()` throw an `InvalidValueException` (`E_INVALID_VALUE`) whose `cause` is
+ * this exception, with the details of the errors.
+ */
+class SchemaValidationException extends SchemaException_js_1.SchemaException {
+    constructor(message, details, original) {
+        super(message);
+        this.errno = 'E_SCHEMA_VALIDATION';
+        this.statusCode = 400;
+        //The base class replaces an empty message with the name of the exception
+        if (this.message !== message) {
+            this.message = message;
+            this.errMsg = message;
+        }
+        this._original = original;
+        this.details = details;
+    }
+    /**
+     * Render the validated value as JSON with each error marked at its place, followed by the list of the error
+     * messages; a value which is not an object renders as the first error message.
+     * @param stripColorCodes Whether to leave out the ANSI color codes (red) marking the errors, for logs and files.
+     * Defaults to false (colored).
+     * @returns The annotated value, for the terminal or a log.
+     */
+    annotate(stripColorCodes) {
+        return annotate_js_1.error.call(this, stripColorCodes);
+    }
+    /**
+     * Whether an error is a schema validation exception.
+     * @param err The error to test, like the `cause` of an `InvalidValueException`.
+     * @returns True for a `SchemaValidationException` (a subclass included).
+     */
+    static isError(err) {
+        return err instanceof SchemaValidationException;
+    }
+}
+exports.SchemaValidationException = SchemaValidationException;