xdbc 1.0.211 → 1.0.213

package/__tests__/DBC/HasAttribute.test.ts

@@ -1,56 +1,60 @@
 import { HasAttribute } from "../../src/DBC/HasAttribute";
 
 describe("HasAttribute", () => {
-    const hasId = new HasAttribute("id");
-
-    test("Should not report infringement when attribute exists", () => {
-        const el = document.createElement("div");
-        el.setAttribute("id", "test");
-        expect(hasId.check(el)).toBe(true);
-    });
-
-    test("Should report infringement when attribute is missing", () => {
-        const el = document.createElement("div");
-        expect(typeof hasId.check(el)).toBe("string");
-    });
-
-    test("Should report infringement when value is not an HTMLElement", () => {
-        expect(typeof hasId.check("not an element")).toBe("string");
-    });
-
-    test("Should report infringement when value is a plain object", () => {
-        expect(typeof hasId.check({ id: "test" })).toBe("string");
-    });
-
-    describe("invert", () => {
-        const noId = new HasAttribute("id", true);
-
-        test("Should not report infringement when attribute is absent", () => {
-            const el = document.createElement("div");
-            expect(noId.check(el)).toBe(true);
-        });
-
-        test("Should report infringement when forbidden attribute exists", () => {
-            const el = document.createElement("div");
-            el.setAttribute("id", "test");
-            expect(typeof noId.check(el)).toBe("string");
-        });
-    });
-
-    describe("checkAlgorithm", () => {
-        test("Should return true when element has the attribute", () => {
-            const el = document.createElement("span");
-            el.setAttribute("class", "active");
-            expect(HasAttribute.checkAlgorithm(el, "class", false)).toBe(true);
-        });
-
-        test("Should return string when element lacks the attribute", () => {
-            const el = document.createElement("span");
-            expect(typeof HasAttribute.checkAlgorithm(el, "class", false)).toBe("string");
-        });
-
-        test("Should return string for non-HTMLElement", () => {
-            expect(typeof HasAttribute.checkAlgorithm(42, "id", false)).toBe("string");
-        });
-    });
+	const hasId = new HasAttribute("id");
+
+	test("Should not report infringement when attribute exists", () => {
+		const el = document.createElement("div");
+		el.setAttribute("id", "test");
+		expect(hasId.check(el)).toBe(true);
+	});
+
+	test("Should report infringement when attribute is missing", () => {
+		const el = document.createElement("div");
+		expect(typeof hasId.check(el)).toBe("string");
+	});
+
+	test("Should report infringement when value is not an HTMLElement", () => {
+		expect(typeof hasId.check("not an element")).toBe("string");
+	});
+
+	test("Should report infringement when value is a plain object", () => {
+		expect(typeof hasId.check({ id: "test" })).toBe("string");
+	});
+
+	describe("invert", () => {
+		const noId = new HasAttribute("id", true);
+
+		test("Should not report infringement when attribute is absent", () => {
+			const el = document.createElement("div");
+			expect(noId.check(el)).toBe(true);
+		});
+
+		test("Should report infringement when forbidden attribute exists", () => {
+			const el = document.createElement("div");
+			el.setAttribute("id", "test");
+			expect(typeof noId.check(el)).toBe("string");
+		});
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true when element has the attribute", () => {
+			const el = document.createElement("span");
+			el.setAttribute("class", "active");
+			expect(HasAttribute.checkAlgorithm(el, "class", false)).toBe(true);
+		});
+
+		test("Should return string when element lacks the attribute", () => {
+			const el = document.createElement("span");
+			expect(typeof HasAttribute.checkAlgorithm(el, "class", false)).toBe(
+				"string",
+			);
+		});
+
+		test("Should return string for non-HTMLElement", () => {
+			expect(typeof HasAttribute.checkAlgorithm(42, "id", false)).toBe(
+				"string",
+			);
+		});
+	});
 });

package/__tests__/DBC/IF.test.ts

@@ -1,62 +1,62 @@
-import { IF } from "../../src/DBC/IF";
 import { EQ } from "../../src/DBC/EQ";
