umt 1.9.0 → 2.0.0

package/module/es5/tests/unit/Tool/createPipeline.test.js

@@ -0,0 +1,184 @@
+"use strict";
+
+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); }
+var _createPipeline = require("@/Tool/createPipeline");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+describe("createPipeline", function () {
+  it("引数なしで呼び出すと、初期値を返す", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(1);
+    expect(pipeline()).toBe(1);
+  });
+  it("関数を引数として渡すと、新しいPipelineインスタンスを返す", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(1);
+    var newPipeline = pipeline(function (x) {
+      return x + 1;
+    });
+    expect(newPipeline).toBeInstanceOf(Function);
+  });
+  it("関数を引数として渡して呼び出すと、変換された値を返す", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(1);
+    var newPipeline = pipeline(function (x) {
+      return x + 1;
+    });
+    expect(newPipeline()).toBe(2);
+  });
+  it("複数の関数を連鎖して呼び出すことができる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(1);
+    var result = pipeline(function (x) {
+      return x + 1;
+    })(function (x) {
+      return x * 2;
+    })(function (x) {
+      return x - 1;
+    })();
+    expect(result).toBe(3);
+  });
+  it("関数の型が正しく推論される", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(1);
+    var newPipeline = pipeline(function (x) {
+      return "".concat(x);
+    });
+    var result = newPipeline();
+    expect(result).toBe("1");
+  });
+  it("複雑な型の推論が正しく行われる", function () {
+    var user = {
+      id: 1,
+      name: "John Doe",
+      age: 30
+    };
+    var pipeline = (0, _createPipeline.createPipeline)(user);
+    var post = pipeline(function (user) {
+      return {
+        id: 1,
+        title: "First Post",
+        content: "Hello, world!",
+        author: user
+      };
+    })();
+    expect(post).toEqual({
+      id: 1,
+      title: "First Post",
+      content: "Hello, world!",
+      author: {
+        id: 1,
+        name: "John Doe",
+        age: 30
+      }
+    });
+  });
+  it("ジェネリック型のネストが正しく推論される", function () {
+    var pipeline = (0, _createPipeline.createPipeline)([]);
+    var users = pipeline(function (users) {
+      return [].concat(_toConsumableArray(users), [{
+        id: 1,
+        name: "John Doe",
+        age: 30
+      }]);
+    })(function (users) {
+      return [].concat(_toConsumableArray(users), [{
+        id: 2,
+        name: "Jane Smith",
+        age: 25
+      }]);
+    })();
+    expect(users).toEqual([{
+      id: 1,
+      name: "John Doe",
+      age: 30
+    }, {
+      id: 2,
+      name: "Jane Smith",
+      age: 25
+    }]);
+  });
+  it("initialValueがnullの場合も正しく動作する", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(null);
+    expect(pipeline()).toBeNull();
+  });
+  it("initialValueがundefinedの場合も正しく動作する", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(undefined);
+    expect(pipeline()).toBeUndefined();
+  });
+  it("空文字列を正しく処理できる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)("");
+    var result = pipeline(function (x) {
+      return x + "test";
+    })(function (x) {
+      return x.toUpperCase();
+    })();
+    expect(result).toBe("TEST");
+  });
+  it("数値の0を正しく処理できる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(0);
+    var result = pipeline(function (x) {
+      return x + 1;
+    })(function (x) {
+      return x * 2;
+    })();
+    expect(result).toBe(2);
+  });
+  it("真偽値の変換を正しく処理できる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(true);
+    var result = pipeline(function (x) {
+      return !x;
+    })(function (x) {
+      return x.toString();
+    })();
+    expect(result).toBe("false");
+  });
+  it("配列の変換を正しく処理できる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)([1, 2, 3, 4, 5]);
+    var result = pipeline(function (arr) {
+      return arr.filter(function (x) {
+        return x % 2 === 0;
+      });
+    })(function (arr) {
+      return arr.map(function (x) {
+        return x * 2;
+      });
+    })();
+    expect(result).toEqual([4, 8]);
+  });
+  it("オブジェクトの複雑な変換を正しく処理できる", function () {
+    var initial = {
+      count: 0,
+      items: []
+    };
+    var pipeline = (0, _createPipeline.createPipeline)(initial);
+    var result = pipeline(function (data) {
+      return _objectSpread(_objectSpread({}, data), {}, {
+        count: data.count + 1
+      });
+    })(function (data) {
+      return _objectSpread(_objectSpread({}, data), {}, {
+        items: [].concat(_toConsumableArray(data.items), ["Item ".concat(data.count)])
+      });
+    })();
+    expect(result).toEqual({
+      count: 1,
+      items: ["Item 1"]
+    });
+  });
+  it("複数の型変換を連鎖的に処理できる", function () {
+    var pipeline = (0, _createPipeline.createPipeline)(123);
+    var result = pipeline(function (x) {
+      return x.toString();
+    })(function (x) {
+      return x.split("");
+    })(function (arr) {
+      return arr.map(Number);
+    })();
+    expect(result).toEqual([1, 2, 3]);
+  });
+});

