umt 2.1.2 → 2.2.0

package/module/es5/tests/unit/UA/extractBrowserFromUserAgent.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _extractBrowserFromUserAgent = require("@/UA/extractBrowserFromUserAgent");
+describe("extractBrowserFromUserAgent", function () {
+  it("should detect Edge browser", function () {
+    var edgeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.57";
+    var legacyEdgeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edge/89.0.774.57";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(edgeUA)).toBe("edge");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(legacyEdgeUA)).toBe("edge");
+  });
+  it("should detect desktop Chrome browser", function () {
+    var chromeUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(chromeUA)).toBe("chrome");
+  });
+  it("should detect iOS Chrome browser (CriOS)", function () {
+    var chromeIosUA = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/89.0.4389.90 Mobile/15E148 Safari/604.1";
+    var chromeIpadUA = "Mozilla/5.0 (iPad; CPU OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/89.0.4389.90 Mobile/15E148 Safari/604.1";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(chromeIosUA)).toBe("chrome");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(chromeIpadUA)).toBe("chrome");
+  });
+  it("should detect Firefox browser", function () {
+    var firefoxUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:88.0) Gecko/20100101 Firefox/88.0";
+    var firefoxIosUA = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/33.0 Mobile/15E148 Safari/605.1.15";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(firefoxUA)).toBe("firefox");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(firefoxIosUA)).toBe("firefox");
+  });
+  it("should detect Safari browser", function () {
+    var safariUA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Safari/605.1.15";
+    var mobileSafariUA = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(safariUA)).toBe("safari");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(mobileSafariUA)).toBe("safari");
+  });
+  it("should detect Internet Explorer", function () {
+    var ie11UA = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
+    var ie10UA = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(ie11UA)).toBe("ie");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(ie10UA)).toBe("ie");
+  });
+  it("should return 'other' for unknown browsers", function () {
+    var operaUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 OPR/75.0.3969.149";
+    var unknownUA = "Unknown Browser";
+    var emptyUA = "";
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(operaUA)).toBe("other");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(unknownUA)).toBe("other");
+    expect((0, _extractBrowserFromUserAgent.extractBrowserFromUserAgent)(emptyUA)).toBe("other");
+  });
+});

package/module/es5/tests/unit/UA/extractDeviceFromUserAgent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/UA/extractDeviceFromUserAgent.test.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _extractDeviceFromUserAgent = require("@/UA/extractDeviceFromUserAgent");
+describe("extractDeviceFromUserAgent", function () {
+  it("should detect bots and crawlers", function () {
+    var googlebot = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    var bingbot = "Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)";
+    var crawler = "Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(googlebot)).toBe("bot");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(bingbot)).toBe("bot");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(crawler)).toBe("bot");
+  });
+  it("should detect mobile devices", function () {
+    var iphone = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1";
+    var androidMobile = "Mozilla/5.0 (Linux; Android 10; SM-A505FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Mobile Safari/537.36";
+    var blackberry = "Mozilla/5.0 (BlackBerry; U; BlackBerry 9900; en) AppleWebKit/534.11+ (KHTML, like Gecko) Version/7.1.0.346 Mobile Safari/534.11+";
+    var operaMini = "Opera/9.80 (J2ME/MIDP; Opera Mini/5.1.21214/28.2725; U; ru) Presto/2.8.119 Version/11.10";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(iphone)).toBe("mobile");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(androidMobile)).toBe("mobile");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(blackberry)).toBe("mobile");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(operaMini)).toBe("mobile");
+  });
+  it("should detect tablets", function () {
+    var ipad = "Mozilla/5.0 (iPad; CPU OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1";
+    var androidTablet = "Mozilla/5.0 (Linux; Android 11; SM-T870) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    var androidNonMobile = "Mozilla/5.0 (Linux; Android 11; SAMSUNG-SM-T377A Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(ipad)).toBe("tablet");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(androidTablet)).toBe("tablet");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(androidNonMobile)).toBe("tablet");
+  });
+  it("should detect desktop devices", function () {
+    var windows = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    var mac = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Safari/605.1.15";
+    var linux = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(windows)).toBe("desktop");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(mac)).toBe("desktop");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(linux)).toBe("desktop");
+  });
+  it("should handle unknown devices", function () {
+    var empty = "";
+    var unknown = "Unknown Device";
+    var customDevice = "Mozilla/5.0 (CustomOS; Device) CustomBrowser/1.0";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(empty)).toBe("other");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(unknown)).toBe("other");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(customDevice)).toBe("other");
+  });
+  it("should handle Android edge cases", function () {
+    // Android device with explicit mobile flag
+    var androidMobile = "Mozilla/5.0 (Linux; Android 10; Mobile) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    // Android device without mobile flag (should be detected as tablet)
+    var androidNonMobile = "Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(androidMobile)).toBe("mobile");
+    expect((0, _extractDeviceFromUserAgent.extractDeviceFromUserAgent)(androidNonMobile)).toBe("tablet");
+  });
+});