+import { IF } from "../../src/DBC/IF";
 import { TYPE } from "../../src/DBC/TYPE";
 
 describe("IF", () => {
-    const isString = new TYPE("string");
-    const eqHello = new EQ("hello");
-
-    const ifContract = new IF(isString, eqHello);
-
-    test("Should not report infringement when condition matches and inCase is fulfilled", () => {
-        expect(ifContract.check("hello")).toBe(true);
-    });
-
-    test("Should report infringement when condition matches but inCase is not fulfilled", () => {
-        expect(typeof ifContract.check("world")).toBe("string");
-    });
-
-    test("Should not report infringement when condition does not match", () => {
-        expect(ifContract.check(42)).toBe(true);
-    });
-
-    describe("invert", () => {
-        const invertedContract = new IF(isString, eqHello, true);
-
-        test("Should not report infringement when condition does not match and inCase is fulfilled", () => {
-            expect(invertedContract.check("hello")).toBe(true);
-        });
-
-        test("Should report infringement when condition does not match and inCase is not fulfilled", () => {
-            expect(typeof invertedContract.check(42)).toBe("string");
-        });
-
-        test("Should not report infringement when condition matches", () => {
-            expect(invertedContract.check("world")).toBe(true);
-        });
-    });
-
-    describe("checkAlgorithm", () => {
-        test("Should return true when condition not met", () => {
-            expect(IF.checkAlgorithm(123, isString, eqHello)).toBe(true);
-        });
-
-        test("Should return string when condition met but inCase fails", () => {
-            expect(typeof IF.checkAlgorithm("notHello", isString, eqHello)).toBe("string");
-        });
-
-        test("Should return true when both condition and inCase pass", () => {
-            expect(IF.checkAlgorithm("hello", isString, eqHello)).toBe(true);
-        });
-
-        test("Should return true when toCheck is undefined", () => {
-            expect(IF.checkAlgorithm(undefined, isString, eqHello)).toBe(true);
-        });
-
-        test("Should return true when toCheck is null", () => {
-            expect(IF.checkAlgorithm(null, isString, eqHello)).toBe(true);
-        });
-
-
-    });
+	const isString = new TYPE("string");
+	const eqHello = new EQ("hello");
+
+	const ifContract = new IF(isString, eqHello);
+
+	test("Should not report infringement when condition matches and inCase is fulfilled", () => {
+		expect(ifContract.check("hello")).toBe(true);
+	});
+
+	test("Should report infringement when condition matches but inCase is not fulfilled", () => {
+		expect(typeof ifContract.check("world")).toBe("string");
+	});
+
+	test("Should not report infringement when condition does not match", () => {
+		expect(ifContract.check(42)).toBe(true);
+	});
+
+	describe("invert", () => {
+		const invertedContract = new IF(isString, eqHello, true);
+
+		test("Should not report infringement when condition does not match and inCase is fulfilled", () => {
+			expect(invertedContract.check("hello")).toBe(true);
+		});
+
+		test("Should report infringement when condition does not match and inCase is not fulfilled", () => {
+			expect(typeof invertedContract.check(42)).toBe("string");
+		});
+
+		test("Should not report infringement when condition matches", () => {
+			expect(invertedContract.check("world")).toBe(true);
+		});
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true when condition not met", () => {
+			expect(IF.checkAlgorithm(123, isString, eqHello)).toBe(true);
+		});
+
+		test("Should return string when condition met but inCase fails", () => {
+			expect(typeof IF.checkAlgorithm("notHello", isString, eqHello)).toBe(
+				"string",
+			);
+		});
+
+		test("Should return true when both condition and inCase pass", () => {
+			expect(IF.checkAlgorithm("hello", isString, eqHello)).toBe(true);
+		});
+
+		test("Should return true when toCheck is undefined", () => {
+			expect(IF.checkAlgorithm(undefined, isString, eqHello)).toBe(true);
+		});
+
+		test("Should return true when toCheck is null", () => {
+			expect(IF.checkAlgorithm(null, isString, eqHello)).toBe(true);
+		});
+	});
 });

package/__tests__/DBC/OR.test.ts

@@ -1,5 +1,5 @@
-import { OR } from "../../src/DBC/OR";
 import { EQ } from "../../src/DBC/EQ";