package/module/es5/tests/unit/Tool/parseJson.test.d.ts

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

package/module/es5/tests/unit/Tool/parseJson.test.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _parseJson = require("@/Tool/parseJson");
+describe("parseJson", function () {
+  it("should parse valid JSON string", function () {
+    var jsonString = '{"key": "value"}';
+    var result = (0, _parseJson.parseJson)(jsonString);
+    expect(result).toEqual({
+      key: "value"
+    });
+  });
+  it("should throw an error for invalid JSON string", function () {
+    var invalidJsonString = '{"key": "value"';
+    expect(function () {
+      return (0, _parseJson.parseJson)(invalidJsonString);
+    }).toThrow(SyntaxError);
+  });
+  it("should parse JSON string with array", function () {
+    var jsonString = '["value1", "value2"]';
+    var result = (0, _parseJson.parseJson)(jsonString);
+    expect(result).toEqual(["value1", "value2"]);
+  });
+  it("should parse JSON string with nested objects", function () {
+    var jsonString = '{"key": {"nestedKey": "nestedValue"}}';
+    var result = (0, _parseJson.parseJson)(jsonString);
+    expect(result).toEqual({
+      key: {
+        nestedKey: "nestedValue"
+      }
+    });
+  });
+  it("should parse JSON string with numbers", function () {
+    var jsonString = '{"key": 123}';
+    var result = (0, _parseJson.parseJson)(jsonString);
+    expect(result).toEqual({
+      key: 123
+    });
+  });
+  it("should parse JSON string with boolean values", function () {
+    var jsonString = '{"key": true}';
+    var result = (0, _parseJson.parseJson)(jsonString);
+    expect(result).toEqual({
+      key: true
+    });
+  });
+});

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

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

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

