xdbc 1.0.217 → 1.0.218

package/__tests__/DBC/onInfringement.test.ts

@@ -0,0 +1,262 @@
+import "reflect-metadata";
+import { DBC } from "../../src/DBC";
+import { TYPE } from "../../src/DBC/TYPE";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+type InfringementCallback = (
+	infringement: InstanceType<typeof DBC.Infringement>,
+	context: {
+		type: "precondition" | "postcondition" | "invariant";
+		value: unknown;
+	},
+) => void;
+
+function makeDbcWithSpy(throwException = false): {
+	dbc: DBC;
+	spy: jest.MockedFunction<InfringementCallback>;
+} {
+	const spy = jest.fn<void, Parameters<InfringementCallback>>();
+	const dbc = new DBC({
+		throwException,
+		logToConsole: false,
+		onInfringement: spy,
+	});
+	return { dbc, spy };
+}
+
+// ─── reportParameterInfringement ─────────────────────────────────────────────
+
+describe("onInfringement — reportParameterInfringement", () => {
+	test("calls callback with a DBC.Infringement instance", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportParameterInfringement(
+			"must be a string",
+			{},
+			undefined,
+			"myMethod",
+			0,
+			42,
+		);
+		expect(spy).toHaveBeenCalledTimes(1);
+		expect(spy.mock.calls[0][0]).toBeInstanceOf(DBC.Infringement);
+	});
+
+	test("context.type is 'precondition'", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportParameterInfringement(
+			"must be a string",
+			{},
+			undefined,
+			"myMethod",
+			0,
+			42,
+		);
+		expect(spy.mock.calls[0][1].type).toBe("precondition");
+	});
+
+	test("context.value reflects the violating argument", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportParameterInfringement(
+			"must be a string",
+			{},
+			undefined,
+			"myMethod",
+			0,
+			42,
+		);
+		expect(spy.mock.calls[0][1].value).toBe(42);
+	});
+
+	test("callback is invoked before the exception is thrown", () => {
+		const order: string[] = [];
+		const spy = jest.fn(() => order.push("callback"));
+		const dbc = new DBC({
+			throwException: true,
+			logToConsole: false,
+			onInfringement: spy,
+		});
+		try {
+			dbc.reportParameterInfringement("msg", {}, undefined, "m", 0, null);
+		} catch {
+			order.push("throw");
+		}
+		expect(order).toEqual(["callback", "throw"]);
+	});
+
+	test("thrown error is a DBC.Infringement", () => {
+		const { dbc } = makeDbcWithSpy(true);
+		expect(() =>
+			dbc.reportParameterInfringement("msg", {}, undefined, "m", 0, undefined),
+		).toThrow(DBC.Infringement);
+	});
+
+	test("callback is not called when throwException is true and no infringement", () => {
+		const { spy } = makeDbcWithSpy(true);
+		// No call made — spy must stay silent
+		expect(spy).not.toHaveBeenCalled();
+	});
+});
+
+// ─── reportFieldInfringement ──────────────────────────────────────────────────
+
+describe("onInfringement — reportFieldInfringement", () => {
+	test("calls callback with a DBC.Infringement instance", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportFieldInfringement("must be positive", {}, undefined, "count", -1);
+		expect(spy).toHaveBeenCalledTimes(1);
+		expect(spy.mock.calls[0][0]).toBeInstanceOf(DBC.Infringement);
+	});
+
+	test("context.type is 'invariant'", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportFieldInfringement("must be positive", {}, undefined, "count", -1);
+		expect(spy.mock.calls[0][1].type).toBe("invariant");
+	});
+
+	test("context.value reflects the violating field value", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportFieldInfringement("must be positive", {}, undefined, "count", -1);
+		expect(spy.mock.calls[0][1].value).toBe(-1);
+	});
+});
+
+// ─── reportReturnvalueInfringement ───────────────────────────────────────────
+
+describe("onInfringement — reportReturnvalueInfringement", () => {
+	test("calls callback with a DBC.Infringement instance", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportReturnvalueInfringement(
+			"must not be null",
+			{},
+			undefined,
+			"getUser",
+			null,
+		);
+		expect(spy).toHaveBeenCalledTimes(1);
+		expect(spy.mock.calls[0][0]).toBeInstanceOf(DBC.Infringement);
+	});
+
+	test("context.type is 'postcondition'", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportReturnvalueInfringement(
+			"must not be null",
+			{},
+			undefined,
+			"getUser",
+			null,
+		);
+		expect(spy.mock.calls[0][1].type).toBe("postcondition");
+	});
+
+	test("context.value reflects the violating return value", () => {
+		const { dbc, spy } = makeDbcWithSpy();
+		dbc.reportReturnvalueInfringement(
+			"must not be null",
+			{},
+			undefined,
+			"getUser",
+			null,
+		);
+		expect(spy.mock.calls[0][1].value).toBeNull();
+	});
+});
+
+// ─── reportTsCheckInfringement ───────────────────────────────────────────────
+
+describe("onInfringement — reportTsCheckInfringement", () => {
+	test("calls callback with a DBC.Infringement instance and precondition context", () => {
+		const spy = jest.fn<void, Parameters<InfringementCallback>>();
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = false;
+			dbc.infringementSettings.onInfringement = spy;
+			DBC.reportTsCheckInfringement("value must be > 0", undefined, -5);
+		});
+		expect(spy).toHaveBeenCalledTimes(1);
+		expect(spy.mock.calls[0][0]).toBeInstanceOf(DBC.Infringement);
+		expect(spy.mock.calls[0][1].type).toBe("precondition");
+	});
+
+	test("context.value is the value passed to reportTsCheckInfringement", () => {
+		const spy = jest.fn<void, Parameters<InfringementCallback>>();
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = false;
+			dbc.infringementSettings.onInfringement = spy;
+			DBC.reportTsCheckInfringement("msg", undefined, "badValue");
+		});
+		expect(spy.mock.calls[0][1].value).toBe("badValue");
+	});
+
+	test("throws DBC.Infringement even when no instance is registered", () => {
+		expect(() =>
+			DBC.reportTsCheckInfringement("msg", "XDBC.NonExistent.Path"),
+		).toThrow(DBC.Infringement);
+	});
+
+	test("callback is called before exception is thrown", () => {
+		const order: string[] = [];
+		const spy = jest.fn(() => order.push("callback"));
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = true;
+			dbc.infringementSettings.onInfringement = spy;
+			try {
+				DBC.reportTsCheckInfringement("msg");
+			} catch {
+				order.push("throw");
+			}
+		});
+		expect(order).toEqual(["callback", "throw"]);
+	});
+});
+
+// ─── Decorator integration ────────────────────────────────────────────────────
+//
+// Each test calls makeTypedSubject() to create a fresh class whose decorator closures
+// have an un-cached dbcInstance. That way DBC.isolated()'s registered instance is
+// always picked up on the first (and only) call within that block.
+//
+
+function makeTypedSubject() {
+	class Subject {
+		@DBC.ParamvalueProvider
+		public typed(@TYPE.PRE("string") value: unknown): unknown {
+			return value;
+		}
+	}
+	return new Subject();
+}
+
+describe("onInfringement — decorator integration", () => {
+	test("onInfringement is called via @TYPE.PRE infringement (precondition)", () => {
+		const spy = jest.fn<void, Parameters<InfringementCallback>>();
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = false;
+			dbc.infringementSettings.onInfringement = spy;
+			makeTypedSubject().typed(99);
+		});
+		expect(spy).toHaveBeenCalledTimes(1);
+		expect(spy.mock.calls[0][0]).toBeInstanceOf(DBC.Infringement);
+		expect(spy.mock.calls[0][1].type).toBe("precondition");
+		expect(spy.mock.calls[0][1].value).toBe(99);
+	});
+
+	test("onInfringement is not called when contract is satisfied", () => {
+		const spy = jest.fn<void, Parameters<InfringementCallback>>();
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = false;
+			dbc.infringementSettings.onInfringement = spy;
+			makeTypedSubject().typed("valid");
+		});
+		expect(spy).not.toHaveBeenCalled();
+	});
+
+	test("the Infringement message contains the raw message text", () => {
+		const spy = jest.fn<void, Parameters<InfringementCallback>>();
+		DBC.isolated((dbc) => {
+			dbc.infringementSettings.throwException = false;
+			dbc.infringementSettings.onInfringement = spy;
+			makeTypedSubject().typed(true);
+		});
+		expect(spy.mock.calls[0][0].message).toContain("XDBC Infringement");
+	});
+});

