umt 1.8.2 → 2.0.0

package/module/es5/tests/unit/Array/shuffle2DArray.test.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _shuffle2DArray = require("@/Array/shuffle2DArray");
+describe("shuffle2DArray関数のテスト", function () {
+  it("空の2次元配列がそのまま返されること", function () {
+    var array = [];
+    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
+    expect(shuffledArray).toEqual(array);
+  });
+  it("サブ配列が空の場合もそのまま返されること", function () {
+    var array = [[], [], []];
+    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
+    expect(shuffledArray).toEqual(array);
+  });
+  it("シャッフルされた2次元配列の長さが元の配列と同じであること", function () {
+    var array = [[1, 2], [3, 4], [5, 6]];
+    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
+    expect(shuffledArray.length).toBe(array.length);
+    shuffledArray.forEach(function (subArray, index) {
+      expect(subArray.length).toBe(array[index].length);
+    });
+  });
+  it("異なる型を含む2次元配列がシャッフルされること", function () {
+    var array = [[1, "2"], ["3", 4], [5, "6"]];
+    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
+    // 全体の配列がシャッフルされているか確認
+    expect(shuffledArray.map(function (subArray) {
+      return subArray.sort();
+    })).not.toEqual(array.map(function (subArray) {
+      return subArray.sort();
+    }));
+  });
+  it("長い配列の要素がシャッフルされること", function () {
+    var array = Array.from({
+      length: 1000
+    }, function (_, index) {
+      return [index, index + 1];
+    });
+    var shuffledArray = (0, _shuffle2DArray.shuffle2DArray)(array);
+    // 全体の配列がシャッフルされているか確認
+    expect(shuffledArray.map(function (subArray) {
+      return subArray.sort();
+    })).not.toEqual(array.map(function (subArray) {
+      return subArray.sort();
+    }));
+  });
+});

package/module/es5/tests/unit/Array/sum.test.d.ts

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

package/module/es5/tests/unit/Array/sum.test.js

@@ -0,0 +1,6 @@
+"use strict";
+
+var _sum = require("@/Array/sum");
+test("{sum}", function () {
+  expect((0, _sum.sum)([1, 2, 3])).toBe(6);
+});

package/module/es5/tests/unit/Array/timSort.test.d.ts

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