package/module/es5/tests/unit/UA/extractOsFromUserAgent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/UA/extractOsFromUserAgent.test.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _extractOsFromUserAgent = require("@/UA/extractOsFromUserAgent");
+describe("extractOsFromUserAgent", function () {
+  it("should detect iOS devices", function () {
+    var iphone = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Mobile/15E148 Safari/604.1";
+    var ipad = "Mozilla/5.0 (iPad; CPU OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1";
+    var ipod = "Mozilla/5.0 (iPod touch; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Mobile/15E148 Safari/604.1";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(iphone)).toBe("ios");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(ipad)).toBe("ios");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(ipod)).toBe("ios");
+  });
+  it("should detect Android devices", function () {
+    var androidPhone = "Mozilla/5.0 (Linux; Android 10; SM-A505FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Mobile Safari/537.36";
+    var androidTablet = "Mozilla/5.0 (Linux; Android 11; SM-T870) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    var androidTV = "Mozilla/5.0 (Linux; Android 10; AndroidTV) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(androidPhone)).toBe("android");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(androidTablet)).toBe("android");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(androidTV)).toBe("android");
+  });
+  it("should detect macOS devices", function () {
+    var macOsSafari = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1 Safari/605.1.15";
+    var macOsChrome = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    var macOsFirefox = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:88.0) Gecko/20100101 Firefox/88.0";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(macOsSafari)).toBe("macos");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(macOsChrome)).toBe("macos");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(macOsFirefox)).toBe("macos");
+  });
+  it("should detect Windows devices", function () {
+    var win10Edge = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36 Edg/89.0.774.57";
+    var win10Chrome = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    var win7IE = "Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko";
+    var win32UA = "Mozilla/5.0 (Win32; x86) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(win10Edge)).toBe("windows");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(win10Chrome)).toBe("windows");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(win7IE)).toBe("windows");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(win32UA)).toBe("windows");
+  });
+  it("should detect Linux devices", function () {
+    var ubuntuChrome = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    var fedoraFirefox = "Mozilla/5.0 (X11; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0";
+    var genericLinux = "Mozilla/5.0 (Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(ubuntuChrome)).toBe("linux");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(fedoraFirefox)).toBe("linux");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(genericLinux)).toBe("linux");
+  });
+  it("should handle unknown operating systems", function () {
+    var empty = "";
+    var unknown = "Unknown OS";
+    var customOs = "Mozilla/5.0 (CustomOS) CustomBrowser/1.0";
+    var bot = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(empty)).toBe("other");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(unknown)).toBe("other");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(customOs)).toBe("other");
+    expect((0, _extractOsFromUserAgent.extractOsFromUserAgent)(bot)).toBe("other");
+  });
+});

package/module/es5/tests/unit/Unit/unitConverterInitialization.test.js

@@ -1,38 +1,40 @@
 "use strict";
 
 var _unitConverterInitialization = require("@/Unit/unitConverterInitialization");