+import { OR } from "../../src/DBC/OR";
 
 describe("OR", () => {
 	const or = new OR([new EQ("a"), new EQ("b")]);

package/__tests__/DBC/UNDEFINED.test.ts

@@ -1,45 +1,45 @@
 import { UNDEFINED } from "../../src/DBC/UNDEFINED";
 
 describe("UNDEFINED", () => {
-    const undef = new UNDEFINED();
-
-    test("Should not report infringement with undefined", () => {
-        expect(undef.check(undefined)).toBe(true);
-    });
-
-    test("Should report infringement with null", () => {
-        expect(typeof undef.check(null)).toBe("string");
-    });
-
-    test("Should report infringement with a string value", () => {
-        expect(typeof undef.check("hello")).toBe("string");
-    });
-
-    test("Should report infringement with a number value", () => {
-        expect(typeof undef.check(42)).toBe("string");
-    });
-
-    test("Should report infringement with zero", () => {
-        expect(typeof undef.check(0)).toBe("string");
-    });
-
-    test("Should report infringement with false", () => {
-        expect(typeof undef.check(false)).toBe("string");
-    });
-
-    test("Should report infringement with an empty string", () => {
-        expect(typeof undef.check("")).toBe("string");
-    });
-
-    describe("checkAlgorithm", () => {
-        test("Should return true for undefined", () => {
-            expect(UNDEFINED.checkAlgorithm(undefined)).toBe(true);
-        });
-
-        test("Should return string for defined values", () => {
-            expect(typeof UNDEFINED.checkAlgorithm("test")).toBe("string");
-            expect(typeof UNDEFINED.checkAlgorithm(0)).toBe("string");
-            expect(typeof UNDEFINED.checkAlgorithm(null)).toBe("string");
-        });
-    });
+	const undef = new UNDEFINED();
+
+	test("Should not report infringement with undefined", () => {
+		expect(undef.check(undefined)).toBe(true);
+	});
+
+	test("Should report infringement with null", () => {
+		expect(typeof undef.check(null)).toBe("string");
+	});
+
+	test("Should report infringement with a string value", () => {
+		expect(typeof undef.check("hello")).toBe("string");
+	});
+
+	test("Should report infringement with a number value", () => {
+		expect(typeof undef.check(42)).toBe("string");
+	});
+
+	test("Should report infringement with zero", () => {
+		expect(typeof undef.check(0)).toBe("string");
+	});
+
+	test("Should report infringement with false", () => {
+		expect(typeof undef.check(false)).toBe("string");
+	});
+
+	test("Should report infringement with an empty string", () => {
+		expect(typeof undef.check("")).toBe("string");
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true for undefined", () => {
+			expect(UNDEFINED.checkAlgorithm(undefined)).toBe(true);
+		});
+
+		test("Should return string for defined values", () => {
+			expect(typeof UNDEFINED.checkAlgorithm("test")).toBe("string");
+			expect(typeof UNDEFINED.checkAlgorithm(0)).toBe("string");
+			expect(typeof UNDEFINED.checkAlgorithm(null)).toBe("string");
+		});
+	});
 });

package/__tests__/DBC/ZOD.test.ts

@@ -1,54 +1,54 @@
-import { ZOD } from "../../src/DBC/ZOD";
 import { z } from "zod";
