xdbc 1.0.217 → 1.0.219

package/__tests__/DBC/PLAIN_OBJECT.test.ts

@@ -1,109 +1,109 @@
-import { PLAIN_OBJECT } from "../../src/DBC/ARR/PLAIN_OBJECT";
-import { DBC } from "../../src/DBC";
-
-describe("PLAIN_OBJECT", () => {
-	const plainObject = new PLAIN_OBJECT();
-
-	test("Should not report infringement with a plain object", () => {
-		expect(plainObject.check({ a: 1 })).toBe(true);
-	});
-
-	test("Should not report infringement with an empty object", () => {
-		expect(plainObject.check({})).toBe(true);
-	});
-
-	test("Should not report infringement with undefined (null-passthrough)", () => {
-		expect(plainObject.check(undefined)).toBe(true);
-	});
-
-	test("Should not report infringement with null (null-passthrough)", () => {
-		expect(plainObject.check(null)).toBe(true);
-	});
-
-	test("Should report infringement with an array", () => {
-		expect(typeof plainObject.check([])).toBe("string");
-	});
-
-	test("Should report infringement with a non-empty array", () => {
-		expect(typeof plainObject.check([1, 2, 3])).toBe("string");
-	});
-
-	test("Should report infringement with a string", () => {
-		expect(typeof plainObject.check("hello")).toBe("string");
-	});
-
-	test("Should report infringement with a number", () => {
-		expect(typeof plainObject.check(42)).toBe("string");
-	});
-
-	describe("checkAlgorithm", () => {
-		test("Should return true for a plain object", () => {
-			expect(PLAIN_OBJECT.checkAlgorithm({ key: "value" })).toBe(true);
-		});
-
-		test("Should return true for an empty object", () => {
-			expect(PLAIN_OBJECT.checkAlgorithm({})).toBe(true);
-		});
-
-		test("Should return true for null (null-passthrough)", () => {
-			expect(PLAIN_OBJECT.checkAlgorithm(null)).toBe(true);
-		});
-
-		test("Should return true for undefined (null-passthrough)", () => {
-			expect(PLAIN_OBJECT.checkAlgorithm(undefined)).toBe(true);
-		});
-
-		test("Should return string for an array", () => {
-			const result = PLAIN_OBJECT.checkAlgorithm([]);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("ARRAY");
-		});
-
-		test("Should return string for a non-empty array", () => {
-			const result = PLAIN_OBJECT.checkAlgorithm([1, 2, 3]);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("ARRAY");
-		});
-
-		test("Should return string for a string value", () => {
-			const result = PLAIN_OBJECT.checkAlgorithm("hello");
-			expect(typeof result).toBe("string");
-			expect(result).toContain("PLAIN_OBJECT");
-		});
-
-		test("Should return string for a number", () => {
-			const result = PLAIN_OBJECT.checkAlgorithm(42);
-			expect(typeof result).toBe("string");
-			expect(result).toContain("PLAIN_OBJECT");
-		});
-	});
-
-	describe("tsCheck", () => {
-		test("Should return the value when it is a plain object", () => {
-			const value = { x: 1 };
-			expect(PLAIN_OBJECT.tsCheck(value)).toBe(value);
-		});
-
-		test("Should throw DBC.Infringement when value is an array", () => {
-			expect(() => PLAIN_OBJECT.tsCheck([] as any)).toThrow(DBC.Infringement);
-		});
-
-		test("Should throw DBC.Infringement when value is a string", () => {
-			expect(() => PLAIN_OBJECT.tsCheck("oops" as any)).toThrow(
-				DBC.Infringement,
-			);
-		});
-
-		test("Should include hint in the infringement message", () => {
-			expect(() =>
-				PLAIN_OBJECT.tsCheck([] as any, "must be a plain object"),
-			).toThrow(/must be a plain object/);
-		});
-
-		test("Should include id in the infringement message", () => {
-			expect(() =>
-				PLAIN_OBJECT.tsCheck(42 as any, undefined, "optionsParam"),
-			).toThrow(/optionsParam/);
-		});
-	});
-});
+import { DBC } from "../../src/DBC";
+import { PLAIN_OBJECT } from "../../src/DBC/ARR/PLAIN_OBJECT";
+
+describe("PLAIN_OBJECT", () => {
+	const plainObject = new PLAIN_OBJECT();
+
+	test("Should not report infringement with a plain object", () => {
+		expect(plainObject.check({ a: 1 })).toBe(true);
+	});
+
+	test("Should not report infringement with an empty object", () => {
+		expect(plainObject.check({})).toBe(true);
+	});
+
+	test("Should not report infringement with undefined (null-passthrough)", () => {
+		expect(plainObject.check(undefined)).toBe(true);
+	});
+
+	test("Should not report infringement with null (null-passthrough)", () => {
+		expect(plainObject.check(null)).toBe(true);
+	});
+
+	test("Should report infringement with an array", () => {
+		expect(typeof plainObject.check([])).toBe("string");
+	});
+
+	test("Should report infringement with a non-empty array", () => {
+		expect(typeof plainObject.check([1, 2, 3])).toBe("string");
+	});
+
+	test("Should report infringement with a string", () => {
+		expect(typeof plainObject.check("hello")).toBe("string");
+	});
+
+	test("Should report infringement with a number", () => {
+		expect(typeof plainObject.check(42)).toBe("string");
+	});
+
+	describe("checkAlgorithm", () => {
+		test("Should return true for a plain object", () => {
+			expect(PLAIN_OBJECT.checkAlgorithm({ key: "value" })).toBe(true);
+		});
+
+		test("Should return true for an empty object", () => {
+			expect(PLAIN_OBJECT.checkAlgorithm({})).toBe(true);
+		});
+
+		test("Should return true for null (null-passthrough)", () => {
+			expect(PLAIN_OBJECT.checkAlgorithm(null)).toBe(true);
+		});
+
+		test("Should return true for undefined (null-passthrough)", () => {
+			expect(PLAIN_OBJECT.checkAlgorithm(undefined)).toBe(true);
+		});
+
+		test("Should return string for an array", () => {
+			const result = PLAIN_OBJECT.checkAlgorithm([]);
+			expect(typeof result).toBe("string");
+			expect(result).toContain("ARRAY");
+		});
+
+		test("Should return string for a non-empty array", () => {
+			const result = PLAIN_OBJECT.checkAlgorithm([1, 2, 3]);
+			expect(typeof result).toBe("string");
+			expect(result).toContain("ARRAY");
+		});
+
+		test("Should return string for a string value", () => {
+			const result = PLAIN_OBJECT.checkAlgorithm("hello");
+			expect(typeof result).toBe("string");
+			expect(result).toContain("PLAIN_OBJECT");
+		});
+
+		test("Should return string for a number", () => {
+			const result = PLAIN_OBJECT.checkAlgorithm(42);
+			expect(typeof result).toBe("string");
+			expect(result).toContain("PLAIN_OBJECT");
+		});
+	});
+
+	describe("tsCheck", () => {
+		test("Should return the value when it is a plain object", () => {
+			const value = { x: 1 };
+			expect(PLAIN_OBJECT.tsCheck(value)).toBe(value);
+		});
+
+		test("Should throw DBC.Infringement when value is an array", () => {
+			expect(() => PLAIN_OBJECT.tsCheck([] as any)).toThrow(DBC.Infringement);
+		});
+
+		test("Should throw DBC.Infringement when value is a string", () => {
+			expect(() => PLAIN_OBJECT.tsCheck("oops" as any)).toThrow(
+				DBC.Infringement,
+			);
+		});
+
+		test("Should include hint in the infringement message", () => {
+			expect(() =>
+				PLAIN_OBJECT.tsCheck([] as any, "must be a plain object"),
+			).toThrow(/must be a plain object/);
+		});
+
+		test("Should include id in the infringement message", () => {
+			expect(() =>
+				PLAIN_OBJECT.tsCheck(42 as any, undefined, "optionsParam"),
+			).toThrow(/optionsParam/);
+		});
+	});
+});

package/__tests__/DBC/REGEX.test.ts

@@ -1,17 +1,17 @@
-import { REGEX } from "../../src/DBC/REGEX";
-
-describe("REGEX", () => {
-	const regex = new REGEX(/^a$/);
-
-	test("Should not report infringement with 'a' to check", () => {
-		expect(regex.check("a")).toBe(true);
-	});
-
-	test("Should report infringement with 'c' to check", () => {
-		expect(typeof regex.check("c")).toBe("string");
-	});
-
-	test("Should not report infringement with empty string", () => {
-		expect(regex.check("")).toBe(true);
-	});
-});
+import { REGEX } from "../../src/DBC/REGEX";
+
+describe("REGEX", () => {
+	const regex = new REGEX(/^a$/);
+
+	test("Should not report infringement with 'a' to check", () => {
+		expect(regex.check("a")).toBe(true);
+	});
+
+	test("Should report infringement with 'c' to check", () => {
+		expect(typeof regex.check("c")).toBe("string");
+	});
+
+	test("Should not report infringement with empty string", () => {
+		expect(regex.check("")).toBe(true);
+	});
+});

package/__tests__/DBC/TYPE.test.ts

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

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

package/__tests__/DBC/ZOD.test.ts

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