xdbc 1.0.211 → 1.0.212

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"
+		}
+	}
+}