umt 2.2.1 → 2.4.0

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

@@ -1,62 +0,0 @@
-"use strict";
-
-var _isDictionaryObject = require("@/Validate/isDictionaryObject");
-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,
-      bar: 2
-    })).toBe(true);
-  });
-  it("should return true for an object with boolean properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: true,
-      bar: false
-    })).toBe(true);
-  });
-  it("should return true for an object with mixed properties", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)({
-      foo: "bar",
-      baz: 1,
-      qux: true
-    })).toBe(true);
-  });
-  it("should return false for an array", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)([1, 2, 3])).toBe(false);
-  });
-  it("should return false for a string", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)("foo")).toBe(false);
-  });
-  it("should return false for a number", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(42)).toBe(false);
-  });
-  it("should return false for a boolean", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(true)).toBe(false);
-  });
-  it("should return false for null", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(null)).toBe(false);
-  });
-  it("should return false for undefined", function () {
-    expect((0, _isDictionaryObject.isDictionaryObject)(undefined)).toBe(false);
-  });
-});

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

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

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

@@ -1,47 +0,0 @@
-"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)(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);
-    expect((0, _isDouble.isDouble)(false)).toBe(false);
-    expect((0, _isDouble.isDouble)({})).toBe(false);
-    expect((0, _isDouble.isDouble)([])).toBe(false);
-    expect((0, _isDouble.isDouble)(0x12)).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/isEqual.test.d.ts

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

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

@@ -1,74 +0,0 @@
-"use strict";
-
-var _isEqual = require("@/Validate/isEqual");
-var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-describe("isEqual", function () {
-  it("should compare primitive values correctly", function () {
-    expect((0, _isEqual.isEqual)(1, 1)).toBe(true);
-    expect((0, _isEqual.isEqual)("test", "test")).toBe(true);
-    expect((0, _isEqual.isEqual)(true, true)).toBe(true);
-    expect((0, _isEqual.isEqual)(null, null)).toBe(true);
-    expect((0, _isEqual.isEqual)(undefined, undefined)).toBe(true);
-    expect((0, _isEqual.isEqual)(Number.NaN, Number.NaN)).toBe(true);
-  });
-  it("should return false for different primitive values", function () {
-    expect((0, _isEqual.isEqual)(1, 2)).toBe(false);
-    expect((0, _isEqual.isEqual)("test", "other")).toBe(false);
-    expect((0, _isEqual.isEqual)(true, false)).toBe(false);
-    expect((0, _isEqual.isEqual)(null, undefined)).toBe(false);
-  });
-  it("should handle object references correctly", function () {
-    var obj = {
-      a: 1
-    };
-    expect((0, _isEqual.isEqual)(obj, obj)).toBe(true);
-    expect((0, _isEqual.isEqual)(obj, {
-      a: 1
-    })).toBe(false);
-  });
-  it("should handle array references correctly", function () {
-    var arr = [1, 2, 3];
-    expect((0, _isEqual.isEqual)(arr, arr)).toBe(true);
-    expect((0, _isEqual.isEqual)(arr, [1, 2, 3])).toBe(false);
-  });
-  it("should distinguish between -0 and +0", function () {
-    expect((0, _isEqual.isEqual)(-0, +0)).toBe(false);
-  });
-
-  // lodash tests
-  it("should compare primitive values correctly (using lodash)", function () {
-    expect(_lodash["default"].isEqual(1, 1)).toBe(true);
-    expect(_lodash["default"].isEqual("test", "test")).toBe(true);
-    expect(_lodash["default"].isEqual(true, true)).toBe(true);
-    expect(_lodash["default"].isEqual(null, null)).toBe(true);
-    expect(_lodash["default"].isEqual(undefined, undefined)).toBe(true);
-    expect(_lodash["default"].isEqual(Number.NaN, Number.NaN)).toBe(true);
-  });
-  it("should return false for different primitive values (using lodash)", function () {
-    expect(_lodash["default"].isEqual(1, 2)).toBe(false);
-    expect(_lodash["default"].isEqual("test", "other")).toBe(false);
-    expect(_lodash["default"].isEqual(true, false)).toBe(false);
-    expect(_lodash["default"].isEqual(null, undefined)).toBe(false);
-  });
-  it("should handle object references correctly (using lodash)", function () {
-    var obj = {
-      a: 1
-    };
-    expect(_lodash["default"].isEqual(obj, obj)).toBe(true);
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(obj, {
-      a: 1
-    })).toBe(true);
-  });
-  it("should handle array references correctly (using lodash)", function () {
-    var arr = [1, 2, 3];
-    expect(_lodash["default"].isEqual(arr, arr)).toBe(true);
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(arr, [1, 2, 3])).toBe(true);
-  });
-  it("should distinguish between -0 and +0 (using lodash)", function () {
-    // This test returns true because the implementation of lodash and isEqual is different.
-    expect(_lodash["default"].isEqual(-0, +0)).toBe(true);
-  });
-});

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

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

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

