umt 1.9.0 → 2.0.0

package/module/es5/tests/unit/Math/toCelsius.test.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _toCelsius = require("@/Math/toCelsius");
+test("{toCelsius}", function () {
+  expect((0, _toCelsius.toCelsius)(32)).toBe(-241.15);
+});

package/module/es5/tests/unit/Math/toKelvin.test.d.ts

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

package/module/es5/tests/unit/Math/toKelvin.test.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _toKelvin = require("@/Math/toKelvin");
+test("{toKelvin}", function () {
+  expect((0, _toKelvin.toKelvin)(0)).toBe(273.15);
+});

package/module/es5/tests/unit/Math/uuidv7.test.d.ts

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

package/module/es5/tests/unit/Math/uuidv7.test.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _uuidv = require("@/Math/uuidv7");
+describe("uuidv7", function () {
+  it("生成されたUUID v7が正しい形式である", function () {
+    var uuid = (0, _uuidv.uuidv7)();
+    var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+    expect(uuid).toMatch(uuidRegex);
+  });
+  it("生成されたUUID v7が一意である", function () {
+    var uuid1 = (0, _uuidv.uuidv7)();
+    var uuid2 = (0, _uuidv.uuidv7)();
+    expect(uuid1).not.toBe(uuid2);
+  });
+  it("生成されたUUID v7のバージョンが7である", function () {
+    var uuid = (0, _uuidv.uuidv7)();
+    var version = uuid.split("-")[2][0];
+    expect(version).toBe("7");
+  });
+  it("生成されたUUID v7のバリアントが正しい形式である", function () {
+    var uuid = (0, _uuidv.uuidv7)();
+    var variant = uuid.split("-")[3][0];
+    expect(["8", "9", "a", "b"]).toContain(variant);
+  });
+  it("衝突しないUUID v7が生成される", function () {
+    var uuids = new Set();
+    for (var index = 0; index < 1000; index++) {
+      var uuid = (0, _uuidv.uuidv7)();
+      expect(uuids.has(uuid)).toBe(false);
+      uuids.add(uuid);
+    }
+  });
+});

package/module/es5/tests/unit/Math/valueSwap.test.d.ts

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

package/module/es5/tests/unit/Math/valueSwap.test.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var _valueSwap = require("@/Math/valueSwap");
+test("{valueSwap}", function () {
+  expect((0, _valueSwap.valueSwap)(1, 2)).toEqual([1, 2]);
+  expect((0, _valueSwap.valueSwap)(2, 1)).toEqual([1, 2]);
+  expect((0, _valueSwap.valueSwap)(1, 1)).toEqual([1, 1]);
+  expect((0, _valueSwap.valueSwap)(2, 2)).toEqual([2, 2]);
+  expect((0, _valueSwap.valueSwap)(3, 3)).toEqual([3, 3]);
+});

package/module/es5/tests/unit/Math/xoshiro256.test.d.ts

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

package/module/es5/tests/unit/Math/xoshiro256.test.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _xoshiro = require("@/Math/xoshiro256");
+describe("xoshiro256", function () {
+  it("乱数を生成する", function () {
+    var result = (0, _xoshiro.xoshiro256)([1, 2, 3, 4]);
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThan(1);
+  });
+  it("同じシード値で同じ乱数列を生成する", function () {
+    var result1 = (0, _xoshiro.xoshiro256)([1, 2, 3, 4]);
+    var result2 = (0, _xoshiro.xoshiro256)([1, 2, 3, 4]);
+    expect(result1).toBe(result2);
+    expect(result1).toBe(result2);
+    expect(result1).toBe(result2);
+  });
+  it("異なるシード値で異なる乱数列を生成する", function () {
+    var result1 = (0, _xoshiro.xoshiro256)([1, 2, 3, 4]);
+    var result2 = (0, _xoshiro.xoshiro256)([4, 3, 2, 1]);
+    expect(result1).not.toBe(result2);
+  });
+});

package/module/es5/tests/unit/Object/has.test.d.ts

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

