umt 2.0.0 → 2.1.1

package/module/es5/Validate/isEqual.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEqual = void 0;
+/**
+ * Evaluates true strict equality
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns boolean
+ *
+ * @example
+ * isEqual(1, 1); // true
+ * isEqual("test", "test"); // true
+ * isEqual(Number.NaN, Number.NaN); // true
+ * isEqual(-0, +0); // false
+ *
+ * @example
+ * const obj = { a: 1 };
+ * isEqual(obj, obj); // true
+ * isEqual(obj, { a: 1 }); // false
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * isEqual(arr, arr); // true
+ * isEqual(arr, [1, 2, 3]); // false
+ */
+var isEqual = exports.isEqual = function isEqual(a, b) {
+  return Object.is(a, b);
+};

package/module/es5/Validate/object/core.js

@@ -4,12 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.object = void 0;
-var _isObject = require("@/Validate/isObject");
+var _isDictionaryObject = require("@/Validate/isDictionaryObject");
 var object = exports.object = function object() {
   var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var message = arguments.length > 1 ? arguments[1] : undefined;
   return function (value) {
-    if (!(0, _isObject.isObject)(value)) {
+    if (!(0, _isDictionaryObject.isDictionaryObject)(value)) {
       return {
         validate: false,
         message: message || "",

package/module/es5/tests/unit/Consts/clock.test.js

@@ -1,38 +1,38 @@
 "use strict";
 
-var _Consts = require("@/Consts");
+var _clock = require("@/Consts/clock");
 describe("時間定数のテスト", function () {
   it("1秒は1000ミリ秒", function () {
-    expect(_Consts.OneSecondMs).toBe(1000);
+    expect(_clock.OneSecondMs).toBe(1000);
   });
   it("1分は60000ミリ秒", function () {
-    expect(_Consts.OneMinuteMs).toBe(60000);
+    expect(_clock.OneMinuteMs).toBe(60000);
   });
   it("1時間は3600000ミリ秒", function () {
-    expect(_Consts.OneHourMs).toBe(3600000);
+    expect(_clock.OneHourMs).toBe(3600000);
   });
   it("1日は86400000ミリ秒", function () {
-    expect(_Consts.OneDayMs).toBe(86400000);
+    expect(_clock.OneDayMs).toBe(86400000);
   });
   it("1週間は604800000ミリ秒", function () {
-    expect(_Consts.OneWeekMs).toBe(604800000);
+    expect(_clock.OneWeekMs).toBe(604800000);
   });
   it("1ヶ月（28日として）は2419200000ミリ秒", function () {
-    expect(_Consts.OneMonthMs28).toBe(2419200000);
+    expect(_clock.OneMonthMs28).toBe(2419200000);
   });
   it("1ヶ月（29日として）は2505600000ミリ秒", function () {
-    expect(_Consts.OneMonthMs29).toBe(2505600000);
+    expect(_clock.OneMonthMs29).toBe(2505600000);
   });
   it("1ヶ月（30日として）は2592000000ミリ秒", function () {
-    expect(_Consts.OneMonthMs).toBe(2592000000);
+    expect(_clock.OneMonthMs).toBe(2592000000);
   });
   it("1ヶ月（31日として）は2678400000ミリ秒", function () {
-    expect(_Consts.OneMonthMs31).toBe(2678400000);
+    expect(_clock.OneMonthMs31).toBe(2678400000);
   });
   it("1年（365日として）は31536000000ミリ秒", function () {
-    expect(_Consts.OneYearMs).toBe(31536000000);
+    expect(_clock.OneYearMs).toBe(31536000000);
   });
   it("1年（366日として）は31622400000ミリ秒", function () {
-    expect(_Consts.OneYearMs366).toBe(31622400000);
+    expect(_clock.OneYearMs366).toBe(31622400000);
   });
 });

package/module/es5/tests/unit/Consts/httpClientErrorStatus.test.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpClientErrorStatus", function () {
+  describe("4xx Client Error", function () {
+    it("should have correct client error status codes", function () {
+      expect(_httpStatus.HttpClientErrorStatus.BAD_REQUEST).toBe(400);
+      expect(_httpStatus.HttpClientErrorStatus.UNAUTHORIZED).toBe(401);
+      expect(_httpStatus.HttpClientErrorStatus.PAYMENT_REQUIRED).toBe(402);
+      expect(_httpStatus.HttpClientErrorStatus.FORBIDDEN).toBe(403);
+      expect(_httpStatus.HttpClientErrorStatus.NOT_FOUND).toBe(404);
+      expect(_httpStatus.HttpClientErrorStatus.METHOD_NOT_ALLOWED).toBe(405);
+      expect(_httpStatus.HttpClientErrorStatus.NOT_ACCEPTABLE).toBe(406);
+      expect(_httpStatus.HttpClientErrorStatus.PROXY_AUTHENTICATION_REQUIRED).toBe(407);
+      expect(_httpStatus.HttpClientErrorStatus.REQUEST_TIMEOUT).toBe(408);
+      expect(_httpStatus.HttpClientErrorStatus.CONFLICT).toBe(409);
+      expect(_httpStatus.HttpClientErrorStatus.GONE).toBe(410);
+      expect(_httpStatus.HttpClientErrorStatus.LENGTH_REQUIRED).toBe(411);
+      expect(_httpStatus.HttpClientErrorStatus.PRECONDITION_FAILED).toBe(412);
+      expect(_httpStatus.HttpClientErrorStatus.PAYLOAD_TOO_LARGE).toBe(413);
+      expect(_httpStatus.HttpClientErrorStatus.URI_TOO_LONG).toBe(414);
+      expect(_httpStatus.HttpClientErrorStatus.UNSUPPORTED_MEDIA_TYPE).toBe(415);
+      expect(_httpStatus.HttpClientErrorStatus.REQUESTED_RANGE_NOT_SATISFIABLE).toBe(416);
+      expect(_httpStatus.HttpClientErrorStatus.EXPECTATION_FAILED).toBe(417);
+      expect(_httpStatus.HttpClientErrorStatus.I_AM_A_TEAPOT).toBe(418);
+      expect(_httpStatus.HttpClientErrorStatus.MISDIRECTED).toBe(421);
+      expect(_httpStatus.HttpClientErrorStatus.UNPROCESSABLE_ENTITY).toBe(422);
+      expect(_httpStatus.HttpClientErrorStatus.FAILED_DEPENDENCY).toBe(424);
+      expect(_httpStatus.HttpClientErrorStatus.PRECONDITION_REQUIRED).toBe(428);
+      expect(_httpStatus.HttpClientErrorStatus.TOO_MANY_REQUESTS).toBe(429);
+    });
+  });
+});

package/module/es5/tests/unit/Consts/httpInformationalStatus.test.d.ts

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

package/module/es5/tests/unit/Consts/httpInformationalStatus.test.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpInformationalStatus", function () {
+  describe("1xx Informational", function () {
+    it("should have correct informational status codes", function () {
+      expect(_httpStatus.HttpInformationalStatus.CONTINUE).toBe(100);
+      expect(_httpStatus.HttpInformationalStatus.SWITCHING_PROTOCOLS).toBe(101);
+      expect(_httpStatus.HttpInformationalStatus.PROCESSING).toBe(102);
+      expect(_httpStatus.HttpInformationalStatus.EARLYHINTS).toBe(103);
+    });
+  });
+});

package/module/es5/tests/unit/Consts/httpRedirectionStatus.test.d.ts

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

package/module/es5/tests/unit/Consts/httpRedirectionStatus.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpRedirectionStatus", function () {
+  describe("3xx Redirection", function () {
+    it("should have correct redirection status codes", function () {
+      expect(_httpStatus.HttpRedirectionStatus.AMBIGUOUS).toBe(300);
+      expect(_httpStatus.HttpRedirectionStatus.MOVED_PERMANENTLY).toBe(301);
+      expect(_httpStatus.HttpRedirectionStatus.FOUND).toBe(302);
+      expect(_httpStatus.HttpRedirectionStatus.SEE_OTHER).toBe(303);
+      expect(_httpStatus.HttpRedirectionStatus.NOT_MODIFIED).toBe(304);
+      expect(_httpStatus.HttpRedirectionStatus.TEMPORARY_REDIRECT).toBe(307);
+      expect(_httpStatus.HttpRedirectionStatus.PERMANENT_REDIRECT).toBe(308);
+    });
+  });
+});