@@ -1,43 +0,0 @@
-"use strict";
-
-var _isNotEmpty = require("@/Validate/isNotEmpty");
-describe("isNotEmpty", function () {
-  it("should return true for a non-empty object", function () {
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: 1
-    })).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: 1,
-      b: 2
-    })).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)({
-      a: {
-        b: 2
-      }
-    })).toBe(true);
-  });
-  it("should return false for an empty object", function () {
-    expect((0, _isNotEmpty.isNotEmpty)({})).toBe(false);
-  });
-  it("should return true for a non-empty array", function () {
-    expect((0, _isNotEmpty.isNotEmpty)([1, 2, 3])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)(["a", "b", "c"])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)([true, false])).toBe(true);
-    expect((0, _isNotEmpty.isNotEmpty)([{
-      a: 1
-    }, {
-      b: 2
-    }])).toBe(true);
-  });
-  it("should return false for an empty array", function () {
-    expect((0, _isNotEmpty.isNotEmpty)([])).toBe(false);
-  });
-
-  // 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);
-    expect((0, _isNotEmpty.isNotEmpty)(new Map())).toBe(false);
-    expect((0, _isNotEmpty.isNotEmpty)(new Set())).toBe(false);
-  });
-});

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

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

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

@@ -1,77 +0,0 @@
-"use strict";
-
-var _isNumber = require("@/Validate/isNumber");
-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("isNumber", function () {
-  describe("integers and decimals", function () {
-    test("should return true for integer numbers", function () {
-      expect((0, _isNumber.isNumber)(5)).toBe(true);
-      expect((0, _isNumber.isNumber)(-5)).toBe(true);
-      expect((0, _isNumber.isNumber)(0)).toBe(true);
-    });
-    test("should return true for decimal numbers", function () {
-      expect((0, _isNumber.isNumber)(5.5)).toBe(true);
-      expect((0, _isNumber.isNumber)(-5.5)).toBe(true);
-      expect((0, _isNumber.isNumber)(0.0)).toBe(true);
-    });
-  });
-  describe("string representations (loose mode)", function () {
-    test("should return true for valid number strings when loose is true", function () {
-      expect((0, _isNumber.isNumber)("5", true)).toBe(true);
-      expect((0, _isNumber.isNumber)("-5.5", true)).toBe(true);
-      expect((0, _isNumber.isNumber)("0", true)).toBe(true);
-    });
-    test("should return false for invalid number strings", function () {
-      expect((0, _isNumber.isNumber)("abc", true)).toBe(false);
-      expect((0, _isNumber.isNumber)("5abc", true)).toBe(false);
-    });
-    test("should return false for number strings when loose is false", function () {
-      expect((0, _isNumber.isNumber)("5", false)).toBe(false);
-      expect((0, _isNumber.isNumber)("-5.5", false)).toBe(false);
-    });
-    test("should handle empty string", function () {
-      expect((0, _isNumber.isNumber)("")).toBe(true); // Due to isFinite("") returning true
-    });
-  });
-  describe("special number values", function () {
-    test("should return false for NaN", function () {
-      expect((0, _isNumber.isNumber)(Number.NaN)).toBe(false);
-    });
-    test("should return false for Infinity", function () {
-      expect((0, _isNumber.isNumber)(Number.POSITIVE_INFINITY)).toBe(false);
-      expect((0, _isNumber.isNumber)(Number.NEGATIVE_INFINITY)).toBe(false);
-    });
-  });
-  describe("non-number types", function () {
-    test("should return false for null and undefined", function () {
-      expect((0, _isNumber.isNumber)(null)).toBe(false);
-      expect((0, _isNumber.isNumber)(undefined)).toBe(false);
-    });
-    test("should return false for booleans", function () {
-      expect((0, _isNumber.isNumber)(true)).toBe(false);
-      expect((0, _isNumber.isNumber)(false)).toBe(false);
-    });
-    test("should return false for objects and arrays", function () {
-      expect((0, _isNumber.isNumber)({})).toBe(false);
-      expect((0, _isNumber.isNumber)([])).toBe(false);
-    });
-  });
-  describe("type guard functionality", function () {
-    test("should work as a type guard in loose mode", function () {
-      var value = "123";
-      if ((0, _isNumber.isNumber)(value)) {
-        // TypeScript should recognize value as number | string
-        expect(typeof value === "string" || typeof value === "number").toBe(true);
-        expect(Number(value)).toBe(123);
-      }
-    });
-    test("should work as a type guard in strict mode", function () {
-      var value = 123;
-      if ((0, _isNumber.isNumber)(value, false)) {
-        // TypeScript should recognize value as number
-        expect(_typeof(value)).toBe("number");
-        expect(value).toBe(123);
-      }
-    });
-  });
-});

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

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

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