-var convertWaterUnit = (0, _unitConverterInitialization.unitConverterInitialization)({
-  L: 1,
-  mL: 1000,
-  cup: 4.227,
-  m3: 0.001
+// Example unit converter for length measurements
+var convertLength = (0, _unitConverterInitialization.unitConverterInitialization)({
+  meters: 1,
+  // base unit
+  kilometers: 0.001,
+  centimeters: 100,
+  millimeters: 1000
 });
-describe("convertWaterUnit", function () {
-  it("should correctly convert between L and mL", function () {
-    expect(convertWaterUnit(1, "L", "mL")).toBeCloseTo(1000);
-    expect(convertWaterUnit(1000, "mL", "L")).toBeCloseTo(1);
+describe("Unit Converter", function () {
+  it("converts between base unit and larger units", function () {
+    expect(convertLength(1000, "meters", "kilometers")).toBeCloseTo(1);
+    expect(convertLength(1, "kilometers", "meters")).toBeCloseTo(1000);
   });
-  it("should correctly convert between L and cup", function () {
-    expect(convertWaterUnit(1, "L", "cup")).toBeCloseTo(4.227);
-    expect(convertWaterUnit(1, "cup", "L")).toBeCloseTo(0.237);
+  it("converts between base unit and smaller units", function () {
+    expect(convertLength(1, "meters", "centimeters")).toBeCloseTo(100);
+    expect(convertLength(100, "centimeters", "meters")).toBeCloseTo(1);
   });
-  it("should correctly convert between L and m3", function () {
-    expect(convertWaterUnit(1, "m3", "L")).toBeCloseTo(1000);
-    expect(convertWaterUnit(1000, "L", "m3")).toBeCloseTo(1);
+  it("converts between different small units", function () {
+    expect(convertLength(100, "centimeters", "millimeters")).toBeCloseTo(1000);
+    expect(convertLength(1000, "millimeters", "centimeters")).toBeCloseTo(100);
   });
-  it("should handle zero values correctly", function () {
-    expect(convertWaterUnit(0, "L", "mL")).toBe(0);
-    expect(convertWaterUnit(0, "cup", "m3")).toBe(0);
+  it("handles zero values correctly", function () {
+    expect(convertLength(0, "meters", "kilometers")).toBe(0);
+    expect(convertLength(0, "millimeters", "centimeters")).toBe(0);
   });
-  it("should return same value when converting to same unit", function () {
-    expect(convertWaterUnit(5, "L", "L")).toBe(5);
-    expect(convertWaterUnit(100, "mL", "mL")).toBe(100);
+  it("returns same value when converting to same unit", function () {
+    expect(convertLength(5, "meters", "meters")).toBe(5);
+    expect(convertLength(100, "centimeters", "centimeters")).toBe(100);
   });
-  it("should maintain value in round-trip conversions", function () {
+  it("maintains precision in round-trip conversions", function () {
     var original = 5;
-    var roundTrip = convertWaterUnit(convertWaterUnit(original, "L", "mL"), "mL", "L");
+    var roundTrip = convertLength(convertLength(original, "meters", "kilometers"), "kilometers", "meters");
     expect(roundTrip).toBeCloseTo(original);
-    var cupRoundTrip = convertWaterUnit(convertWaterUnit(original, "cup", "m3"), "m3", "cup");
-    expect(cupRoundTrip).toBeCloseTo(original);
+    var smallUnitsRoundTrip = convertLength(convertLength(original, "centimeters", "millimeters"), "millimeters", "centimeters");
+    expect(smallUnitsRoundTrip).toBeCloseTo(original);
   });
 });

package/module/es5/tests/unit/Validate/array/core.test.js

@@ -3,12 +3,26 @@
 var _Validate = require("@/Validate");
 var _core = require("@/Validate/array/core");
 var _string = require("@/Validate/string");
-describe("array core validation", function () {
-  it("should validate an array of booleans", function () {
+describe("Array core validation", function () {
+  // Test for empty array
+  it("should validate an empty array", function () {
     var validateArray = (0, _core.array)();
-    expect(validateArray(["apple", "banana", "cherry"]).validate).toBe(true);
+    expect(validateArray([]).validate).toBe(true);
+  });
+
+  // Test for null and undefined
+  it("should fail validation for null and undefined", function () {
+    var validateArray = (0, _core.array)();
+    // @ts-ignore
+    expect(validateArray(null).validate).toBe(false);
+    // @ts-ignore
+    expect(validateArray(undefined).validate).toBe(false);
+  });
+  it("should validate an array of mixed values without type validation", function () {
+    var validateArray = (0, _core.array)();
+    expect(validateArray(["apple", true, 123]).validate).toBe(true);
   });
-  it("should validate an array of strings", function () {
+  it("should validate an array of strings with validation", function () {
     var validateArray = (0, _core.array)({
       string: (0, _string.string)()
     });
@@ -16,7 +30,7 @@ describe("array core validation", function () {
     // @ts-ignore
     expect(validateArray(["apple", 1, true]).validate).toBe(false);
   });
-  it("should validate an array of numbers", function () {
+  it("should validate an array of numbers with range validation", function () {
     var validateArray = (0, _core.array)({
       number: (0, _Validate.number)([(0, _Validate.minValue)(0), (0, _Validate.maxValue)(10)])
     });
@@ -25,7 +39,7 @@ describe("array core validation", function () {
     // @ts-ignore
     expect(validateArray([1, "2", 3]).validate).toBe(false);
   });
-  it("should validate an array of numbers and strings", function () {
+  it("should validate an array of mixed types with specific validations", function () {
     var validateArray = (0, _core.array)({
       string: (0, _string.string)([(0, _string.maxLength)(1)]),
       number: (0, _Validate.number)([(0, _Validate.minValue)(0), (0, _Validate.maxValue)(10)])
@@ -35,23 +49,38 @@ describe("array core validation", function () {
     expect(validateArray([1, "2", 3]).validate).toBe(true);
     expect(validateArray([1, 2, 3, "11"]).validate).toBe(false);
   });
-  it("should return a custom message on validation failure", function () {
+  it("should return a custom message on array type validation failure", function () {
     var customMessage = "Array validation failed";
     var validateArray = (0, _core.array)({
       string: (0, _string.string)()
     }, customMessage);
     // @ts-ignore
-    var result = validateArray(1);
+    var result = validateArray("not an array");
     expect(result.validate).toBe(false);
     expect(result.message).toBe(customMessage);
   });
-  it("should return an empty message on validation failure", function () {
+  it("should return element validation error message", function () {
+    var elementMessage = "String too long";
+    var validateArray = (0, _core.array)({
+      string: (0, _string.string)([(0, _string.maxLength)(3, elementMessage)])
+    });
+    var result = validateArray(["ok", "good", "toolong"]);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe(elementMessage);
+  });
+  it("should return an empty message when no custom message is provided", function () {
     var validateArray = (0, _core.array)({
       string: (0, _string.string)()
     });
     // @ts-ignore
-    var result = validateArray(1);
+    var result = validateArray("not an array");
     expect(result.validate).toBe(false);
     expect(result.message).toBe("");
   });
+  it("should preserve the original array in the return type", function () {
+    var testArray = [1, 2, 3];
+    var validateArray = (0, _core.array)();
+    var result = validateArray(testArray);
+    expect(result.type).toBe(testArray);
+  });
 });

package/module/es5/tests/unit/Validate/core/core.test.d.ts

@@ -0,0 +1 @@
+export {};

package/module/es5/tests/unit/Validate/core/core.test.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _core = require("@/Validate/core");
+describe("Core validation", function () {
+  it("should validate type correctly", function () {
+    var validateString = (0, _core.core)("string");
+    expect(validateString("test").validate).toBe(true);
+    // @ts-ignore
+    expect(validateString(123).validate).toBe(false);
+  });
+  it("should respect custom message for type validation", function () {
+    var message = "Not a string";
+    var validateString = (0, _core.core)("string");
+    // @ts-ignore
+    expect(validateString(123, [], message).message).toBe(message);
+  });
+  it("should return empty message when no message provided", function () {
+    var validateString = (0, _core.core)("string");
+    // @ts-ignore
+    expect(validateString(123).message).toBe("");
+  });
+  it("should validate with additional validation rules", function () {
+    var validateString = (0, _core.core)("string");
+    var minLength = {
+      type: "string",
+      validate: function validate(value) {
+        return value.length >= 3;
+      },
+      message: "String too short"
+    };
+    expect(validateString("test", [minLength]).validate).toBe(true);
+    expect(validateString("ab", [minLength]).validate).toBe(false);
+    expect(validateString("ab", [minLength]).message).toBe("String too short");
+
+    // Test validation rule without message
+    var noMessage = {
+      type: "string",
+      validate: function validate(value) {
+        return value.length >= 3;
+      }
+    };
+    expect(validateString("ab", [noMessage]).message).toBe("");
+  });
+  it("should validate numbers", function () {
+    var validateNumber = (0, _core.core)("number");
+    expect(validateNumber(123).validate).toBe(true);
+    // @ts-ignore
+    expect(validateNumber("123").validate).toBe(false);
+  });
+  it("should validate booleans", function () {
+    var validateBoolean = (0, _core.core)("boolean");
+    expect(validateBoolean(true).validate).toBe(true);
+    expect(validateBoolean(false).validate).toBe(true);
+    // @ts-ignore
+    expect(validateBoolean("true").validate).toBe(false);
+  });
+  it("should validate with multiple validation rules", function () {
+    var validateString = (0, _core.core)("string");
+    var minLength = {
+      type: "string",
+      validate: function validate(value) {
+        return value.length >= 3;
+      },
+      message: "String too short"
+    };
+    var maxLength = {
+      type: "string",
+      validate: function validate(value) {
+        return value.length <= 10;
+      },
+      message: "String too long"
+    };
+    expect(validateString("test", [minLength, maxLength]).validate).toBe(true);
+    expect(validateString("ab", [minLength, maxLength]).validate).toBe(false);
+    expect(validateString("ab", [minLength, maxLength]).message).toBe("String too short");
+    expect(validateString("very long string", [minLength, maxLength]).validate).toBe(false);
+    expect(validateString("very long string", [minLength, maxLength]).message).toBe("String too long");
+  });
+  it("should preserve type information in return value", function () {
+    var validateString = (0, _core.core)("string");
+    var validateNumber = (0, _core.core)("number");
+    var validateBoolean = (0, _core.core)("boolean");
+    expect(validateString("test").type).toBe("string");
+    expect(validateNumber(123).type).toBe("number");
+    expect(validateBoolean(true).type).toBe("boolean");
+  });
+});

package/module/es5/tests/unit/Validate/isArray.test.js

@@ -11,6 +11,17 @@ describe("isArray", function () {
     }, {
       b: 2
     }])).toBe(true);
+    expect((0, _isArray.isArray)([])).toBe(true);
+  });
+  it("should work as a type guard", function () {
+    var value = [1, 2, 3];
+    if ((0, _isArray.isArray)(value)) {
+      // TypeScript should recognize value as number[] here
+      var sum = value.reduce(function (a, b) {
+        return a + b;
+      }, 0);
+      expect(sum).toBe(6);
+    }
   });
   it("should return false for a non-array value", function () {
     expect((0, _isArray.isArray)(1)).toBe(false);

package/module/es5/tests/unit/Validate/isDictionaryObject.test.js

@@ -1,13 +1,27 @@
 "use strict";
 
 var _isDictionaryObject = require("@/Validate/isDictionaryObject");
-describe("isObj", function () {
+describe("isDictionaryObject", function () {
+  it("should return true for an empty object", function () {
+    expect((0, _isDictionaryObject.isDictionaryObject)({})).toBe(true);
+  });
   it("should return true for an object with string properties", function () {
     expect((0, _isDictionaryObject.isDictionaryObject)({
       foo: "bar",
       baz: "qux"
     })).toBe(true);
   });
+  it("should work as a type guard", function () {
+    var value = {
+      x: 1,
+      y: 2
+    };
+    if ((0, _isDictionaryObject.isDictionaryObject)(value)) {
+      // TypeScript should recognize value as { x: number; y: number }
+      var sum = value.x + value.y;
+      expect(sum).toBe(3);
+    }
+  });
   it("should return true for an object with number properties", function () {
     expect((0, _isDictionaryObject.isDictionaryObject)({
       foo: 1,

package/module/es5/tests/unit/Validate/isDouble.test.js

@@ -1,20 +1,37 @@
 "use strict";
 
 var _isDouble = require("@/Validate/isDouble");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 describe("isDouble", function () {
   it("should return true for valid doubles", function () {
     expect((0, _isDouble.isDouble)(1.5)).toBe(true);
+    expect((0, _isDouble.isDouble)(-1.5)).toBe(true);
+    expect((0, _isDouble.isDouble)(1.23e-4)).toBe(true);
     expect((0, _isDouble.isDouble)("1.5")).toBe(true);
     expect((0, _isDouble.isDouble)("1.5", false)).toBe(false);
   });
+  it("should work as a type guard", function () {
+    var value = 1.5;
+    if ((0, _isDouble.isDouble)(value)) {
+      // TypeScript should recognize value as number | string
+      expect(typeof value === "number" || typeof value === "string").toBe(true);
+      expect(Number(value)).toBe(1.5);
+    }
+    var strictValue = 1.5;
+    if ((0, _isDouble.isDouble)(strictValue, false)) {
+      // TypeScript should recognize strictValue as number
+      expect(_typeof(strictValue)).toBe("number");
+      expect(strictValue).toBe(1.5);
+    }
+  });
   it("should return false for invalid doubles", function () {
     expect((0, _isDouble.isDouble)(1)).toBe(false);
     expect((0, _isDouble.isDouble)(1, false)).toBe(false);
     expect((0, _isDouble.isDouble)("1")).toBe(false);
     expect((0, _isDouble.isDouble)("1", false)).toBe(false);
-    expect((0, _isDouble.isDouble)(NaN)).toBe(false);
-    expect((0, _isDouble.isDouble)(Infinity)).toBe(false);
-    expect((0, _isDouble.isDouble)(-Infinity)).toBe(false);
+    expect((0, _isDouble.isDouble)(Number.NaN)).toBe(false);
+    expect((0, _isDouble.isDouble)(Number.POSITIVE_INFINITY)).toBe(false);
+    expect((0, _isDouble.isDouble)(Number.NEGATIVE_INFINITY)).toBe(false);
     expect((0, _isDouble.isDouble)(null)).toBe(false);
     expect((0, _isDouble.isDouble)(undefined)).toBe(false);
     expect((0, _isDouble.isDouble)(true)).toBe(false);
@@ -22,7 +39,7 @@ describe("isDouble", function () {
     expect((0, _isDouble.isDouble)({})).toBe(false);
     expect((0, _isDouble.isDouble)([])).toBe(false);
     expect((0, _isDouble.isDouble)(0x12)).toBe(false);
-    expect((0, _isDouble.isDouble)(-Infinity, false)).toBe(false);
+    expect((0, _isDouble.isDouble)(Number.NEGATIVE_INFINITY, false)).toBe(false);
     expect((0, _isDouble.isDouble)(null, false)).toBe(false);
     expect((0, _isDouble.isDouble)(true, false)).toBe(false);
     expect((0, _isDouble.isDouble)(false, false)).toBe(false);

package/module/es5/tests/unit/Validate/isNotEmpty.test.js

@@ -32,11 +32,11 @@ describe("isNotEmpty", function () {
   it("should return false for an empty array", function () {
     expect((0, _isNotEmpty.isNotEmpty)([])).toBe(false);
   });
-  it("should return true for a non-empty Map or Set", function () {
+
+  // Note: Map and Set are always considered empty by Object.keys()
+  it("should return false for Map and Set (regardless of content)", function () {
     expect((0, _isNotEmpty.isNotEmpty)(new Map([["a", 1], ["b", 2]]))).toBe(false);
     expect((0, _isNotEmpty.isNotEmpty)(new Set([1, 2, 3]))).toBe(false);
-  });
-  it("should return false for an empty Map or Set", function () {
     expect((0, _isNotEmpty.isNotEmpty)(new Map())).toBe(false);
     expect((0, _isNotEmpty.isNotEmpty)(new Set())).toBe(false);
   });