package/module/es5/tests/unit/Consts/httpServerErrorStatus.test.d.ts

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

package/module/es5/tests/unit/Consts/httpServerErrorStatus.test.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpServerErrorStatus", function () {
+  describe("5xx Server Error", function () {
+    it("should have correct server error status codes", function () {
+      expect(_httpStatus.HttpServerErrorStatus.INTERNAL_SERVER_ERROR).toBe(500);
+      expect(_httpStatus.HttpServerErrorStatus.NOT_IMPLEMENTED).toBe(501);
+      expect(_httpStatus.HttpServerErrorStatus.BAD_GATEWAY).toBe(502);
+      expect(_httpStatus.HttpServerErrorStatus.SERVICE_UNAVAILABLE).toBe(503);
+      expect(_httpStatus.HttpServerErrorStatus.GATEWAY_TIMEOUT).toBe(504);
+      expect(_httpStatus.HttpServerErrorStatus.HTTP_VERSION_NOT_SUPPORTED).toBe(505);
+    });
+  });
+});

package/module/es5/tests/unit/Consts/httpStatus.test.d.ts

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

package/module/es5/tests/unit/Consts/httpStatus.test.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpStatus", function () {
+  describe("1xx Informational", function () {
+    it("should have correct informational status codes", function () {
+      expect(_httpStatus.HttpStatus.CONTINUE).toBe(100);
+      expect(_httpStatus.HttpStatus.SWITCHING_PROTOCOLS).toBe(101);
+      expect(_httpStatus.HttpStatus.PROCESSING).toBe(102);
+      expect(_httpStatus.HttpStatus.EARLYHINTS).toBe(103);
+    });
+  });
+  describe("2xx Success", function () {
+    it("should have correct success status codes", function () {
+      expect(_httpStatus.HttpStatus.OK).toBe(200);
+      expect(_httpStatus.HttpStatus.CREATED).toBe(201);
+      expect(_httpStatus.HttpStatus.ACCEPTED).toBe(202);
+      expect(_httpStatus.HttpStatus.NON_AUTHORITATIVE_INFORMATION).toBe(203);
+      expect(_httpStatus.HttpStatus.NO_CONTENT).toBe(204);
+      expect(_httpStatus.HttpStatus.RESET_CONTENT).toBe(205);
+      expect(_httpStatus.HttpStatus.PARTIAL_CONTENT).toBe(206);
+    });
+  });
+  describe("3xx Redirection", function () {
+    it("should have correct redirection status codes", function () {
+      expect(_httpStatus.HttpStatus.AMBIGUOUS).toBe(300);
+      expect(_httpStatus.HttpStatus.MOVED_PERMANENTLY).toBe(301);
+      expect(_httpStatus.HttpStatus.FOUND).toBe(302);
+      expect(_httpStatus.HttpStatus.SEE_OTHER).toBe(303);
+      expect(_httpStatus.HttpStatus.NOT_MODIFIED).toBe(304);
+      expect(_httpStatus.HttpStatus.TEMPORARY_REDIRECT).toBe(307);
+      expect(_httpStatus.HttpStatus.PERMANENT_REDIRECT).toBe(308);
+    });
+  });
+  describe("4xx Client Error", function () {
+    it("should have correct client error status codes", function () {
+      expect(_httpStatus.HttpStatus.BAD_REQUEST).toBe(400);
+      expect(_httpStatus.HttpStatus.UNAUTHORIZED).toBe(401);
+      expect(_httpStatus.HttpStatus.PAYMENT_REQUIRED).toBe(402);
+      expect(_httpStatus.HttpStatus.FORBIDDEN).toBe(403);
+      expect(_httpStatus.HttpStatus.NOT_FOUND).toBe(404);
+      expect(_httpStatus.HttpStatus.METHOD_NOT_ALLOWED).toBe(405);
+      expect(_httpStatus.HttpStatus.NOT_ACCEPTABLE).toBe(406);
+      expect(_httpStatus.HttpStatus.PROXY_AUTHENTICATION_REQUIRED).toBe(407);
+      expect(_httpStatus.HttpStatus.REQUEST_TIMEOUT).toBe(408);
+      expect(_httpStatus.HttpStatus.CONFLICT).toBe(409);
+      expect(_httpStatus.HttpStatus.GONE).toBe(410);
+      expect(_httpStatus.HttpStatus.LENGTH_REQUIRED).toBe(411);
+      expect(_httpStatus.HttpStatus.PRECONDITION_FAILED).toBe(412);
+      expect(_httpStatus.HttpStatus.PAYLOAD_TOO_LARGE).toBe(413);
+      expect(_httpStatus.HttpStatus.URI_TOO_LONG).toBe(414);
+      expect(_httpStatus.HttpStatus.UNSUPPORTED_MEDIA_TYPE).toBe(415);
+      expect(_httpStatus.HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE).toBe(416);
+      expect(_httpStatus.HttpStatus.EXPECTATION_FAILED).toBe(417);
+      expect(_httpStatus.HttpStatus.I_AM_A_TEAPOT).toBe(418);
+      expect(_httpStatus.HttpStatus.MISDIRECTED).toBe(421);
+      expect(_httpStatus.HttpStatus.UNPROCESSABLE_ENTITY).toBe(422);
+      expect(_httpStatus.HttpStatus.FAILED_DEPENDENCY).toBe(424);
+      expect(_httpStatus.HttpStatus.PRECONDITION_REQUIRED).toBe(428);
+      expect(_httpStatus.HttpStatus.TOO_MANY_REQUESTS).toBe(429);
+    });
+  });
+  describe("5xx Server Error", function () {
+    it("should have correct server error status codes", function () {
+      expect(_httpStatus.HttpStatus.INTERNAL_SERVER_ERROR).toBe(500);
+      expect(_httpStatus.HttpStatus.NOT_IMPLEMENTED).toBe(501);
+      expect(_httpStatus.HttpStatus.BAD_GATEWAY).toBe(502);
+      expect(_httpStatus.HttpStatus.SERVICE_UNAVAILABLE).toBe(503);
+      expect(_httpStatus.HttpStatus.GATEWAY_TIMEOUT).toBe(504);
+      expect(_httpStatus.HttpStatus.HTTP_VERSION_NOT_SUPPORTED).toBe(505);
+    });
+  });
+});