@@ -1,27 +0,0 @@
-"use strict";
-
-var _isPerfectSquare = require("@/Validate/isPerfectSquare");
-describe("isPerfectSquare", function () {
-  it("should return true for a perfect square", function () {
-    expect((0, _isPerfectSquare.isPerfectSquare)(16)).toBe(true);
-    expect((0, _isPerfectSquare.isPerfectSquare)(25)).toBe(true);
-    expect((0, _isPerfectSquare.isPerfectSquare)(49)).toBe(true);
-    expect((0, _isPerfectSquare.isPerfectSquare)(0)).toBe(true);
-  });
-  it("should return false for a non-perfect square", function () {
-    expect((0, _isPerfectSquare.isPerfectSquare)(20)).toBe(false);
-    expect((0, _isPerfectSquare.isPerfectSquare)(-16)).toBe(false);
-  });
-  it("should return true for 1", function () {
-    expect((0, _isPerfectSquare.isPerfectSquare)(1)).toBe(true);
-  });
-  it("should handle large numbers", function () {
-    expect((0, _isPerfectSquare.isPerfectSquare)(100000000)).toBe(true);
-    expect((0, _isPerfectSquare.isPerfectSquare)(100000002)).toBe(false);
-  });
-  it("should handle non-integer numbers", function () {
-    expect((0, _isPerfectSquare.isPerfectSquare)(4.0)).toBe(true); // 4.0 is treated as integer 4
-    expect((0, _isPerfectSquare.isPerfectSquare)(4.5)).toBe(false);
-    expect((0, _isPerfectSquare.isPerfectSquare)(2.25)).toBe(false);
-  });
-});

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

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

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

@@ -1,51 +0,0 @@
-"use strict";
-
-var _isPrimeNumber = require("@/Validate/isPrimeNumber");
-describe("isPrimeNumber", function () {
-  test("returns false for numbers less than or equal to 1", function () {
-    expect((0, _isPrimeNumber.isPrimeNumber)(0)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(1)).toBe(false);
-  });
-  test("returns true for prime numbers", function () {
-    expect((0, _isPrimeNumber.isPrimeNumber)(2)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(3)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(5)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(7)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(11)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(13)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(17)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(19)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(23)).toBe(true);
-    expect((0, _isPrimeNumber.isPrimeNumber)(29)).toBe(true);
-  });
-  test("returns false for composite numbers", function () {
-    expect((0, _isPrimeNumber.isPrimeNumber)(4)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(6)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(8)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(9)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(10)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(12)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(14)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(15)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(16)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(18)).toBe(false);
-  });
-  test("should return false for negative numbers", function () {
-    expect((0, _isPrimeNumber.isPrimeNumber)(-2)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(-7)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(-11)).toBe(false);
-  });
-  test("should return false for non-integer numbers", function () {
-    expect((0, _isPrimeNumber.isPrimeNumber)(2.5)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(3.14)).toBe(false);
-    expect((0, _isPrimeNumber.isPrimeNumber)(7.0)).toBe(true); // 7.0 is treated as integer 7
-  });
-  test("should handle large non-prime numbers", function () {
-    var largeNonPrimeNumber = 10000000000000; // 10^13
-    expect((0, _isPrimeNumber.isPrimeNumber)(largeNonPrimeNumber)).toBe(false);
-  });
-  test("should handle large prime numbers", function () {
-    var largePrimeNumber = 982451653; // 982,451,653 is a known prime number
-    expect((0, _isPrimeNumber.isPrimeNumber)(largePrimeNumber)).toBe(true);
-  });
-});

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

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

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