package/biome.json

@@ -1,40 +1,40 @@
-{
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-	"vcs": {
-		"enabled": false,
-		"clientKind": "git",
-		"useIgnoreFile": false
-	},
-	"files": {
-		"ignoreUnknown": false,
-		"ignore": ["dist/**", "node_modules/**", "docs/**", "coverage/**"]
-	},
-	"formatter": {
-		"enabled": true,
-		"indentStyle": "tab"
-	},
-	"organizeImports": {
-		"enabled": true
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true,
-			"suspicious": {
-				"noExplicitAny": "off",
-				"useValidTypeof": "off"
-			},
-			"style": {
-				"noNonNullAssertion": "off"
-			}
-		}
-	},
-	"javascript": {
-		"parser": {
-			"unsafeParameterDecoratorsEnabled": true
-		},
-		"formatter": {
-			"quoteStyle": "double"
-		}
-	}
-}
+{
+	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+	"vcs": {
+		"enabled": false,
+		"clientKind": "git",
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false,
+		"ignore": ["dist/**", "node_modules/**", "docs/**", "coverage/**"]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"organizeImports": {
+		"enabled": true
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"suspicious": {
+				"noExplicitAny": "off",
+				"useValidTypeof": "off"
+			},
+			"style": {
+				"noNonNullAssertion": "off"
+			}
+		}
+	},
+	"javascript": {
+		"parser": {
+			"unsafeParameterDecoratorsEnabled": true
+		},
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	}
+}