@@ -0,0 +1,95 @@
+"use strict";
+
+var _parseUserAgent = require("@/UA/parseUserAgent");
+describe("parseUserAgent", function () {
+  it("should detect iOS mobile with Safari", function () {
+    var ua = "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 result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "ios",
+      browser: "safari",
+      device: "mobile"
+    });
+  });
+  it("should detect Android mobile with Chrome", function () {
+    var ua = "Mozilla/5.0 (Linux; Android 10; SM-A505FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Mobile Safari/537.36";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "android",
+      browser: "chrome",
+      device: "mobile"
+    });
+  });
+  it("should detect macOS desktop with Firefox", function () {
+    var ua = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:88.0) Gecko/20100101 Firefox/88.0";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "macos",
+      browser: "firefox",
+      device: "desktop"
+    });
+  });
+  it("should detect Windows desktop with Edge", function () {
+    var ua = "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 result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "windows",
+      browser: "edge",
+      device: "desktop"
+    });
+  });
+  it("should detect Linux desktop with Chrome", function () {
+    var ua = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.90 Safari/537.36";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "linux",
+      browser: "chrome",
+      device: "desktop"
+    });
+  });
+  it("should detect iPad as tablet", function () {
+    var ua = "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 result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "ios",
+      browser: "safari",
+      device: "tablet"
+    });
+  });
+  it("should detect Android tablet", function () {
+    var ua = "Mozilla/5.0 (Linux; Android 11; SM-T870) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.105 Safari/537.36";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "android",
+      browser: "chrome",
+      device: "tablet"
+    });
+  });
+  it("should detect Internet Explorer on Windows", function () {
+    var ua = "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "windows",
+      browser: "ie",
+      device: "desktop"
+    });
+  });
+  it("should detect Googlebot", function () {
+    var ua = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "other",
+      browser: "other",
+      device: "bot"
+    });
+  });
+  it("should handle unknown user agent", function () {
+    var ua = "Unknown User Agent String";
+    var result = (0, _parseUserAgent.parseUserAgent)(ua);
+    expect(result).toEqual({
+      os: "other",
+      browser: "other",
+      device: "other"
+    });
+  });
+});

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+
+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 () {
+    var validateArray = (0, _core.array)();
+    expect(validateArray(["apple", "banana", "cherry"]).validate).toBe(true);
+  });
+  it("should validate an array of strings", function () {
+    var validateArray = (0, _core.array)({
+      string: (0, _string.string)()
+    });
+    expect(validateArray(["apple", "banana", "cherry"]).validate).toBe(true);
+    // @ts-ignore
+    expect(validateArray(["apple", 1, true]).validate).toBe(false);
+  });
+  it("should validate an array of numbers", function () {
+    var validateArray = (0, _core.array)({
+      number: (0, _Validate.number)([(0, _Validate.minValue)(0), (0, _Validate.maxValue)(10)])
+    });
+    expect(validateArray([1, 2, 3]).validate).toBe(true);
+    expect(validateArray([1, 2, 3, 11]).validate).toBe(false);
+    // @ts-ignore
+    expect(validateArray([1, "2", 3]).validate).toBe(false);
+  });
+  it("should validate an array of numbers and strings", 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)])
+    });
+    expect(validateArray([1, 2, 3]).validate).toBe(true);
+    expect(validateArray([1, 2, 3, 11]).validate).toBe(false);
+    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 () {
+    var customMessage = "Array validation failed";
+    var validateArray = (0, _core.array)({
+      string: (0, _string.string)()
+    }, customMessage);
+    // @ts-ignore
+    var result = validateArray(1);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe(customMessage);
+  });
+  it("should return an empty message on validation failure", function () {
+    var validateArray = (0, _core.array)({
+      string: (0, _string.string)()
+    });
+    // @ts-ignore
+    var result = validateArray(1);
+    expect(result.validate).toBe(false);
+    expect(result.message).toBe("");
+  });
+});

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+
+var _core = require("@/Validate/boolean/core");
+describe("boolean core validation", function () {
+  it("should return true for boolean values", function () {
+    var validateBoolean = (0, _core["boolean"])();
+    expect(validateBoolean(true).validate).toBe(true);
+    expect(validateBoolean(false).validate).toBe(true);
+  });
+  it("should return false for non-boolean values", function () {
+    var validateBoolean = (0, _core["boolean"])();
+    // @ts-ignore
+    expect(validateBoolean(0).validate).toBe(false);
+    // @ts-ignore
+    expect(validateBoolean(null).validate).toBe(false);
+    // @ts-ignore
+    expect(validateBoolean(undefined).validate).toBe(false);
+    // @ts-ignore
+    expect(validateBoolean("true").validate).toBe(false);
+  });
+  it("should return the custom message for invalid input", function () {
+    var customMessage = "This is not a boolean";
+    var validateBoolean = (0, _core["boolean"])(customMessage);
+    // @ts-ignore
+    expect(validateBoolean(0).validate).toBe(false);
+    // @ts-ignore
+    expect(validateBoolean(0).message).toBe(customMessage);
+  });
+});

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

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

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