package/module/es5/tests/unit/Consts/httpSuccessStatus.test.d.ts

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

package/module/es5/tests/unit/Consts/httpSuccessStatus.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _httpStatus = require("@/Consts/httpStatus");
+describe("HttpSuccessStatus", function () {
+  describe("2xx Success", function () {
+    it("should have correct success status codes", function () {
+      expect(_httpStatus.HttpSuccessStatus.OK).toBe(200);
+      expect(_httpStatus.HttpSuccessStatus.CREATED).toBe(201);
+      expect(_httpStatus.HttpSuccessStatus.ACCEPTED).toBe(202);
+      expect(_httpStatus.HttpSuccessStatus.NON_AUTHORITATIVE_INFORMATION).toBe(203);
+      expect(_httpStatus.HttpSuccessStatus.NO_CONTENT).toBe(204);
+      expect(_httpStatus.HttpSuccessStatus.RESET_CONTENT).toBe(205);
+      expect(_httpStatus.HttpSuccessStatus.PARTIAL_CONTENT).toBe(206);
+    });
+  });
+});

package/module/es5/tests/unit/Time/convertTime.test.js

@@ -2,7 +2,7 @@
 
 var _convertTime = require("@/Time/convertTime");
 describe("convertTime", function () {
-  // 正常系のテスト
+  // long format to long format
   test("1時間を秒に変換", function () {
     expect((0, _convertTime.convertTime)("1", "hours", "seconds")).toBe(3600);
     expect((0, _convertTime.convertTime)(1, "hours", "seconds")).toBe(3600);
@@ -40,4 +40,102 @@ describe("convertTime", function () {
   test("非常に大きな数値の変換", function () {
     expect((0, _convertTime.convertTime)("1e9", "milliseconds", "hours")).toBe(1000000000 / (60 * 60 * 1000));
   });
+
+  // short format to short format
+  test("1時間を秒に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("1", "h", "s")).toBe(3600);
+  });
+  test("3600秒を時間に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("3600", "s", "h")).toBe(1);
+  });
+  test("90分を時間に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("90", "m", "h")).toBe(1.5);
+  });
+  test("1時間をミリ秒に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("1", "h", "ms")).toBe(3600000);
+  });
+  test("0.5秒をミリ秒に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("0.5", "s", "ms")).toBe(500);
+  });
+  test("1000ミリ秒を秒に変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("1000", "ms", "s")).toBe(1);
+  });
+  test("同じ単位（秒から秒）への変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("10", "s", "s")).toBe(10);
+  });
+  test("小数点を含む入力（1.5時間を分に変換）（short format）", function () {
+    expect((0, _convertTime.convertTime)("1.5", "h", "m")).toBe(90);
+  });
+  test("0の変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("0", "h", "s")).toBe(0);
+  });
+  test("非常に大きな数値の変換（short format）", function () {
+    expect((0, _convertTime.convertTime)("1e9", "ms", "h")).toBe(1000000000 / (60 * 60 * 1000));
+  });
+
+  // long format to short format
+
+  test("1時間を秒に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("1", "hours", "s")).toBe(3600);
+  });
+  test("3600秒を時間に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("3600", "seconds", "h")).toBe(1);
+  });
+  test("90分を時間に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("90", "minutes", "h")).toBe(1.5);
+  });
+  test("1時間をミリ秒に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("1", "hours", "ms")).toBe(3600000);
+  });
+  test("0.5秒をミリ秒に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("0.5", "seconds", "ms")).toBe(500);
+  });
+  test("1000ミリ秒を秒に変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("1000", "milliseconds", "s")).toBe(1);
+  });
+  test("同じ単位（秒から秒）への変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("10", "seconds", "s")).toBe(10);
+  });
+  test("小数点を含む入力（1.5時間を分に変換）（long to short）", function () {
+    expect((0, _convertTime.convertTime)("1.5", "hours", "m")).toBe(90);
+  });
+  test("0の変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("0", "hours", "s")).toBe(0);
+  });
+  test("非常に大きな数値の変換（long to short）", function () {
+    expect((0, _convertTime.convertTime)("1e9", "milliseconds", "h")).toBe(1000000000 / (60 * 60 * 1000));
+  });
+
+  // short format to long format
+
+  test("1時間を秒に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("1", "h", "seconds")).toBe(3600);
+  });
+  test("3600秒を時間に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("3600", "s", "hours")).toBe(1);
+  });
+  test("90分を時間に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("90", "m", "hours")).toBe(1.5);
+  });
+  test("1時間をミリ秒に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("1", "h", "milliseconds")).toBe(3600000);
+  });
+  test("0.5秒をミリ秒に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("0.5", "s", "milliseconds")).toBe(500);
+  });
+  test("1000ミリ秒を秒に変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("1000", "ms", "seconds")).toBe(1);
+  });
+  test("同じ単位（秒から秒）への変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("10", "s", "seconds")).toBe(10);
+  });
+  test("小数点を含む入力（1.5時間を分に変換）（short to long）", function () {
+    expect((0, _convertTime.convertTime)("1.5", "h", "minutes")).toBe(90);
+  });
+  test("0の変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("0", "h", "seconds")).toBe(0);
+  });
+  test("非常に大きな数値の変換（short to long）", function () {
+    expect((0, _convertTime.convertTime)("1e9", "ms", "hours")).toBe(1000000000 / (60 * 60 * 1000));
+  });
 });