package/dist/DBC/AE.js

@@ -0,0 +1,172 @@
+import { DBC } from "../DBC";
+/**
+ * A {@link DBC } defining that all elements of an {@link object }s have to fulfill
+ * a given {@link object }'s check-method (**( toCheck : any ) => boolean | string**).
+ *
+ * @remarks
+ * Maintainer: Callari, Salvatore (XDBC@WaXCode.net) */
+export class AE extends DBC {
+    // #region Condition checking.
+    /**
+     * Checks each element of the **value**-{@link Array < any >} against the given **condition**, if it is one. If it is not
+     * the **value** itself will be checked.
+     *
+     * @param condition	The { check: (toCheck: any) => boolean | string } 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 As soon as the **condition** returns a {@link string }, instead of TRUE, the returned string. TRUE if the
+     * 			**condition** never returns a {@link string}. */
+    static checkAlgorithm(condition, value, index, idxEnd) {
+        if (Array.isArray(value)) {
+            if (index !== undefined && idxEnd === undefined) {
+                if (index > -1 && index < value.length) {
+                    const result = condition.check(value[index]);
+                    if (typeof result === "string") {
+                        return `Violating-Arrayelement at index "${index}" with value "${value[index]}". ${result}`;
+                    }
+                }
+                return true; // In order for optional parameter to not cause an error if they are omitted.
+            }
+            const ending = idxEnd !== undefined
+                ? idxEnd !== -1
+                    ? idxEnd + 1
+                    : value.length
+                : value.length;
+            for (let i = index ? index : 0; i < ending; i++) {
+                const result = condition.check(value[i]);
+                if (result !== true) {
+                    return `Violating-Arrayelement at index ${i}. ${result}`;
+                }
+            }
+        }
+        else {
+            return condition.check(value);
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link AE.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 index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param hint				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(realConditions, index = undefined, idxEnd = undefined, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.decPrecondition((value, target, methodName, parameterIndex) => {
+            if (Array.isArray(realConditions)) {
+                for (const currentCondition of realConditions) {
+                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);
+                    if (typeof result !== "boolean")
+                        return result;
+                }
+            }
+            else {
+                return AE.checkAlgorithm(realConditions, value, index, idxEnd);
+            }
+            return true;
+        }, dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link AE.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 index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decPrecondition }.
+     * @param hint				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(realConditions, index = undefined, idxEnd = undefined, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.decPostcondition((value, target, propertyKey) => {
+            if (Array.isArray(realConditions)) {
+                for (const currentCondition of realConditions) {
+                    const result = AE.checkAlgorithm(currentCondition, value, index, idxEnd);
+                    if (typeof result !== "boolean")
+                        return result;
+                }
+            }
+            else {
+                return AE.checkAlgorithm(realConditions, value, index, idxEnd);
+            }
+            return true;
+        }, dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link AE.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 index				See the {@link AE.checkAlgorithm }.
+     * @param idxEnd			See the {@link AE.checkAlgorithm }.
+     * @param path				See {@link DBC.decInvariant }.
+     * @param hint				See {@link DBC.decInvariant }.
+     * @param dbc				See {@link DBC.decInvariant }.
+     *
+     * @returns	See {@link DBC.decInvariant }. */
+    static INVARIANT(realConditions, index = undefined, idxEnd = undefined, path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(AE, [realConditions, index, idxEnd], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like global functions).
+    //
+    /**
+     * Invokes the {@link AE.checkAlgorithm } with all {@link AE.conditions } and the {@link object } {@link toCheck },
+     * {@link AE.index } & {@link AE.idxEnd }.
+     *
+     * @param toCheck See {@link AE.checkAlgorithm }.
+     *
+     * @returns See {@link EQ.checkAlgorithm}. */
+    check(toCheck) {
+        if (Array.isArray(this.conditions)) {
+            for (const currentCondition of this.conditions) {
+                const result = AE.checkAlgorithm(currentCondition, toCheck, this.index, this.idxEnd);
+                if (typeof result !== "boolean")
+                    return result;
+            }
+        }
+        else {
+            return AE.checkAlgorithm(this.conditions, toCheck, this.index, this.idxEnd);
+        }
+        return true;
+    }
+    /**
+     * Creates this {@link AE } by setting the protected property {@link AE.conditions }, {@link AE.index } and {@link AE.idxEnd } used by {@link AE.check }.
+     *
+     * @param equivalent See {@link EQ.check }. */
+    constructor(conditions, index = undefined, idxEnd = undefined) {
+        super();
+        this.conditions = conditions;
+        this.index = index;
+        this.idxEnd = idxEnd;
+    }
+}

package/dist/DBC/ARR/PLAIN_OBJECT.d.ts

@@ -61,7 +61,4 @@ export declare class PLAIN_OBJECT extends ARRAY {
      *
      * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link PLAIN_OBJECT }. */
     static tsCheck<CANDIDATE extends object = object>(toCheck: CANDIDATE | undefined | null, hint?: string | undefined, id?: string | undefined, dbc?: string | undefined): CANDIDATE;
-    /**
-     * Creates this {@link PLAIN_OBJECT } instance. No parameters needed — the check is always the same. */
-    constructor();
 }

package/dist/DBC/ARR/PLAIN_OBJECT.js

@@ -0,0 +1,95 @@
+import { DBC } from "../../DBC";
+import { ARRAY } from "../ARRAY";
+/**
+ * A {@link DBC } defining that a value must be a plain object — i.e. `typeof value === "object"`,
+ * not `null`, and not an array.
+ *
+ * @remarks
+ * Maintainer: Salvatore Callari (XDBC@WaXCode.net) */
+export class PLAIN_OBJECT extends ARRAY {
+    /**
+     * Checks if the value **toCheck** is a plain object (non-null, non-array object).
+     *
+     * @param toCheck	The value to check.
+     *
+     * @returns TRUE if the value **toCheck** is a plain object, otherwise a string describing the infringement. */
+    static checkAlgorithm(toCheck) {
+        if (toCheck === undefined || toCheck === null)
+            return true;
+        if (typeof toCheck !== "object") {
+            return `Value has to be a PLAIN_OBJECT but is of type "${typeof toCheck}"`;
+        }
+        if (Array.isArray(toCheck)) {
+            return "Value has to be a PLAIN_OBJECT but is an ARRAY";
+        }
+        return true;
+    }
+    /**
+     * A parameter-decorator factory using the {@link PLAIN_OBJECT.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged parameter.
+     *
+     * @param path	See {@link DBC.decPrecondition }.
+     * @param hint	See {@link DBC.decPrecondition }.
+     * @param dbc	See {@link DBC.decPrecondition }.
+     *
+     * @returns See {@link DBC.decPrecondition }. */
+    static PRE(path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPRE(PLAIN_OBJECT.checkAlgorithm, [], dbc, path, hint);
+    }
+    /**
+     * A method-decorator factory using the {@link PLAIN_OBJECT.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged method's returnvalue.
+     *
+     * @param path	See {@link DBC.decPostcondition }.
+     * @param hint	See {@link DBC.decPostcondition }.
+     * @param dbc	See {@link DBC.decPostcondition }.
+     *
+     * @returns See {@link DBC.decPostcondition }. */
+    static POST(path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createPOST(PLAIN_OBJECT.checkAlgorithm, [], dbc, path, hint);
+    }
+    /**
+     * A field-decorator factory using the {@link PLAIN_OBJECT.checkAlgorithm } to determine whether this {@link DBC } is fulfilled
+     * by the tagged field.
+     *
+     * @param path	See {@link DBC.decInvariant }.
+     * @param hint	See {@link DBC.decInvariant }.
+     * @param dbc	See {@link DBC.decInvariant }.
+     *
+     * @returns See {@link DBC.decInvariant }. */
+    static INVARIANT(path = undefined, hint = undefined, dbc = undefined) {
+        return DBC.createINVARIANT(PLAIN_OBJECT, [], dbc, path, hint);
+    }
+    // #endregion Condition checking.
+    // #region Referenced Condition checking.
+    //
+    // For usage in dynamic scenarios (like with AE-DBC).
+    //
+    /**
+     * Invokes the {@link PLAIN_OBJECT.checkAlgorithm } passing the value **toCheck**.
+     *
+     * @param toCheck See {@link PLAIN_OBJECT.checkAlgorithm }.
+     *
+     * @returns See {@link PLAIN_OBJECT.checkAlgorithm}. */
+    check(toCheck) {
+        return PLAIN_OBJECT.checkAlgorithm(toCheck);
+    }
+    /**
+     * Invokes the {@link PLAIN_OBJECT.checkAlgorithm } passing the value **toCheck**.
+     *
+     * @param toCheck	See {@link PLAIN_OBJECT.checkAlgorithm }.
+     * @param hint		An optional {@link string } providing extra information in case of an infringement.
+     * @param id		A {@link string } identifying this {@link PLAIN_OBJECT } via the {@link DBC.Infringement }-Message.
+     *
+     * @returns The **CANDIDATE** **toCheck** if this {@link PLAIN_OBJECT } is fulfilled.
+     *
+     * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link PLAIN_OBJECT }. */
+    static tsCheck(toCheck, hint = undefined, id = undefined, dbc = undefined) {
+        const result = PLAIN_OBJECT.checkAlgorithm(toCheck);
+        if (result === true) {
+            return toCheck;
+        }
+        DBC.reportTsCheckInfringement(`${id ? `(${id}) ` : ""}${result}${hint ? ` ✨ ${hint} ✨` : ""}`, dbc);
+        return toCheck;
+    }
+}

package/dist/DBC/ARRAY.d.ts

@@ -60,7 +60,4 @@ export declare class ARRAY extends DBC {
      *
      * @throws A {@link DBC.Infringement } if the **CANDIDATE** **toCheck** does not fulfill this {@link ARRAY }. */
     static tsCheck<CANDIDATE extends unknown[] = unknown[]>(toCheck: CANDIDATE | undefined | null, hint?: string | undefined, id?: string | undefined, dbc?: string | undefined): CANDIDATE;
-    /**
-     * Creates this {@link ARRAY } instance.  No parameters needed — the check is always {@link Array.isArray }. */
-    constructor();
 }