package/module/es5/tests/unit/Array/timSort.test.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _timSort = require("@/Array/timSort");
+describe("timSort", function () {
+  it("空の配列をソートすると空の配列が返される", function () {
+    expect((0, _timSort.timSort)([])).toEqual([]);
+  });
+  it("既にソートされた配列はそのまま返される", function () {
+    expect((0, _timSort.timSort)([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+  it("逆順にソートされた配列を正しくソートする", function () {
+    expect((0, _timSort.timSort)([3, 2, 1])).toEqual([1, 2, 3]);
+  });
+  it("ランダムな配列を正しくソートする", function () {
+    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
+    var sortedArray = [].concat(array).sort(function (a, b) {
+      return a - b;
+    });
+    expect((0, _timSort.timSort)(array)).toEqual(sortedArray);
+  });
+  it("重複した要素を含む配列を正しくソートする", function () {
+    expect((0, _timSort.timSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
+  });
+  it("大量の要素を含む配列を正しくソートする", function () {
+    var largeArray = Array.from({
+      length: 10000
+    }, function () {
+      return Math.floor(Math.random() * 10000);
+    });
+    var sortedArray = [].concat(largeArray).sort(function (a, b) {
+      return a - b;
+    });
+    expect((0, _timSort.timSort)(largeArray)).toEqual(sortedArray);
+  });
+  it("負の数を含む配列を正しくソートする", function () {
+    expect((0, _timSort.timSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
+  });
+  it("配列を降順にソートする", function () {
+    expect((0, _timSort.timSort)([1, 2, 3], function (a, b) {
+      return b - a;
+    })).toEqual([3, 2, 1]);
+  });
+  it("部分配列をソートする", function () {
+    expect((0, _timSort.timSort)([1, 3, 2, 5, 4], function (a, b) {
+      return a - b;
+    }, 1, 3)).toEqual([1, 2, 3, 5, 4]);
+  });
+});

package/module/es5/tests/unit/Array/zip.test.d.ts

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

package/module/es5/tests/unit/Array/zip.test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _zip = require("@/Array/zip");
+describe("zip関数のテスト", function () {
+  it("複数の配列を組み合わせる", function () {
+    var array1 = [1, 2, 3];
+    var array2 = ["one", "two", "three"];
+    var array3 = [true, false, true];
+    var result = (0, _zip.zip)(array1, array2, array3);
+    expect(result).toEqual([[1, "one", true], [2, "two", false], [3, "three", true]]);
+  });
+  it("異なる長さの配列を組み合わせる", function () {
+    var array1 = [1, 2];
+    var array2 = ["one", "two", "three"];
+    var result = (0, _zip.zip)(array1, array2);
+    expect(result).toEqual([[1, "one"], [2, "two"]]);
+  });
+  it("空の配列を含む組み合わせ", function () {
+    var array1 = [1, 2, 3];
+    // @ts-ignore
+    var array2 = [];
+    // @ts-ignore
+    var result = (0, _zip.zip)(array1, array2);
+    expect(result).toEqual([]);
+  });
+  it("引数がない場合は空の配列を返す", function () {
+    var result = (0, _zip.zip)();
+    expect(result).toEqual([]);
+  });
+});

package/module/es5/tests/unit/Array/zipLongest.test.d.ts

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

package/module/es5/tests/unit/Array/zipLongest.test.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _zipLongest = require("@/Array/zipLongest");
+describe("zipLongest関数のテスト", function () {
+  it("異なる長さの配列を組み合わせる", function () {
+    var array1 = [1, 2];
+    var array2 = ["one", "two", "three"];
+    var array3 = [true, false, true, false];
+    var result = (0, _zipLongest.zipLongest)(array1, array2, array3);
+    expect(result).toEqual([[1, "one", true], [2, "two", false], [undefined, "three", true], [undefined, undefined, false]]);
+  });
+  it("すべての配列が同じ長さの場合", function () {
+    var array1 = [1, 2, 3];
+    var array2 = ["one", "two", "three"];
+    var array3 = [true, false, true];
+    var result = (0, _zipLongest.zipLongest)(array1, array2, array3);
+    expect(result).toEqual([[1, "one", true], [2, "two", false], [3, "three", true]]);
+  });
+  it("空の配列を含む組み合わせ", function () {
+    var array1 = [1, 2, 3];
+    // @ts-ignore
+    var array2 = [];
+    // @ts-ignore
+    var result = (0, _zipLongest.zipLongest)(array1, array2);
+    expect(result).toEqual([[1, undefined], [2, undefined], [3, undefined]]);
+  });
+  it("引数がない場合は空の配列を返す", function () {
+    var result = (0, _zipLongest.zipLongest)();
+    expect(result).toEqual([]);
+  });
+});

package/module/es5/tests/unit/Color/cmykToRgba.test.d.ts

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

package/module/es5/tests/unit/Color/cmykToRgba.test.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _cmykToRgba = require("@/Color/cmykToRgba");
+describe("cmykToRgba関数のテスト", function () {
+  it.each([[100, 100, 0, 60.78, 1, {
+    r: 0,
+    g: 0,
+    b: 100,
+    a: 1
+  }], [0, 0, 0, 0, 1, {
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 1
+  }], [0, 100, 100, 0, 0.5, {
+    r: 255,
+    g: 0,
+    b: 0,
+    a: 0.5
+  }], [100, 0, 100, 0, 0.7, {
+    r: 0,
+    g: 255,
+    b: 0,
+    a: 0.7
+  }], [100, 100, 0, 0, 0.3, {
+    r: 0,
+    g: 0,
+    b: 255,
+    a: 0.3
+  }], [50, 50, 50, 50, 1, {
+    r: 64,
+    g: 64,
+    b: 64,
+    a: 1
+  }]])("CMYK(%i, %i, %i, %i, %i)をRGBAに変換する", function (c, m, y, k, a, expected) {
+    expect((0, _cmykToRgba.cmykToRgba)(c, m, y, k, a)).toEqual(expected);
+  });
+  it("不正な値を渡した場合の挙動", function () {
+    expect((0, _cmykToRgba.cmykToRgba)(-1, 100, 100, 0)).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _cmykToRgba.cmykToRgba)(100, 100, 100, 100)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _cmykToRgba.cmykToRgba)(100, 100, 100, 100, -1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0
+    });
+  });
+});

package/module/es5/tests/unit/Color/hexaToRgba.test.d.ts

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

package/module/es5/tests/unit/Color/hexaToRgba.test.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _hexaToRgba = require("@/Color/hexaToRgba");
+describe("hexaToRgba", function () {
+  it("should convert valid hex code to rgba", function () {
+    expect((0, _hexaToRgba.hexaToRgba)("#FF0000")).toEqual({
+      r: 255,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#00FF00")).toEqual({
+      r: 0,
+      g: 255,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#0000FF")).toEqual({
+      r: 0,
+      g: 0,
+      b: 255,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FFFFFF")).toEqual({
+      r: 255,
+      g: 255,
+      b: 255,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#000000")).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FFA500")).toEqual({
+      r: 255,
+      g: 165,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hexaToRgba.hexaToRgba)("#FFA50099")).toEqual({
+      r: 255,
+      g: 165,
+      b: 0,
+      a: 0.6
+    });
+  });
+  it("should throw an error for invalid hex code", function () {
+    expect(function () {
+      return (0, _hexaToRgba.hexaToRgba)("#12345");
+    }).toThrow("Invalid hex code");
+    expect(function () {
+      return (0, _hexaToRgba.hexaToRgba)("#1234567");
+    }).toThrow("Invalid hex code");
+    expect(function () {
+      return (0, _hexaToRgba.hexaToRgba)("123456");
+    }).toThrow("Invalid hex code");
+    expect(function () {
+      return (0, _hexaToRgba.hexaToRgba)("");
+    }).toThrow("Invalid hex code");
+  });
+});

package/module/es5/tests/unit/Color/hslaToRgba.test.d.ts

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

package/module/es5/tests/unit/Color/hslaToRgba.test.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _hslaToRgba = require("@/Color/hslaToRgba");
+describe("hslaToRgba関数のテスト", function () {
+  it.each([[0, 100, 50, 1, {
+    r: 255,
+    g: 0,
+    b: 0,
+    a: 1
+  }], [120, 100, 50, 1, {
+    r: 0,
+    g: 255,
+    b: 0,
+    a: 1
+  }], [240, 100, 50, 1, {
+    r: 0,
+    g: 0,
+    b: 255,
+    a: 1
+  }], [60, 100, 50, 1, {
+    r: 255,
+    g: 255,
+    b: 0,
+    a: 1
+  }], [180, 100, 50, 1, {
+    r: 0,
+    g: 255,
+    b: 255,
+    a: 1
+  }], [300, 100, 50, 1, {
+    r: 255,
+    g: 0,
+    b: 255,
+    a: 1
+  }], [0, 0, 100, 1, {
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 1
+  }], [0, 0, 0, 1, {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 1
+  }], [0, 100, 50, 0.5, {
+    r: 255,
+    g: 0,
+    b: 0,
+    a: 0.5
+  }]])("HSLA(%i, %i%, %i%, %i)をRGBAに変換する", function (h, s, l, a, expected) {
+    expect((0, _hslaToRgba.hslaToRgba)(h, s, l, a)).toEqual(expected);
+  });
+  it.each([[0, 0, 0, {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 1
+  }], [360, 100, 100, {
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 1
+  }], [0, 100, 50, {
+    r: 255,
+    g: 0,
+    b: 0,
+    a: 1
+  }]])("HSLA(%i, %i%, %i%)をRGBAに変換する", function (h, s, l, expected) {
+    expect((0, _hslaToRgba.hslaToRgba)(h, s, l)).toEqual(expected);
+  });
+  it.each([[240, 100, 25, 1, {
+    r: 0,
+    g: 0,
+    b: 127.5,
+    a: 1
+  }], [120, 100, 25, 1, {
+    r: 0,
+    g: 127.5,
+    b: 0,
+    a: 1
+  }], [0, 100, 25, 1, {
+    r: 127.5,
+    g: 0,
+    b: 0,
+    a: 1
+  }], [60, 100, 25, 1, {
+    r: 127.5,
+    g: 127.5,
+    b: 0,
+    a: 1
+  }], [180, 100, 25, 1, {
+    r: 0,
+    g: 127.5,
+    b: 127.5,
+    a: 1
+  }], [300, 100, 25, 1, {
+    r: 127.5,
+    g: 0,
+    b: 127.5,
+    a: 1
+  }], [0, 0, 25, 1, {
+    r: 63.75,
+    g: 63.75,
+    b: 63.75,
+    a: 1
+  }]])("HSLA(%i, %i%, %i%, %i)をRGBAに変換する", function (h, s, l, a, expected) {
+    expect((0, _hslaToRgba.hslaToRgba)(h, s, l, a)).toEqual(expected);
+  });
+  it("不正な値を渡した場合の挙動", function () {
+    expect((0, _hslaToRgba.hslaToRgba)(-60, 100, 50, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(420, 100, 50, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, -50, 50, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, 150, 50, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, 100, -20, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 120, 1)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 50, -0.5)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+    expect((0, _hslaToRgba.hslaToRgba)(0, 100, 50, 1.5)).toEqual({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    });
+  });
+});

package/module/es5/tests/unit/Color/rgbaToCmyk.test.d.ts

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

package/module/es5/tests/unit/Color/rgbaToCmyk.test.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _rgbaToCmyk = require("@/Color/rgbaToCmyk");
+describe("rgbaToCmyk", function () {
+  it.each([[{
+    r: 255,
+    g: 255,
+    b: 255,
+    a: 1
+  }, {
+    c: 0,
+    m: 0,
+    y: 0,
+    k: 0,
+    a: 1
+  }], [{
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 1
+  }, {
+    c: 0,
+    m: 0,
+    y: 0,
+    k: 100,
+    a: 1
+  }], [{
+    r: 255,
+    g: 0,
+    b: 0,
+    a: 0.5
+  }, {
+    c: 0,
+    m: 100,
+    y: 100,
+    k: 0,
+    a: 0.5
+  }], [{
+    r: 0,
+    g: 255,
+    b: 0,
+    a: 0.7
+  }, {
+    c: 100,
+    m: 0,
+    y: 100,
+    k: 0,
+    a: 0.7
+  }], [{
+    r: 0,
+    g: 0,
+    b: 255,
+    a: 0.3
+  }, {
+    c: 100,
+    m: 100,
+    y: 0,
+    k: 0,
+    a: 0.3
+  }], [{
+    r: 255,
+    g: 255,
+    b: 255
+  }, {
+    c: 0,
+    m: 0,
+    y: 0,
+    k: 0,
+    a: 1
+  }]])("RGBA(%o)をCMYKに変換する", function (input, expected) {
+    expect((0, _rgbaToCmyk.rgbaToCmyk)(input)).toEqual(expected);
+  });
+});

package/module/es5/tests/unit/Color/rgbaToHexA.test.d.ts

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

package/module/es5/tests/unit/Color/rgbaToHexA.test.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _rgbaToHexA = require("@/Color/rgbaToHexA");
+describe("rgbaToHexA", function () {
+  it("should convert valid rgba to hex code", function () {
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 255,
+      g: 0,
+      b: 0
+    })).toEqual("#ff0000ff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 0,
+      g: 255,
+      b: 0,
+      a: 1
+    })).toEqual("#00ff00ff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 0,
+      g: 0,
+      b: 255,
+      a: 1
+    })).toEqual("#0000ffff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 255,
+      g: 255,
+      b: 255,
+      a: 1
+    })).toEqual("#ffffffff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 1
+    })).toEqual("#000000ff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 255,
+      g: 165,
+      b: 0,
+      a: 1
+    })).toEqual("#ffa500ff");
+    expect((0, _rgbaToHexA.rgbaToHexA)({
+      r: 255,
+      g: 255,
+      b: 255,
+      a: 0.5
+    })).toEqual("#ffffff80");
+  });
+  it("should throw an error for invalid rgba", function () {
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 256,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: 256,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: 0,
+        b: 256,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 1.5
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: -1,
+        g: 0,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: -1,
+        b: 0,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: 0,
+        b: -1,
+        a: 1
+      });
+    }).toThrow("Invalid rgba value");
+    expect(function () {
+      return (0, _rgbaToHexA.rgbaToHexA)({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: -0.5
+      });
+    }).toThrow("Invalid rgba value");
+  });
+});

package/module/es5/tests/unit/Color/rgbaToHsla.test.d.ts

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