xdbc 1.0.217 → 1.0.218

package/__tests__/DBC/EQ.test.ts

@@ -1,13 +1,13 @@
-import { EQ } from "../../src/DBC/EQ";
-
-describe("EQ", () => {
-	const eq = new EQ("b");
-
-	test("Should not report infringement with 'b' to check", () => {
-		expect(eq.check("b")).toBe(true);
-	});
-
-	test("Should report infringement with 'c' to check", () => {
-		expect(typeof eq.check("c")).toBe("string");
-	});
-});
+import { EQ } from "../../src/DBC/EQ";
+
+describe("EQ", () => {
+	const eq = new EQ("b");
+
+	test("Should not report infringement with 'b' to check", () => {
+		expect(eq.check("b")).toBe(true);
+	});
+
+	test("Should report infringement with 'c' to check", () => {
+		expect(typeof eq.check("c")).toBe("string");
+	});
+});

package/__tests__/DBC/GREATER.test.ts

@@ -1,31 +1,31 @@
-import { GREATER } from "../../src/DBC/COMPARISON/GREATER";
-import { GREATER_OR_EQUAL } from "../../src/DBC/COMPARISON/GREATER_OR_EQUAL";
-import { LESS_OR_EQUAL } from "../../src/DBC/COMPARISON/LESS_OR_EQUAL";
-
-describe("GREATER", () => {
-	const greater = new GREATER(1);
-
-	test("Should not report infringement with '2' to check", () => {
-		expect(greater.check(2)).toBe(true);
-	});
-
-	test("Should report infringement with '0' to check", () => {
-		expect(typeof greater.check(0)).toBe("string");
-	});
-
-	test("Should report infringement with '1' to check (equality not permitted)", () => {
-		expect(typeof greater.check(1)).toBe("string");
-	});
-
-	test("Should not report infringement with '1' and '1' to check since equality is now permitted", () => {
-		expect(new GREATER_OR_EQUAL(1).check(1)).toBe(true);
-	});
-
-	test("Should not report infringement with '1' and '1' to check since inverting the result is now on", () => {
-		expect(new LESS_OR_EQUAL(1).check(1)).toBe(true);
-	});
-
-	test("Should not report infringement with 'undefined' and 'undefined' to check", () => {
-		expect(new GREATER(undefined).check(undefined)).toBe(true);
-	});
-});
+import { GREATER } from "../../src/DBC/COMPARISON/GREATER";
+import { GREATER_OR_EQUAL } from "../../src/DBC/COMPARISON/GREATER_OR_EQUAL";
+import { LESS_OR_EQUAL } from "../../src/DBC/COMPARISON/LESS_OR_EQUAL";
+
+describe("GREATER", () => {
+	const greater = new GREATER(1);
+
+	test("Should not report infringement with '2' to check", () => {
+		expect(greater.check(2)).toBe(true);
+	});
+
+	test("Should report infringement with '0' to check", () => {
+		expect(typeof greater.check(0)).toBe("string");
+	});
+
+	test("Should report infringement with '1' to check (equality not permitted)", () => {
+		expect(typeof greater.check(1)).toBe("string");
+	});
+
+	test("Should not report infringement with '1' and '1' to check since equality is now permitted", () => {
+		expect(new GREATER_OR_EQUAL(1).check(1)).toBe(true);
+	});
+
+	test("Should not report infringement with '1' and '1' to check since inverting the result is now on", () => {
+		expect(new LESS_OR_EQUAL(1).check(1)).toBe(true);
+	});
+
+	test("Should not report infringement with 'undefined' and 'undefined' to check", () => {
+		expect(new GREATER(undefined).check(undefined)).toBe(true);
+	});
+});

package/__tests__/DBC/HasAttribute.test.ts

@@ -1,60 +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",
-			);
-		});
-	});
-});
+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",
+			);
+		});
+	});
+});

package/__tests__/DBC/IF.test.ts

@@ -1,62 +1,62 @@
-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);
-		});
-	});
-});
+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);
+		});
+	});
+});

package/__tests__/DBC/INSTANCE.test.ts

@@ -1,13 +1,13 @@
-import { INSTANCE } from "../../src/DBC/INSTANCE";
-
-describe("INSTANCE", () => {
-	const instance = new INSTANCE(RegExp);
-
-	test("Should not report infringement with '/a/g' to check", () => {
-		expect(instance.check(/a/g)).toBe(true);
-	});
-
-	test("Should report infringement with 'd' to check", () => {
-		expect(typeof instance.check("d")).toBe("string");
-	});
-});
+import { INSTANCE } from "../../src/DBC/INSTANCE";
+
+describe("INSTANCE", () => {
+	const instance = new INSTANCE(RegExp);
+
+	test("Should not report infringement with '/a/g' to check", () => {
+		expect(instance.check(/a/g)).toBe(true);
+	});
+
+	test("Should report infringement with 'd' to check", () => {
+		expect(typeof instance.check("d")).toBe("string");
+	});
+});

package/__tests__/DBC/JSON.OP.test.ts

