xdbc 1.0.217 → 1.0.218

package/dist/DBC/EQ/DIFFERENT.js

@@ -0,0 +1,34 @@
+import { EQ } from "../EQ";
+/**
+ * DIFFERENT class for inequality comparisons.
+ *
+ * This class extends EQ and provides methods to check if a value is different (not equal)
+ * from a specified equivalent value. It inverts the equality check by always passing
+ * `true` for the invert parameter to the parent EQ class methods.
+ *
+ * @remarks
+ * The class provides precondition (PRE), postcondition (POST), and invariant (INVARIANT)
+ * checks for Design by Contract programming patterns.
+ *
+ * @see {@link COMPARISON}
+ * @see {@link EQ}
+ */
+export class DIFFERENT extends EQ {
+    /** See {@link EQ.PRE }. Always inverts equality check. */
+    static PRE(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.PRE(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.POST }. Always inverts equality check. */
+    static POST(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.POST(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.INVARIANT }. Always inverts equality check. */
+    static INVARIANT(equivalent, _invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return EQ.INVARIANT(equivalent, true, path, hint, dbc);
+    }
+    /** See {@link EQ.constructor }. */
+    constructor(equivalent) {
+        super(equivalent, true);
+        this.equivalent = equivalent;
+    }
+}

package/dist/DBC/EQ.js

@@ -0,0 +1,101 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that two {@link object }s gotta be equal.
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class EQ extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks if the value **toCheck** is equal to the specified **equivalent**.
+     *
+     * @param toCheck		The value that has to be equal to it's possible **equivalent** for this {@link DBC } to be fulfilled.
+     * @param equivalent	The {@link object } the one **toCheck** has to be equal to in order for this {@link DBC } to be
+     * 						fulfilled.
+     *
+     * @returns TRUE if the value **toCheck** and the **equivalent** are equal to each other, otherwise FALSE. */
+    static checkAlgorithm(toCheck, equivalent, invert) {
+        if (!invert && equivalent !== toCheck) {
+            return `Value has to be equal to "${equivalent}"`;
+        }
+        if (invert && equivalent === toCheck) {
+            return `Value must not be equal to "${equivalent}"`;
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decPrecondition }.
+     * @param dbc			See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPRE(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.Postcondition }.
+     * @param dbc			See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPOST(EQ.checkAlgorithm, [equivalent, invert], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link EQ.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param equivalent	See {@link EQ.checkAlgorithm }.
+     * @param path			See {@link DBC.decInvariant }.
+     * @param dbc			See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(equivalent, invert = false, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(EQ, [equivalent, invert], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck**, {@link EQ.equivalent } and {@link EQ.invert }.
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck) {
+        return EQ.checkAlgorithm(toCheck, this.equivalent, this.invert);
+    }
+    /**
+     * Invokes the {@link EQ.checkAlgorithm } passing the value **toCheck** and the specified **type** .
+     *
+     * @param toCheck See {@link EQ.checkAlgorithm }.
+     *
+     * @returns The **CANDIDATE** **toCheck** doesn't fulfill this {@link EQ }.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link EQ }.*/
+    static tsCheck(toCheck, equivalent, hint = undefined, id = undefined, dbc = undefined) {
+        const result = EQ.checkAlgorithm(toCheck, equivalent, false);
+        if (result === true) {
+            return toCheck;
+        }
+        DBC.reportTsCheckInfringement(`${id ? `(${id}) ` : ""}${result} ${hint ? `✨ ${hint} ✨` : ""}`, dbc);
+        return toCheck;
+    }
+    /**
+     * Creates this {@link EQ } by setting the protected property {@link EQ.equivalent } used by {@link EQ.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(equivalent, invert = false) {
+        super();
+        this.equivalent = equivalent;
+        this.invert = invert;
+    }
+}

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);
+        }
+    }
+}