package/module/es5/tests/unit/Time/normalizeTimeUnit.test.d.ts

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

package/module/es5/tests/unit/Time/normalizeTimeUnit.test.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _normalizeTimeUnit = require("@/Time/normalizeTimeUnit");
+describe("normalizeTimeUnit", function () {
+  test("converts long format to long format", function () {
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("milliseconds", "long")).toBe("milliseconds");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("seconds", "long")).toBe("seconds");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("minutes", "long")).toBe("minutes");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("hours", "long")).toBe("hours");
+  });
+  test("converts long format to short format", function () {
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("milliseconds", "short")).toBe("ms");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("seconds", "short")).toBe("s");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("minutes", "short")).toBe("m");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("hours", "short")).toBe("h");
+  });
+  test("converts short format to long format", function () {
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("ms", "long")).toBe("milliseconds");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("s", "long")).toBe("seconds");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("m", "long")).toBe("minutes");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("h", "long")).toBe("hours");
+  });
+  test("converts short format to short format", function () {
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("ms", "short")).toBe("ms");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("s", "short")).toBe("s");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("m", "short")).toBe("m");
+    expect((0, _normalizeTimeUnit.normalizeTimeUnit)("h", "short")).toBe("h");
+  });
+});

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

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

package/module/es5/tests/unit/Validate/{isObject.test.js → isDictionaryObject.test.js}

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

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

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

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

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