@@ -1,47 +1,47 @@
-import { JSON_OP } from "../../src/DBC/JSON.OP";
-
-describe("JSON.OP", () => {
-	const jsonOP = new JSON_OP([
-		{ name: "x", type: "string" },
-		{ name: "y", type: "number" },
-	]);
-
-	test("Should not report infringement with { x: 'x', y: 1 } to check", () => {
-		expect(jsonOP.check({ x: "x", y: 1 })).toBe(true);
-	});
-
-	test("Should report infringement with { x: 1 } to check", () => {
-		expect(typeof jsonOP.check({ x: 1 })).toBe("string");
-	});
-
-	test("Should not report infringement with [{ x: 'x', y: 1 },{ x: 'xs', y: 2 }] to check in 'checkElements' mode", () => {
-		expect(
-			new JSON_OP(
-				[
-					{ name: "x", type: "string" },
-					{ name: "y", type: "number" },
-				],
-				true,
-			).check([
-				{ x: "x", y: 1 },
-				{ x: "xs", y: 2 },
-			]),
-		).toBe(true);
-	});
-
-	test("Should report infringement with [{ x: 'x', y: 1 },{ x: 'xs', y: 2 }] to check with no 'checkElements' mode", () => {
-		expect(
-			typeof new JSON_OP([
-				{ name: "x", type: "string" },
-				{ name: "y", type: "number" },
-			]).check([
-				{ x: "x", y: 1 },
-				{ x: "xs", y: 2 },
-			]),
-		).toBe("string");
-	});
-
-	test("Should report infringement with [] to check", () => {
-		expect(typeof jsonOP.check([])).toBe("string");
-	});
-});
+import { JSON_OP } from "../../src/DBC/JSON.OP";
+
+describe("JSON.OP", () => {
+	const jsonOP = new JSON_OP([
+		{ name: "x", type: "string" },
+		{ name: "y", type: "number" },
+	]);
+
+	test("Should not report infringement with { x: 'x', y: 1 } to check", () => {
+		expect(jsonOP.check({ x: "x", y: 1 })).toBe(true);
+	});
+
+	test("Should report infringement with { x: 1 } to check", () => {
+		expect(typeof jsonOP.check({ x: 1 })).toBe("string");
+	});
+
+	test("Should not report infringement with [{ x: 'x', y: 1 },{ x: 'xs', y: 2 }] to check in 'checkElements' mode", () => {
+		expect(
+			new JSON_OP(
+				[
+					{ name: "x", type: "string" },
+					{ name: "y", type: "number" },
+				],
+				true,
+			).check([
+				{ x: "x", y: 1 },
+				{ x: "xs", y: 2 },
+			]),
+		).toBe(true);
+	});
+
+	test("Should report infringement with [{ x: 'x', y: 1 },{ x: 'xs', y: 2 }] to check with no 'checkElements' mode", () => {
+		expect(
+			typeof new JSON_OP([
+				{ name: "x", type: "string" },
+				{ name: "y", type: "number" },
+			]).check([
+				{ x: "x", y: 1 },
+				{ x: "xs", y: 2 },
+			]),
+		).toBe("string");
+	});
+
+	test("Should report infringement with [] to check", () => {
+		expect(typeof jsonOP.check([])).toBe("string");
+	});
+});

package/__tests__/DBC/JSON.Parse.test.ts

@@ -1,17 +1,17 @@
-import { JSON_Parse } from "../../src/DBC/JSON.Parse";
-
-describe("JSON_Parse", () => {
-	const jsonParse = new JSON_Parse();
-
-	test(`Should not report infringement with '{"d":"o"}' to check`, () => {
-		expect(jsonParse.check('{"d":"o"}')).toBe(true);
-	});
-
-	test(`Should report infringement with '{"d":o}' to check`, () => {
-		expect(typeof jsonParse.check('{"d":o}')).toBe("string");
-	});
-
-	test(`Should not report infringement or throw "referenceException" with '{"d":"o"}' to check and "receptor" not defined`, () => {
-		expect(new JSON_Parse().check('{"d":"o"}')).toBe(true);
-	});
-});
+import { JSON_Parse } from "../../src/DBC/JSON.Parse";
+
+describe("JSON_Parse", () => {
+	const jsonParse = new JSON_Parse();
+
+	test(`Should not report infringement with '{"d":"o"}' to check`, () => {
+		expect(jsonParse.check('{"d":"o"}')).toBe(true);
+	});
+
+	test(`Should report infringement with '{"d":o}' to check`, () => {
+		expect(typeof jsonParse.check('{"d":o}')).toBe("string");
+	});
+
+	test(`Should not report infringement or throw "referenceException" with '{"d":"o"}' to check and "receptor" not defined`, () => {
+		expect(new JSON_Parse().check('{"d":"o"}')).toBe(true);
+	});
+});

package/__tests__/DBC/OR.test.ts

@@ -1,14 +1,14 @@
-import { EQ } from "../../src/DBC/EQ";
-import { OR } from "../../src/DBC/OR";
-
-describe("OR", () => {
-	const or = new OR([new EQ("a"), new EQ("b")]);
-
-	test("Should not report infringement with 'b' to check", () => {
-		expect(or.check("b")).toBe(true);
-	});
-
-	test("Should report infringement with 'c' to check", () => {
-		expect(typeof or.check("c")).toBe("string");
-	});
-});
+import { EQ } from "../../src/DBC/EQ";
+import { OR } from "../../src/DBC/OR";
+
+describe("OR", () => {
+	const or = new OR([new EQ("a"), new EQ("b")]);
+
+	test("Should not report infringement with 'b' to check", () => {
+		expect(or.check("b")).toBe(true);
+	});
+
+	test("Should report infringement with 'c' to check", () => {
+		expect(typeof or.check("c")).toBe("string");
+	});
+});