@@ -1,54 +0,0 @@
-"use strict";
-
-var _isValueNaN = require("@/Validate/isValueNaN");
-describe("isValueNaN function", function () {
-  describe("strict mode (loose = false)", function () {
-    it("should return false for valid numbers", function () {
-      expect((0, _isValueNaN.isValueNaN)(0)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)(1)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)(-1)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)(Number.POSITIVE_INFINITY)).toBe(false);
-    });
-    it("should return true for NaN", function () {
-      expect((0, _isValueNaN.isValueNaN)(Number.NaN)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)(Number.parseInt("not a number"))).toBe(true);
-    });
-    it("should return false for string values", function () {
-      expect((0, _isValueNaN.isValueNaN)("NaN")).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("0")).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("a")).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("")).toBe(false);
-    });
-    it("should return false for non-number types", function () {
-      expect((0, _isValueNaN.isValueNaN)(undefined)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)(null)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)({})).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)([])).toBe(false);
-    });
-  });
-  describe("loose mode (loose = true)", function () {
-    it("should return false for valid number strings", function () {
-      expect((0, _isValueNaN.isValueNaN)("0", true)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("1", true)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("-1", true)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)("Infinity", true)).toBe(false);
-    });
-    it("should return true for NaN and NaN strings", function () {
-      expect((0, _isValueNaN.isValueNaN)(Number.NaN, true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)("NaN", true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)(Number.parseInt("not a number"), true)).toBe(true);
-    });
-    it("should handle non-numeric strings correctly", function () {
-      expect((0, _isValueNaN.isValueNaN)("a", true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)("abc", true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)("", true)).toBe(false); // isNaN("") returns false
-      expect((0, _isValueNaN.isValueNaN)(" ", true)).toBe(false); // isNaN(" ") returns false (coerced to 0)
-    });
-    it("should handle non-string/non-number types", function () {
-      expect((0, _isValueNaN.isValueNaN)(undefined, true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)(null, true)).toBe(false);
-      expect((0, _isValueNaN.isValueNaN)({}, true)).toBe(true);
-      expect((0, _isValueNaN.isValueNaN)([], true)).toBe(false);
-    });
-  });
-});

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

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

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