+import { ZOD } from "../../src/DBC/ZOD";
 
 describe("ZOD", () => {
-    describe("string schema", () => {
-        const zodString = new ZOD(z.string());
-
-        test("Should not report infringement with a string value", () => {
-            expect(zodString.check("hello")).toBe(true);
-        });
-
-        test("Should report infringement with a number value", () => {
-            expect(typeof zodString.check(42)).toBe("string");
-        });
-    });
-
-    describe("number schema", () => {
-        const zodNumber = new ZOD(z.number());
-
-        test("Should not report infringement with a number value", () => {
-            expect(zodNumber.check(42)).toBe(true);
-        });
-
-        test("Should report infringement with a string value", () => {
-            expect(typeof zodNumber.check("hello")).toBe("string");
-        });
-    });
-
-    describe("object schema", () => {
-        const zodObject = new ZOD(z.object({ name: z.string(), age: z.number() }));
-
-        test("Should not report infringement with a valid object", () => {
-            expect(zodObject.check({ name: "Alice", age: 30 })).toBe(true);
-        });
-
-        test("Should report infringement with an invalid object", () => {
-            expect(typeof zodObject.check({ name: 123 })).toBe("string");
-        });
-
-        test("Should report infringement with a non-object value", () => {
-            expect(typeof zodObject.check("not an object")).toBe("string");
-        });
-    });
-
-    describe("checkAlgorithm", () => {
-        test("Should return true for valid value", () => {
-            expect(ZOD.checkAlgorithm("test", z.string())).toBe(true);
-        });
-
-        test("Should return string for invalid value", () => {
-            expect(typeof ZOD.checkAlgorithm(42, z.string())).toBe("string");
-        });
-    });
+	describe("string schema", () => {
+		const zodString = new ZOD(z.string());
+
+		test("Should not report infringement with a string value", () => {
+			expect(zodString.check("hello")).toBe(true);
+		});
+
+		test("Should report infringement with a number value", () => {
+			expect(typeof zodString.check(42)).toBe("string");
+		});
+	});
+
+	describe("number schema", () => {
+		const zodNumber = new ZOD(z.number());
+
+		test("Should not report infringement with a number value", () => {
+			expect(zodNumber.check(42)).toBe(true);
+		});
+
+		test("Should report infringement with a string value", () => {
+			expect(typeof zodNumber.check("hello")).toBe("string");
+		});
+	});
+
+	describe("object schema", () => {
+		const zodObject = new ZOD(z.object({ name: z.string(), age: z.number() }));
+
+		test("Should not report infringement with a valid object", () => {
+			expect(zodObject.check({ name: "Alice", age: 30 })).toBe(true);
+		});
+
+		test("Should report infringement with an invalid object", () => {
+			expect(typeof zodObject.check({ name: 123 })).toBe("string");
+		});
+
+		test("Should report infringement with a non-object value", () => {
+			expect(typeof zodObject.check("not an object")).toBe("string");
+		});
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true for valid value", () => {
+			expect(ZOD.checkAlgorithm("test", z.string())).toBe(true);
+		});
+
+		test("Should return string for invalid value", () => {
+			expect(typeof ZOD.checkAlgorithm(42, z.string())).toBe("string");
+		});
+	});
 });

package/biome.json

@@ -1,33 +1,40 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-  "vcs": {
-    "enabled": false,
-    "clientKind": "git",
-    "useIgnoreFile": false
-  },
-  "files": {
-    "ignoreUnknown": false,
-    "ignore": []
-  },
-  "formatter": {
-    "enabled": true,
-    "indentStyle": "tab"
-  },
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true
-    }
-  },
-  "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.d.ts

@@ -0,0 +1,117 @@
+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 declare class AE extends DBC {
+    protected conditions: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    };
+    protected index: number | undefined;
+    protected idxEnd: number | undefined;
+    /**
+     * 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: {
+        check: (toCheck: unknown | null | undefined) => boolean | string;
+    }, value: object, index: number | undefined, idxEnd: number | undefined): boolean | string;
+    /**
+     * 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: Array<{
+        check: (toCheck: unknown | undefined | null) => boolean | string;
+    }> | {
+        check: (toCheck: unknown | undefined | null) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /**
+     * 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: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /**
+     * 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: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /**
+     * 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: any): string | boolean;
+    /**
+     * 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: Array<{
+        check: (toCheck: any) => boolean | string;
+    }> | {
+        check: (toCheck: any) => boolean | string;
+    }, index?: number | undefined, idxEnd?: number | undefined);
+}

package/dist/DBC/COMPARISON/GREATER.d.ts

@@ -0,0 +1,13 @@
+import { COMPARISON } from "../COMPARISON";
+/** See {@link COMPARISON }. */
+export declare class GREATER extends COMPARISON {
+    equivalent: any;
+    /** See {@link COMPARISON.PRE }. */
+    static PRE(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, methodName: string | symbol, parameterIndex: number) => void;
+    /** See {@link COMPARISON.POST }. */
+    static POST(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: object, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+    /** See {@link COMPARISON.INVARIANT }. */
+    static INVARIANT(equivalent: any, equalityPermitted?: boolean, invert?: boolean, path?: string | undefined, hint?: string | undefined, dbc?: string | undefined): (target: unknown, propertyKey: string | symbol) => void;
+    /** See {@link COMPARISON.constructor }. */
+    constructor(equivalent: any);
+}