xdbc 1.0.217 → 1.0.219

package/dist/DBC/HasAttribute.js

@@ -0,0 +1,101 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that a {@link HTMLElement } gotta have a certain attribute set.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class HasAttribute extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the {@link HTMLElement } **toCheck** has the attribute **toCheckFor**.
+     *
+     * @param toCheckFor  name of the attribute to check for whether it is set or not.
+     *
+     * @returns TRUE if the {@link HTMLElement } **toCheck** has set the attribute **toCheckFor**,
+     * 			otherwise a proper errormessage. */
+    static checkAlgorithm(toCheck, toCheckFor, invert) {
+        if (!(toCheck instanceof HTMLElement)) {
+            return `The object to check for whether it has the attribute "${toCheckFor}" is not a HTMLElement. It is of type "${typeof toCheck}".`;
+        }
+        if (!invert && !toCheck.hasAttribute(toCheckFor)) {
+            return `Required Attribute "${toCheckFor}" is not set.`;
+        }
+        if (invert && toCheck.hasAttribute(toCheckFor)) {
+            return `Forbidden Attribute "${toCheckFor}" is set.`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link HasAttribute.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param toCheckFor	See {@link HasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(toCheckFor, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createPRE(HasAttribute.checkAlgorithm, [toCheckFor, invert], dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link HasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged method's returnvalue.
+     *
+     * @param toCheckFor	See {@link HasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(toCheckFor, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createPOST(HasAttribute.checkAlgorithm, [toCheckFor, invert], dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link hasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged field.
+     *
+     * @param toCheckFor	See {@link hasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(toCheckFor, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createINVARIANT(HasAttribute, [toCheckFor, invert], dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link hasAttribute.checkAlgorithm } to determine whether this {@link DBC } is
+     * fulfilled by the tagged field's class instance.
+     *
+     * @param toCheckFor	See {@link hasAttribute.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static cINVARIANT(toCheckFor, invert = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.decClassInvariant([new HasAttribute(toCheckFor, invert)], path, dbc);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link hasAttribute.checkAlgorithm } passing the value **toCheck**, {@link hasAttribute.equivalent } and
+     * {@link hasAttribute.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck) {
+        return HasAttribute.checkAlgorithm(toCheck, this.toCheckFor, this.invert);
+    }
+    /**
+     * Creates this {@link DBC } by setting the protected property {@link hasAttribute.equivalent } used by
+     * {@link hasAttribute.check }.
+     *
+     * @param toCheckFor See {@link hasAttribute.check }. */
+    constructor(toCheckFor, invert = false) {
+        super();
+        this.toCheckFor = toCheckFor;
+        this.invert = invert;
+    }
+}

package/dist/DBC/IF.js

@@ -0,0 +1,96 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that an {@link object } has also to comply to a certain {@link DBC } if it complies to
+ * another specified one.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class IF extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the value **toCheck** complies to the specified **condition** and if so does also comply to the one **inCase**.
+     *
+     * @param toCheck	The value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.
+     * @param condition	The contract **toCheck** has to comply to in order to also have to comply to the one **inCase**.
+     * @param inCase	The contract **toCheck** has to also comply to if it complies to **condition**.
+     *
+     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(toCheck, condition, inCase, invert = false) {
+        if (toCheck === undefined || toCheck === null)
+            return true;
+        if (invert &&
+            condition.check(toCheck) !== true &&
+            inCase.check(toCheck) !== true) {
+            return "In case that the value does not comply to the condition, it also has to comply to the required contract";
+        }
+        if (!invert &&
+            condition.check(toCheck) === true &&
+            inCase.check(toCheck) !== true) {
+            return "In case that the value complies to the condition, it has to comply to the required contract";
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path		See {@link DBC.decPrecondition }.
+     * @param dbc		See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(condition, inCase, path = undefined, invert = false, hint = undefined, dbc = undefined) {
+        return DBC.createPRE(IF.checkAlgorithm, [condition, inCase, invert], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link IF.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path		See {@link DBC.Postcondition }.
+     * @param dbc		See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(condition, inCase, path = undefined, invert = false, hint = undefined, dbc = undefined) {
+        return DBC.createPOST(IF.checkAlgorithm, [condition, inCase, invert], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link IF.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param condition	See {@link IF.checkAlgorithm }.
+     * @param inCase	See {@link IF.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(condition, inCase, path = undefined, invert = false, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(IF, [condition, inCase, invert], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link IF.checkAlgorithm } passing the value **toCheck**, {@link IF.equivalent } and {@link IF.invert }.
+     *
+     * @param toCheck See {@link IF.checkAlgorithm }.
+     *
+     * @returns See {@link IF.checkAlgorithm}. */
+    check(toCheck) {
+        return IF.checkAlgorithm(toCheck, this.condition, this.inCase, this.invert);
+    }
+    /**
+     * Creates this {@link IF } by setting the protected property {@link IF.equivalent } used by {@link IF.check }.
+     *
+     * @param equivalent See {@link IF.check }. */
+    constructor(condition, inCase, invert = false) {
+        super();
+        this.condition = condition;
+        this.inCase = inCase;
+        this.invert = invert;
+    }
+}

package/dist/DBC/INSTANCE.js

@@ -0,0 +1,122 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that the an {@link object }s gotta be an instance of a certain {@link INSTANCE.reference }.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+export class INSTANCE extends DBC {
+    /**
+     * Checks if the value **toCheck** is an instance of the specified **reference**.
+     *
+     * @param toCheck	The value that has to be an instance of the **reference** in order for this {@link DBC }
+     * 					to be fulfilled.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     *
+     * @returns TRUE if the value **toCheck** is is an instance of the *reference**, **undefined** or **null**, otherwise FALSE. */
+    static checkAlgorithm(toCheck, ...references) {
+        if (toCheck === null || toCheck === undefined) {
+            return true;
+        }
+        for (const ref of references) {
+            if (toCheck instanceof ref) {
+                return true;
+            }
+        }
+        return `Value has to be an instance of "${references.map((ref) => ref.name || ref).join(", ")}" but is of type "${typeof toCheck}"`;
+    }
+    /**
+     * A parameter-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(reference, path = undefined, hint = undefined, dbc = undefined) {
+        const refs = Array.isArray(reference) ? reference : [reference];
+        return DBC.createPRE(INSTANCE.checkAlgorithm, refs, dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.Postcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(reference, path = undefined, hint = undefined, dbc = undefined) {
+        const refs = Array.isArray(reference) ? reference : [reference];
+        return DBC.createPOST(INSTANCE.checkAlgorithm, refs, dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link INSTANCE.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param path	See {@link DBC.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(reference, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(INSTANCE, [reference], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck See {@link INSTANCE.checkAlgorithm }.
+     *
+     * @returns See {@link INSTANCE.checkAlgorithm}. */
+    check(toCheck) {
+        return Array.isArray(this.reference)
+            ? INSTANCE.checkAlgorithm(toCheck, ...this.reference)
+            : INSTANCE.checkAlgorithm(toCheck, this.reference);
+    }
+    /**
+     * Type-safe check that validates if a value is an instance of a specified reference.
+     *
+     * @param toCheck 	The value to check for instance validity.
+     * @param reference	The {@link object } the one **toCheck** has to be an instance of.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** if it fulfills this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link INSTANCE }. */
+    static tsCheck(toCheck, reference, hint = undefined, id = undefined, dbc = undefined) {
+        return INSTANCE.tsCheckMulti(toCheck, [reference], hint, id, dbc);
+    }
+    /**
+     * Invokes the {@link INSTANCE.checkAlgorithm } passing the value **toCheck** and the {@link INSTANCE.reference } .
+     *
+     * @param toCheck 	See {@link INSTANCE.checkAlgorithm }.
+     * @param reference	See {@link INSTANCE.checkAlgorithm }.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link INSTANCE } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link INSTANCE }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link DEFINED }. */
+    static tsCheckMulti(toCheck, references, hint = undefined, id = undefined, dbc = undefined) {
+        const result = INSTANCE.checkAlgorithm(toCheck, ...references);
+        if (result === true) {
+            return toCheck;
+        }
+        DBC.reportTsCheckInfringement(`${id ? `(${id}) ` : ""}${result} ${hint ? `✨ ${hint} ✨` : ""}`, dbc);
+        return toCheck;
+    }
+    /**
+     * Creates this {@link INSTANCE } by setting the protected property {@link INSTANCE.reference } used by {@link INSTANCE.check }.
+     *
+     * @param reference See {@link INSTANCE.check }. */
+    constructor(reference) {
+        super();
+        this.reference = reference;
+    }
+}

package/dist/DBC/JSON.OP.js

@@ -0,0 +1,120 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } demanding that an {@link object } has specific properties of specific types.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class JSON_OP extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the object **toCheck** has the **necessaryProperties** of necessary type.
+     *
+     * @param toCheck				The {@link object } to check for the necessary properties.
+     * @param necessaryProperties	The **{ name : string, type : string }**s defining the properties and type the {@link object } to
+     * 								check needs to have.
+     * @param checkElements			Indicates if **toCheck** is an iterable object of which all elements have to be checked.
+     * 								Elements will only be checked if **toCheck** is iterable, otherwise **toCheck** itself
+     * 								will be checked.
+     *
+     * @returns TRUE if the value **toCheck** or it's elements, if **checkElements** is TRUE, has all **necessaryProperties**, otherwise a {@link string } to report the infringement. */
+    static checkAlgorithm(toCheck, necessaryProperties, checkElements) {
+        if (toCheck === undefined || toCheck === null) {
+            return `[ UNDEFINED or NULL received instead of object with following properties: ${JSON.stringify(necessaryProperties)} ]`;
+        }
+        for (const property of necessaryProperties)
+            if (checkElements && typeof toCheck[Symbol.iterator] === "function") {
+                for (const element of toCheck) {
+                    if (
+                    // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+                    !element.hasOwnProperty(property.name) ||
+                        typeof element[property.name] !== property.type) {
+                        return `[ Object "${JSON.stringify(element)}" in Array "${JSON.stringify(toCheck)}" does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+                    }
+                }
+            }
+            else {
+                if (
+                // biome-ignore lint/suspicious/noPrototypeBuiltins: <explanation>
+                !toCheck.hasOwnProperty(property.name) ||
+                    typeof toCheck[property.name] !== property.type) {
+                    return `[ Object does not contain the necessary property "${property.name}" of type "${property.type}"]`;
+                }
+            }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(necessaryProperties, checkElements = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createPRE(JSON_OP.checkAlgorithm, [necessaryProperties, checkElements], dbc, path);
+    }
+    /**
+     * A method-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(necessaryProperties, checkElements = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createPOST(JSON_OP.checkAlgorithm, [necessaryProperties, checkElements], dbc, path);
+    }
+    /**
+     * A field-decorator factory using the {@link JSON_OP.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static INVARIANT(necessaryProperties, checkElements = false, path = undefined, dbc = "WaXCode.DBC") {
+        return DBC.createINVARIANT(JSON_OP, [necessaryProperties, checkElements], dbc, path);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link JSON_OP.checkAlgorithm } passing the value **toCheck**, {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+     *
+     * @param toCheck See {@link JSON_OP.checkAlgorithm }.
+     *
+     * @returns See {@link JSON_OP.checkAlgorithm}. */
+    check(toCheck) {
+        return JSON_OP.checkAlgorithm(toCheck, this.necessaryProperties, this.checkElements);
+    }
+    /**
+     * Creates this {@link JSON_OP } by setting the protected property {@link JSON_OP.necessaryProperties } and {@link checkElements } used by {@link JSON_OP.check }.
+     *
+     * @param necessaryProperties	See {@link JSON_OP.check }.
+     * @param checkElements 		See {@link JSON_OP.check }. */
+    constructor(necessaryProperties, checkElements = false) {
+        super();
+        this.necessaryProperties = necessaryProperties;
+        this.checkElements = checkElements;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link JSON_OP.checkAlgorithm } passing the value **toCheck**, {@link JSON_OP.necessaryProperties } and {@link JSON_OP.checkElements }.
+     *
+     * @param toCheck				See {@link JSON_OP.checkAlgorithm} }.
+     * @param necessaryProperties	See {@link JSON_OP.checkAlgorithm} }.
+     * @param checkElements			See {@link JSON_OP.checkAlgorithm} }.
+     */
+    static check(toCheck, necessaryProperties, checkElements = false, dbc = undefined) {
+        const checkResult = JSON_OP.checkAlgorithm(toCheck, necessaryProperties, checkElements);
+        if (typeof checkResult === "string") {
+            DBC.reportTsCheckInfringement(checkResult, dbc);
+        }
+    }
+}

package/dist/DBC/JSON.Parse.js

@@ -0,0 +1,104 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } demanding that a {@link string } is {@link JSON.parse}able.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class JSON_Parse extends DBC {
+    // #region Condition checking.
+    /**
+     * Tries to {@link JSON.parse } the {@link string } **toCheck** invoking the **receptor** with the result, if so.
+     *
+     * @param toCheck	The {@link string } to be {@link JSON.parse }d.
+     * @param receptor	The **( json : object ) => void** to receive the {@link JSON.parse }d {@link string } **toCheck**.
+     * 					check needs to have.
+     *
+     * @returns TRUE if the value **toCheck** is a valid JSON, otherwise a {@link string } to report the infringement. */
+    static checkAlgorithm(toCheck, receptor) {
+        let parsed;
+        try {
+            parsed = JSON.parse(toCheck);
+        }
+        catch (X) {
+            return `[ Following string is not a valid JSON: ${toCheck}]`;
+        }
+        if (receptor) {
+            receptor(parsed);
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link JSON_Parse.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param receptor	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(receptor, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPRE(JSON_Parse.checkAlgorithm, [receptor], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link JSON_Parse.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(receptor, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPOST(JSON_Parse.checkAlgorithm, [receptor], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link JSON_Parse.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param expression	See {@link JSON.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(receptor, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(JSON_Parse, [receptor], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link JSON_Parse.checkAlgorithm } passing the value **toCheck** and {@link JSON_Parse.receptor }.
+     *
+     * @param toCheck See {@link JSON_Parse.checkAlgorithm }.
+     *
+     * @returns See {@link JSON_Parse.checkAlgorithm}. */
+    check(toCheck) {
+        return JSON_Parse.checkAlgorithm(toCheck, this.receptor);
+    }
+    /**
+     * Creates this {@link JSON_Parse } by setting the protected property {@link JSON_Parse.necessaryProperties } and {@link checkElements } used by {@link JSON_Parse.check }.
+     *
+     * @param necessaryProperties	See {@link JSON_Parse.check }.
+     * @param checkElements 		See {@link JSON_Parse.check }. */
+    constructor(receptor = undefined) {
+        super();
+        this.receptor = receptor;
+    }
+    // #endregion Referenced Condition checking.
+    // #region In-Method checking.
+    /**
+     * Invokes the {@link JSON_Parse.checkAlgorithm } passing the value **toCheck**, {@link JSON_Parse.necessaryProperties } and {@link JSON_Parse.checkElements }.
+     *
+     * @param toCheck				See {@link JSON_Parse.checkAlgorithm} }.
+     * @param necessaryProperties	See {@link JSON_Parse.checkAlgorithm} }.
+     * @param checkElements			See {@link JSON_Parse.checkAlgorithm} }.
+     */
+    static check(toCheck, receptor, dbc = undefined) {
+        const checkResult = JSON_Parse.checkAlgorithm(toCheck, receptor);
+        if (typeof checkResult === "string") {
+            DBC.reportTsCheckInfringement(checkResult, dbc);
+        }
+    }
+}

package/dist/DBC/OR.js

@@ -0,0 +1,125 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that all elements of an {@link object }s have to fulfill
+ * one of the given {@link object }s check-methods (**( toCheck : any ) => boolean | string** ).
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class OR extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks the **value** against the given **conditions**
+     *
+     * @param conditions	The **{ check: (toCheck: any) => boolean | string }**-{@link object }s to check the **value** against.
+     * @param value			Either **value**-{@link Array < any >}, which's elements will be checked, or the value to be
+     * 						checked itself.
+     * @param index			If specified with "idxEnd" being undefined, this {@link Number } will be seen as the index of
+     * 						the value-{@link Array }'s element to check. If value isn't an {@link Array } this parameter
+     * 						will not have any effect.
+     * 						With "idxEnd" not undefined this parameter indicates the beginning of the span of elements to
+     * 						check within the value-{@link Array }.
+     * @param idxEnd		Indicates the last element's index (including) of the span of value-{@link Array } elements to check.
+     * 						Setting this parameter to -1 specifies that all value-{@link Array }'s elements beginning from the
+     * 						specified **index** shall be checked.
+     *
+     * @returns TRUE if at least one of the provided **conditions** is fulfilled, otherwise a {@link string } containing all **conditions** returned {@link string }s separated by " || ". */
+    static checkAlgorithm(conditions, value) {
+        let result = "";
+        for (let i = 0; i < conditions.length; i++) {
+            const conditionResult = conditions[i].check(value);
+            if (typeof conditionResult === "string") {
+                result += `${conditionResult}${i === conditions.length - 1 ? "" : " or "}`;
+            }
+            else {
+                return true;
+            }
+        }
+        return result;
+    }
+    /**
+     * A parameter-decorator factory using the {@link OR.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged parameter-value against with.
+     * When specifying an **index** and the tagged parameter's **value** is an {@link Array }, the **realConditions** apply to the
+     * element at the specified **index**.
+     * If the {@link Array } is too short the currently processed { check: (toCheck: any) => boolean | string } of
+     * **realConditions** will be verified to TRUE automatically, considering optional parameters.
+     * If an **index** is specified but the tagged parameter's value isn't an array, the **index** is treated as being undefined.
+     * If **index** is undefined and the tagged parameter's value is an {@link Array } each element of it will be checked
+     * against the **realConditions**.
+     *
+     * @param realConditions	Either one or more **{ check: (toCheck: any) => boolean | string }** to check the tagged parameter-value
+     * 							against with.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one { check: (toCheck: any) => boolean | string } of **realConditions** returns one.
+     * 			Otherwise TRUE. */
+    static PRE(conditions, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.decPrecondition((value) => OR.checkAlgorithm(conditions, value), dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link OR.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged method's return-value against with.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param dbc				See {@link DBC.decPrecondition }.
+     *
+     * @returns	A {@link string } as soon as one **{ check: (toCheck: any) => boolean | string }** of **realConditions** return one.
+     * 			Otherwise TRUE. */
+    static POST(conditions, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.decPostcondition((value) => OR.checkAlgorithm(conditions, value), dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link OR.checkAlgorithm } with either multiple or a single one
+     * of the **realConditions** to check the tagged field.
+     *
+     * @param realConditions	Either one or more { check: (toCheck: any) => boolean | string } to check the tagged parameter-value
+     * 							against with.
+     * @param path				See {@link DBC.decInvariant }.
+     * @param dbc				See {@link DBC.decInvariant }.
+     *
+     * @returns	See {@link DBC.decInvariant }. */
+    static INVARIANT(conditions, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(OR, [conditions], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like global functions).
+    //
+    /**
+     * Invokes the {@link OR.checkAlgorithm } passing the value **toCheck** and {@link OR.conditions }.
+     *
+     * @param toCheck See {@link OR.checkAlgorithm }.
+     *
+     * @returns See {@link OR.checkAlgorithm}. */
+    check(toCheck) {
+        return OR.checkAlgorithm(this.conditions, toCheck);
+    }
+    /**
+     * Invokes the {@link OR.checkAlgorithm } passing the value **toCheck** and the {@link OR.type } .
+     *
+     * @param toCheck See {@link OR.checkAlgorithm }.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link OR }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link OR }.*/
+    static tsCheck(toCheck, conditions, hint = undefined, id = undefined, dbc = undefined) {
+        const result = OR.checkAlgorithm(conditions, toCheck);
+        if (result === true) {
+            return toCheck;
+        }
+        DBC.reportTsCheckInfringement(`${id ? `(${id}) ` : ""}${result}${hint ? ` ✨ ${hint} ✨` : ""}`, dbc);
+        return toCheck;
+    }
+    /**
+     * Creates this {@link OR } by setting the protected property {@link OR.conditions } used by {@link OR.check }.
+     *
+     * @param conditions See {@link OR.check }. */
+    constructor(conditions) {
+        super();
+        this.conditions = conditions;
+    }
+}