@@ -1,36 +0,0 @@
-"use strict";
-
-var _core = require("@/Validate/number/core");
-var _maxValue = require("@/Validate/number/maxValue");
-var _minValue = require("@/Validate/number/minValue");
-describe("number function", function () {
-  it("should validate number with no additional options", function () {
-    var validateNumber = (0, _core.number)();
-    expect(validateNumber(5).validate).toBeTruthy();
-    // @ts-ignore
-    expect(validateNumber("5").validate).toBeFalsy();
-  });
-  it("should validate number with max value option", function () {
-    var validateNumberMax = (0, _core.number)([(0, _maxValue.maxValue)(10)]);
-    expect(validateNumberMax(5).validate).toBeTruthy();
-    expect(validateNumberMax(11).validate).toBeFalsy();
-  });
-  it("should validate number with min value option", function () {
-    var validateNumberMin = (0, _core.number)([(0, _minValue.minValue)(3)]);
-    expect(validateNumberMin(5).validate).toBeTruthy();
-    expect(validateNumberMin(2).validate).toBeFalsy();
-  });
-  it("should validate number with both min and max value options", function () {
-    var validateNumberMinMax = (0, _core.number)([(0, _minValue.minValue)(3), (0, _maxValue.maxValue)(10)]);
-    expect(validateNumberMinMax(5).validate).toBeTruthy();
-    expect(validateNumberMinMax(2).validate).toBeFalsy();
-    expect(validateNumberMinMax(11).validate).toBeFalsy();
-  });
-  it("should return custom message on validation failure", function () {
-    var customMessage = "Value must be between 3 and 10";
-    var validateNumberMinMax = (0, _core.number)([(0, _minValue.minValue)(3, customMessage), (0, _maxValue.maxValue)(10)]);
-    var result = validateNumberMinMax(2);
-    expect(result.validate).toBeFalsy();
-    expect(result.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/double.test.d.ts

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

package/module/es5/tests/unit/Validate/number/double.test.js

@@ -1,23 +0,0 @@
-"use strict";
-
-var _double2 = require("@/Validate/number/double");
-describe("double", function () {
-  it("should return true for double numbers", function () {
-    var validateDouble = (0, _double2["double"])();
-    expect(validateDouble.validate(1.5)).toBe(true);
-    expect(validateDouble.validate(2.22)).toBe(true);
-    expect(validateDouble.validate(0.1)).toBe(true);
-  });
-  it("should return false for non-double numbers", function () {
-    var validateDouble = (0, _double2["double"])();
-    expect(validateDouble.validate(1)).toBe(false);
-    expect(validateDouble.validate(100)).toBe(false);
-    expect(validateDouble.validate(0)).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "This is not a double number";
-    var validateDouble = (0, _double2["double"])(customMessage);
-    expect(validateDouble.validate(1)).toBe(false);
-    expect(validateDouble.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/even.test.d.ts

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

package/module/es5/tests/unit/Validate/number/even.test.js

@@ -1,23 +0,0 @@
-"use strict";
-
-var _even = require("@/Validate/number/even");
-describe("even", function () {
-  it("should return true for even numbers", function () {
-    var validateEven = (0, _even.even)();
-    expect(validateEven.validate(2)).toBe(true);
-    expect(validateEven.validate(4)).toBe(true);
-    expect(validateEven.validate(6)).toBe(true);
-  });
-  it("should return false for odd numbers", function () {
-    var validateEven = (0, _even.even)();
-    expect(validateEven.validate(1)).toBe(false);
-    expect(validateEven.validate(3)).toBe(false);
-    expect(validateEven.validate(5)).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "This is a custom message";
-    var validateEven = (0, _even.even)(customMessage);
-    expect(validateEven.validate(1)).toBe(false);
-    expect(validateEven.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/maxValue.test.d.ts

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

package/module/es5/tests/unit/Validate/number/maxValue.test.js

@@ -1,20 +0,0 @@
-"use strict";
-
-var _maxValue = require("@/Validate/number/maxValue");
-describe("maxValue", function () {
-  it("should return true for numbers less than or equal to the max value", function () {
-    var validateMaxValue = (0, _maxValue.maxValue)(10);
-    expect(validateMaxValue.validate(5)).toBe(true);
-    expect(validateMaxValue.validate(10)).toBe(true);
-  });
-  it("should return false for numbers greater than the max value", function () {
-    var validateMaxValue = (0, _maxValue.maxValue)(10);
-    expect(validateMaxValue.validate(11)).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "Value must be less than or equal to 10";
-    var validateMaxValue = (0, _maxValue.maxValue)(10, customMessage);
-    expect(validateMaxValue.validate(11)).toBe(false);
-    expect(validateMaxValue.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/minValue.test.d.ts

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

package/module/es5/tests/unit/Validate/number/minValue.test.js

@@ -1,20 +0,0 @@
-"use strict";
-
-var _minValue = require("@/Validate/number/minValue");
-describe("minValue", function () {
-  it("should return true for numbers greater than or equal to the minimum value", function () {
-    var validateMinValue = (0, _minValue.minValue)(10);
-    expect(validateMinValue.validate(10)).toBe(true);
-    expect(validateMinValue.validate(15)).toBe(true);
-  });
-  it("should return false for numbers less than the minimum value", function () {
-    var validateMinValue = (0, _minValue.minValue)(10);
-    expect(validateMinValue.validate(9)).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "Value must be at least 10";
-    var validateMinValue = (0, _minValue.minValue)(10, customMessage);
-    expect(validateMinValue.validate(9)).toBe(false);
-    expect(validateMinValue.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/odd.test.d.ts

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

package/module/es5/tests/unit/Validate/number/odd.test.js

@@ -1,23 +0,0 @@
-"use strict";
-
-var _odd = require("@/Validate/number/odd");
-describe("odd", function () {
-  it("should return true for odd numbers", function () {
-    var validateOdd = (0, _odd.odd)();
-    expect(validateOdd.validate(1)).toBe(true);
-    expect(validateOdd.validate(3)).toBe(true);
-    expect(validateOdd.validate(5)).toBe(true);
-  });
-  it("should return false for even numbers", function () {
-    var validateOdd = (0, _odd.odd)();
-    expect(validateOdd.validate(2)).toBe(false);
-    expect(validateOdd.validate(4)).toBe(false);
-    expect(validateOdd.validate(6)).toBe(false);
-  });
-  it("should return the custom message for invalid input", function () {
-    var customMessage = "This is a custom message";
-    var validateOdd = (0, _odd.odd)(customMessage);
-    expect(validateOdd.validate(2)).toBe(false);
-    expect(validateOdd.message).toBe(customMessage);
-  });
-});

package/module/es5/tests/unit/Validate/number/prime.test.d.ts

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