@@ -0,0 +1,25 @@
+"use strict";
+
+var _isArray = require("@/Validate/isArray");
+describe("isArray", function () {
+  it("should return true for an array", function () {
+    expect((0, _isArray.isArray)([1, 2, 3])).toBe(true);
+    expect((0, _isArray.isArray)(["a", "b", "c"])).toBe(true);
+    expect((0, _isArray.isArray)([true, false])).toBe(true);
+    expect((0, _isArray.isArray)([{
+      a: 1
+    }, {
+      b: 2
+    }])).toBe(true);
+  });
+  it("should return false for a non-array value", function () {
+    expect((0, _isArray.isArray)(1)).toBe(false);
+    expect((0, _isArray.isArray)("hello")).toBe(false);
+    expect((0, _isArray.isArray)(true)).toBe(false);
+    expect((0, _isArray.isArray)({
+      a: 1
+    })).toBe(false);
+    expect((0, _isArray.isArray)(null)).toBe(false);
+    expect((0, _isArray.isArray)(undefined)).toBe(false);
+  });
+});

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+
+var _isDouble = require("@/Validate/isDouble");
+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.5", false)).toBe(false);
+  });
+  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)(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)(-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.d.ts

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

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

@@ -0,0 +1,43 @@
+"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);
+  });
+  it("should return true for a non-empty Map or Set", 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);
+  });
+});

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+
+var _isNumber = require("@/Validate/isNumber");
+describe("isNumber", function () {
+  // 引数が数値であるケース
+  test("should return true when a number is provided", function () {
+    expect((0, _isNumber.isNumber)(5)).toBe(true);
+  });
+
+  // 引数が文字列であるが、数値に変換可能なケース
+  test("should return true when a string of a number is provided (loose mode)", function () {
+    expect((0, _isNumber.isNumber)("5", true)).toBe(true);
+  });
+
+  // 引数が文字列であるが、数値に変換不可能なケース
+  test("should return false when a non-numeric string is provided", function () {
+    expect((0, _isNumber.isNumber)("abc", true)).toBe(false);
+  });
+
+  // 引数がnullであるケース
+  test("should return false when null is provided", function () {
+    expect((0, _isNumber.isNumber)(null)).toBe(false);
+  });
+
+  // 引数がbooleanであるケース
+  test("should return false when a boolean is provided", function () {
+    expect((0, _isNumber.isNumber)(true)).toBe(false);
+  });
+
+  // 引数が文字列であるが、looseモードがオフのケース
+  test("should return false when a string is provided and loose mode is off", function () {
+    expect((0, _isNumber.isNumber)("5", false)).toBe(false);
+  });
+
+  // 空文字列が引数として渡されたケース
+  test("should return false when an empty string is provided", function () {
+    expect((0, _isNumber.isNumber)("")).toBe(true);
+  });
+});

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+
+var _isObject = require("@/Validate/isObject");
+describe("isObj", function () {
+  it("should return true for an object with string properties", function () {
+    expect((0, _isObject.isObject)({
+      foo: "bar",
+      baz: "qux"
+    })).toBe(true);
+  });
+  it("should return true for an object with number properties", function () {
+    expect((0, _isObject.isObject)({
+      foo: 1,
+      bar: 2
+    })).toBe(true);
+  });
+  it("should return true for an object with boolean properties", function () {
+    expect((0, _isObject.isObject)({
+      foo: true,
+      bar: false
+    })).toBe(true);
+  });
+  it("should return true for an object with mixed properties", function () {
+    expect((0, _isObject.isObject)({
+      foo: "bar",
+      baz: 1,
+      qux: true
+    })).toBe(true);
+  });
+  it("should return false for an array", function () {
+    expect((0, _isObject.isObject)([1, 2, 3])).toBe(false);
+  });
+  it("should return false for a string", function () {
+    expect((0, _isObject.isObject)("foo")).toBe(false);
+  });
+  it("should return false for a number", function () {
+    expect((0, _isObject.isObject)(42)).toBe(false);
+  });
+  it("should return false for a boolean", function () {
+    expect((0, _isObject.isObject)(true)).toBe(false);
+  });
+  it("should return false for null", function () {
+    expect((0, _isObject.isObject)(null)).toBe(false);
+  });
+  it("should return false for undefined", function () {
+    expect((0, _isObject.isObject)(undefined)).toBe(false);
+  });
+});

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

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

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

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

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

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