package/module/es5/tests/unit/Object/has.test.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _has = require("@/Object/has");
+describe("has", function () {
+  it("should return true for existing nested path (string)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, "a.b")).toBe(true);
+  });
+  it("should return true for existing nested path (array)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, ["a", "b"])).toBe(true);
+  });
+  it("should return false for non-existing nested path (string)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, "a.c")).toBe(false);
+  });
+  it("should return false for non-existing nested path (array)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, ["a", "c"])).toBe(false);
+  });
+  it("should return false for non-existing top-level path", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, "b")).toBe(false);
+  });
+  it("should handle empty path (string)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, "")).toBe(false);
+  });
+  it("should handle empty path (array)", function () {
+    expect((0, _has.has)({
+      a: {
+        b: 1
+      }
+    }, [])).toBe(true);
+  });
+  it("should handle null or undefined object", function () {
+    // @ts-expect-error
+    expect((0, _has.has)(null, "a.b")).toBe(false);
+    // @ts-expect-error
+    expect((0, _has.has)(undefined, "a.b")).toBe(false);
+  });
+});

package/module/es5/tests/unit/Object/keyBy.test.d.ts

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

package/module/es5/tests/unit/Object/keyBy.test.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _keyBy = require("@/Object/keyBy");
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+describe("keyBy", function () {
+  it("プロパティ名でオブジェクトを生成できる", function () {
+    var input = [{
+      id: "a1",
+      name: "Alice"
+    }, {
+      id: "b2",
+      name: "Bob"
+    }];
+    var result = {
+      a1: {
+        id: "a1",
+        name: "Alice"
+      },
+      b2: {
+        id: "b2",
+        name: "Bob"
+      }
+    };
+    var output = (0, _keyBy.keyBy)(input, "id");
+    var lodashOutput = _lodash["default"].keyBy(input, "id");
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+  it("カスタム関数でキーを生成できる", function () {
+    var input = [{
+      dir: "left",
+      code: 97
+    }, {
+      dir: "right",
+      code: 100
+    }];
+    var result = {
+      a: {
+        dir: "left",
+        code: 97
+      },
+      d: {
+        dir: "right",
+        code: 100
+      }
+    };
+    var output = (0, _keyBy.keyBy)(input, function (o) {
+      return String.fromCharCode(o.code);
+    });
+    var lodashOutput = _lodash["default"].keyBy(input, function (o) {
+      return String.fromCharCode(o.code);
+    });
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+  it("空の配列の場合は空のオブジェクトを返す", function () {
+    var result = {};
+    var output = (0, _keyBy.keyBy)([], "id");
+    var lodashOutput = _lodash["default"].keyBy([], "id");
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+  it("重複するキーがある場合は後のものが優先される", function () {
+    var input = [{
+      id: "a1",
+      name: "Alice"
+    }, {
+      id: "a1",
+      name: "Alex"
+    }];
+    var result = {
+      a1: {
+        id: "a1",
+        name: "Alex"
+      }
+    };
+    var output = (0, _keyBy.keyBy)(input, "id");
+    var lodashOutput = _lodash["default"].keyBy(input, "id");
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+  it("オブジェクトを入力として受け付ける", function () {
+    var input = {
+      first: {
+        id: "a1",
+        name: "Alice"
+      },
+      second: {
+        id: "b2",
+        name: "Bob"
+      }
+    };
+    var result = {
+      a1: {
+        id: "a1",
+        name: "Alice"
+      },
+      b2: {
+        id: "b2",
+        name: "Bob"
+      }
+    };
+    var output = (0, _keyBy.keyBy)(input, "id");
+    var lodashOutput = _lodash["default"].keyBy(input, "id");
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+  it("iterateeが未指定の場合はidentity関数として動作する", function () {
+    var input = ["a", "b"];
+    var result = {
+      a: "a",
+      b: "b"
+    };
+    var output = (0, _keyBy.keyBy)(input);
+    var lodashOutput = _lodash["default"].keyBy(input);
+    expect(output).toEqual(result);
+    expect(lodashOutput).toEqual(result);
+  });
+});

package/module/es5/tests/unit/Object/pick.test.d.ts

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

package/module/es5/tests/unit/Object/pick.test.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _pick = require("@/Object/pick");
+describe("pick関数のテスト", function () {
+  test("単一のキーを選択", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pick.pick)(obj, "a");
+    expect(result).toEqual({
+      a: 1
+    });
+  });
+  test("複数のキーを選択", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pick.pick)(obj, "a", "c");
+    expect(result).toEqual({
+      a: 1,
+      c: 3
+    });
+  });
+  test("存在しないキーを選択", function () {
+    var obj = {
+      a: 1,
+      b: 2
+    };
+    // @ts-ignore
+    var result = (0, _pick.pick)(obj, "c");
+    expect(result).toEqual({});
+  });
+  test("空のオブジェクトから選択", function () {
+    var obj = {};
+    // @ts-ignore
+    var result = (0, _pick.pick)(obj, "a");
+    expect(result).toEqual({});
+  });
+  test("キーが空の場合", function () {
+    var obj = {
+      a: 1,
+      b: 2
+    };
+    var result = (0, _pick.pick)(obj);
+    expect(result).toEqual({});
+  });
+  test("すべてのキーを選択", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pick.pick)(obj, "a", "b", "c");
+    expect(result).toEqual(obj);
+  });
+  test("重複したキーを選択", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pick.pick)(obj, "a", "a", "c");
+    expect(result).toEqual({
+      a: 1,
+      c: 3
+    });
+  });
+  test("ネストされたオブジェクトから選択", function () {
+    var obj = {
+      a: {
+        b: 1
+      },
+      c: 2
+    };
+    var result = (0, _pick.pick)(obj, "a");
+    expect(result).toEqual({
+      a: {
+        b: 1
+      }
+    });
+  });
+  test("nullまたはundefinedのプロパティを持つオブジェクトの選択", function () {
+    var obj = {
+      a: null,
+      b: undefined,
+      c: 3
+    };
+    var result = (0, _pick.pick)(obj, "a", "b", "c");
+    expect(result).toEqual({
+      a: null,
+      b: undefined,
+      c: 3
+    });
+  });
+  test("配列を含むオブジェクトからの選択", function () {
+    var obj = {
+      a: [1, 2, 3],
+      b: 4
+    };
+    var result = (0, _pick.pick)(obj, "a");
+    expect(result).toEqual({
+      a: [1, 2, 3]
+    });
+  });
+});

package/module/es5/tests/unit/Object/pickDeep.test.d.ts

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

package/module/es5/tests/unit/Object/pickDeep.test.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var _pickDeep = require("@/Object/pickDeep");
+describe("pickDeep関数のテスト", function () {
+  test("単純なキーの選択", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "c");
+    expect(result).toEqual({
+      a: 1,
+      c: 3
+    });
+  });
+  test("ネストされたキーの選択", function () {
+    var obj = {
+      a: {
+        b: {
+          c: 1,
+          d: 2
+        },
+        e: 3
+      },
+      f: 4
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a.b.c", "f");
+    expect(result).toEqual({
+      a: {
+        b: {
+          c: 1
+        }
+      },
+      f: 4
+    });
+  });
+  test("存在しないキーの選択", function () {
+    var obj = {
+      a: 1,
+      b: 2
+    };
+    // @ts-expect-error
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "c");
+    expect(result).toEqual({
+      a: 1
+    });
+  });
+  test("キーが空の場合", function () {
+    var obj = {
+      a: 1,
+      b: 2
+    };
+    var result = (0, _pickDeep.pickDeep)(obj);
+    expect(result).toEqual({});
+  });
+  test("配列を含むオブジェクトからの選択", function () {
+    var obj = {
+      a: [{
+        b: 1
+      }, {
+        c: 2
+      }],
+      d: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "d");
+    expect(result).toEqual(obj);
+  });
+  test("nullまたはundefinedのプロパティを持つオブジェクトの選択", function () {
+    var obj = {
+      a: null,
+      b: undefined,
+      c: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "b", "c");
+    expect(result).toEqual({
+      a: null,
+      b: undefined,
+      c: 3
+    });
+  });
+  test("ネストが深いキーの選択", function () {
+    var obj = {
+      a: {
+        b: {
+          c: {
+            d: {
+              e: 5
+            }
+          }
+        }
+      }
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a.b.c.d.e");
+    expect(result).toEqual({
+      a: {
+        b: {
+          c: {
+            d: {
+              e: 5
+            }
+          }
+        }
+      }
+    });
+  });
+  test("選択キーがオブジェクト全体を指す場合", function () {
+    var obj = {
+      a: {
+        b: 1,
+        c: 2
+      },
+      d: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a");
+    expect(result).toEqual({
+      a: {
+        b: 1,
+        c: 2
+      }
+    });
+  });
+  test("キーがドットを含まない場合", function () {
+    var obj = {
+      a: {
+        b: 1
+      },
+      c: 2
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "c");
+    expect(result).toEqual({
+      a: {
+        b: 1
+      },
+      c: 2
+    });
+  });
+  test("選択キーが空文字列の場合", function () {
+    var obj = {
+      a: 1,
+      b: 2
+    };
+    // @ts-expect-error
+    var result = (0, _pickDeep.pickDeep)(obj, "");
+    expect(result).toEqual({});
+  });
+  test("キーに数値が含まれる場合", function () {
+    var obj = {
+      a: {
+        "1": 1,
+        "2": 2
+      },
+      b: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a.1");
+    expect(result).toEqual({
+      a: {
+        "1": 1
+      }
+    });
+  });
+  test("キーが存在しない深さ", function () {
+    var obj = {
+      a: {
+        b: 1
+      }
+    };
+    // @ts-expect-error
+    var result = (0, _pickDeep.pickDeep)(obj, "a.b.c");
+    expect(result).toEqual({
+      a: {
+        b: {}
+      }
+    });
+  });
+  test("複数のキーを同時に選択する", function () {
+    var obj = {
+      user: {
+        name: "Alice",
+        address: {
+          city: "Tokyo",
+          zip: "12345"
+        }
+      },
+      posts: [{
+        id: 1,
+        title: "Post 1"
+      }, {
+        id: 2,
+        title: "Post 2"
+      }]
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "user.name", "user.address.city", "posts");
+    expect(result).toEqual({
+      user: {
+        name: "Alice",
+        address: {
+          city: "Tokyo"
+        }
+      },
+      posts: [{
+        id: 1,
+        title: "Post 1"
+      }, {
+        id: 2,
+        title: "Post 2"
+      }]
+    });
+  });
+  test("選択キーが重複している場合", function () {
+    var obj = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    var result = (0, _pickDeep.pickDeep)(obj, "a", "a", "c");
+    expect(result).toEqual({
+      a: 1,
+      c: 3
+    });
+  });
+});

package/module/es5/tests/unit/Simple/Array/quickSortSimple.test.d.ts

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

package/module/es5/tests/unit/Simple/Array/quickSortSimple.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _quickSortSimple = require("@/Simple/Array/quickSortSimple");
+describe("quickSortSimple", function () {
+  it("空の配列をソートすると空の配列が返される", function () {
+    expect((0, _quickSortSimple.quickSortSimple)([])).toEqual([]);
+  });
+  it("startIDが配列の範囲外の場合", function () {
+    expect((0, _quickSortSimple.quickSortSimple)([3, 1, 4], undefined, -1, 2)).toEqual([1, 3, 4]);
+    expect((0, _quickSortSimple.quickSortSimple)([3, 1, 4], undefined, 4, 2)).toEqual([1, 3, 4]);
+  });
+  it("endIDが配列の範囲外の場合", function () {
+    expect((0, _quickSortSimple.quickSortSimple)([3, 1, 4], undefined, 0, 5)).toEqual([1, 3, 4]);
+  });
+  it("startIDがendIDより大きい場合", function () {
+    expect((0, _quickSortSimple.quickSortSimple)([3, 1, 4], undefined, 2, 1)).toEqual([1, 3, 4]);
+  });
+});

package/module/es5/tests/unit/Simple/Date/dayOfWeekSimple.test.d.ts

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