umt 2.2.1 → 2.4.0

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

@@ -1,29 +0,0 @@
-"use strict";
-
-var _compareFunctionDefault = require("@/Array/compareFunctionDefault");
-describe("compareFunctionDefault", function () {
-  test("should return 1 when first value is greater", function () {
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(2, 1)).toBe(1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)("b", "a")).toBe(1);
-  });
-  test("should return -1 when first value is lesser", function () {
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(1, 2)).toBe(-1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)("a", "b")).toBe(-1);
-  });
-  test("should return 0 when values are equal", function () {
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(1, 1)).toBe(0);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)("a", "a")).toBe(0);
-  });
-  test("should work with different types", function () {
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(true, false)).toBe(1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(false, true)).toBe(-1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(true, true)).toBe(0);
-  });
-  test("should work with objects that are comparable", function () {
-    var date1 = new Date(2024, 0, 1);
-    var date2 = new Date(2024, 0, 2);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(date2, date1)).toBe(1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(date1, date2)).toBe(-1);
-    expect((0, _compareFunctionDefault.compareFunctionDefault)(date1, new Date(2024, 0, 1))).toBe(0);
-  });
-});

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

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

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

@@ -1,84 +0,0 @@
-"use strict";
-
-var _drop = require("@/Array/drop");
-var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-describe("drop function", function () {
-  it("should exclude n elements from the start of the array", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
-    expect((0, _drop.drop)([1, 2, 3, 4, 5])).toEqual([2, 3, 4, 5]);
-
-    // lodash
-    expect(_lodash["default"].drop([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
-    expect(_lodash["default"].drop([1, 2, 3, 4, 5])).toEqual([2, 3, 4, 5]);
-  });
-  it("should exclude n elements from the start when direction is 'left'", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2, "left")).toEqual([3, 4, 5]);
-
-    // lodash
-    expect(_lodash["default"].drop([1, 2, 3, 4, 5], 2)).toEqual([3, 4, 5]);
-  });
-  it("should exclude n elements from the end when direction is 'right'", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3, 4, 5], 2, "right")).toEqual([1, 2, 3]);
-
-    // lodash
-    expect(_lodash["default"].dropRight([1, 2, 3, 4, 5], 2)).toEqual([1, 2, 3]);
-  });
-  it("should exclude n elements from the middle when direction is 'between'", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3, 4, 5], 1, "between")).toEqual([1, 2, 4, 5]);
-    expect((0, _drop.drop)([1, 2, 3, 4, 5, 6], 2, "between")).toEqual([1, 2, 5, 6]);
-  });
-  it("should return an empty array when n is greater than or equal to array length", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3], 4)).toEqual([]);
-    expect((0, _drop.drop)([1, 2, 3], 3)).toEqual([]);
-
-    // lodash
-    expect(_lodash["default"].drop([1, 2, 3], 4)).toEqual([]);
-    expect(_lodash["default"].drop([1, 2, 3], 3)).toEqual([]);
-  });
-  it("should return the original array when n is 0", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3], 0)).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], 0, "left")).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], 0, "right")).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], 0, "between")).toEqual([1, 2, 3]);
-
-    // lodash
-    expect(_lodash["default"].drop([1, 2, 3], 0)).toEqual([1, 2, 3]);
-    expect(_lodash["default"].drop([1, 2, 3], 0)).toEqual([1, 2, 3]);
-    expect(_lodash["default"].dropRight([1, 2, 3], 0)).toEqual([1, 2, 3]);
-  });
-  it("should return the original array when n is negative", function () {
-    // umt
-    expect((0, _drop.drop)([1, 2, 3], -1)).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], -2, "left")).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], -3, "right")).toEqual([1, 2, 3]);
-    expect((0, _drop.drop)([1, 2, 3], -4, "between")).toEqual([1, 2, 3]);
-
-    // lodash
-    expect(_lodash["default"].drop([1, 2, 3], -1)).toEqual([1, 2, 3]);
-    expect(_lodash["default"].drop([1, 2, 3], -2)).toEqual([1, 2, 3]);
-    expect(_lodash["default"].dropRight([1, 2, 3], -3)).toEqual([1, 2, 3]);
-  });
-  it("should return an empty array when an empty array is passed", function () {
-    // umt
-    expect((0, _drop.drop)([], 1)).toEqual([]);
-    expect((0, _drop.drop)([], 2, "left")).toEqual([]);
-    expect((0, _drop.drop)([], 3, "right")).toEqual([]);
-    expect((0, _drop.drop)([], 4, "between")).toEqual([]);
-
-    // lodash
-    expect(_lodash["default"].drop([], 1)).toEqual([]);
-    expect(_lodash["default"].drop([], 2)).toEqual([]);
-    expect(_lodash["default"].dropRight([], 3)).toEqual([]);
-  });
-  it("should treat as 'left' when an invalid direction is passed", function () {
-    // @ts-ignore
-    expect((0, _drop.drop)([1, 2, 3], 1, "invalid")).toEqual([2, 3]);
-  });
-});

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

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

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

@@ -1,87 +0,0 @@
-"use strict";
-
-var _dualPivotQuickSort = require("../../../Array/dualPivotQuickSort");
-describe("dualPivotQuickSort", function () {
-  test("should sort an array of numbers in ascending order", function () {
-    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 6, 9]);
-  });
-  test("should sort an array of strings lexicographically", function () {
-    var array = ["banana", "apple", "orange", "grape"];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual(["apple", "banana", "grape", "orange"]);
-  });
-  test("should sort in descending order when custom comparison function is provided", function () {
-    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
-    var compareFunction = function compareFunction(a, b) {
-      return b - a;
-    };
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), compareFunction)).toEqual([9, 6, 5, 5, 4, 3, 3, 2, 1, 1]);
-  });
-  test("should handle empty array", function () {
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([])).toEqual([]);
-  });
-  test("should handle array with single element", function () {
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([1])).toEqual([1]);
-  });
-  test("should handle array with all identical elements", function () {
-    var array = [2, 2, 2, 2, 2];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([2, 2, 2, 2, 2]);
-  });
-  test("should handle already sorted array", function () {
-    var array = [1, 2, 3, 4, 5];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 2, 3, 4, 5]);
-  });
-  test("should handle reverse sorted array", function () {
-    var array = [5, 4, 3, 2, 1];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([1, 2, 3, 4, 5]);
-  });
-  test("should handle array with negative numbers", function () {
-    var array = [-3, 1, -4, 1, 5, -9, 2, 6, 5, 3];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array))).toEqual([-9, -4, -3, 1, 1, 2, 3, 5, 5, 6]);
-  });
-  test("should sort only specified range of array", function () {
-    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), undefined, 2, 6)).toEqual([3, 1, 1, 2, 4, 5, 9, 6, 5, 3]);
-  });
-  test("should handle large arrays efficiently", function () {
-    var size = 1000;
-    var array = Array.from({
-      length: size
-    }, function () {
-      return Math.floor(Math.random() * size);
-    });
-    var sorted = (0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array));
-    for (var i = 1; i < sorted.length; i++) {
-      expect(sorted[i]).toBeGreaterThanOrEqual(sorted[i - 1]);
-    }
-  });
-  test("should use insertion sort for small arrays when threshold is adjusted", function () {
-    var array = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3];
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), undefined, 0, array.length - 1, 5)).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 6, 9]);
-  });
-  test("should sort array of objects using custom comparison", function () {
-    var array = [{
-      id: 3,
-      value: "c"
-    }, {
-      id: 1,
-      value: "a"
-    }, {
-      id: 2,
-      value: "b"
-    }];
-    var compareFunction = function compareFunction(a, b) {
-      return a.id - b.id;
-    };
-    expect((0, _dualPivotQuickSort.dualPivotQuickSort)([].concat(array), compareFunction)).toEqual([{
-      id: 1,
-      value: "a"
-    }, {
-      id: 2,
-      value: "b"
-    }, {
-      id: 3,
-      value: "c"
-    }]);
-  });
-});

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

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

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

@@ -1,28 +0,0 @@
-"use strict";
-
-var _first = require("@/Array/first");
-describe("first", function () {
-  it("should return the first element of a non-empty array", function () {
-    expect((0, _first.first)([1, 2, 3])).toBe(1);
-    expect((0, _first.first)(["a", "b", "c"])).toBe("a");
-    expect((0, _first.first)([true, false, true])).toBe(true);
-    expect((0, _first.first)([{
-      key: "value"
-    }, {
-      key: "another"
-    }])).toEqual({
-      key: "value"
-    });
-  });
-  it("should return undefined for an empty array", function () {
-    expect((0, _first.first)([])).toBeUndefined();
-  });
-  it("should handle arrays with different types of elements", function () {
-    expect((0, _first.first)([1, "a", true])).toBe(1);
-    expect((0, _first.first)([undefined, null, 0])).toBeUndefined();
-  });
-  it("should handle arrays with only one element", function () {
-    expect((0, _first.first)([42])).toBe(42);
-    expect((0, _first.first)(["single"])).toBe("single");
-  });
-});

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

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

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

@@ -1,34 +0,0 @@
-"use strict";
-
-var _generateNumberArray = require("@/Array/generateNumberArray");
-describe("generateNumberArray", function () {
-  it("should generate an array with the specified length", function () {
-    var result = (0, _generateNumberArray.generateNumberArray)(5);
-    expect(result).toEqual([0, 1, 2, 3, 4]);
-  });
-  it("should generate an array with specified min and max values", function () {
-    var result = (0, _generateNumberArray.generateNumberArray)(5, 10, 14);
-    expect(result).toEqual([10, 11, 12, 13, 14]);
-  });
-  it("should return an empty array when length is 0", function () {
-    var result = (0, _generateNumberArray.generateNumberArray)(0);
-    expect(result).toEqual([]);
-  });
-  it("should throw an error when min is greater than max", function () {
-    expect(function () {
-      return (0, _generateNumberArray.generateNumberArray)(5, 10, 5);
-    }).toThrow("min should be less than or equal to max");
-  });
-  it("should return min value when length is 1", function () {
-    var result = (0, _generateNumberArray.generateNumberArray)(1, 10, 20);
-    expect(result).toEqual([10]);
-  });
-  it("should generate an array with random values", function () {
-    var result = (0, _generateNumberArray.generateNumberArray)(5, 10, 14, true);
-    expect(result).toHaveLength(5);
-    result.forEach(function (item) {
-      expect(item).toBeGreaterThanOrEqual(10);
-      expect(item).toBeLessThanOrEqual(14);
-    });
-  });
-});

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

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

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

@@ -1,40 +0,0 @@
-"use strict";
-
-var _getArraysCommon = require("@/Array/getArraysCommon");
-describe("getArraysCommon", function () {
-  it("should find common elements between arrays", function () {
-    // Test with two arrays
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 4])).toEqual([2, 3]);
-
-    // Test with three arrays
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5])).toEqual([3]);
-
-    // Test with four arrays (including duplicates)
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [2, 3, 9], [3, 4, 5], [3, 4, 5])).toEqual([3]);
-  });
-  it("should handle empty arrays", function () {
-    expect((0, _getArraysCommon.getArraysCommon)([], [])).toEqual([]);
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [])).toEqual([]);
-    expect((0, _getArraysCommon.getArraysCommon)([], [1, 2, 3])).toEqual([]);
-  });
-  it("should handle arrays with no common elements", function () {
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2, 3], [4, 5, 6])).toEqual([]);
-    expect((0, _getArraysCommon.getArraysCommon)([1, 2], [3, 4], [5, 6])).toEqual([]);
-  });
-  it("should handle arrays of strings", function () {
-    expect((0, _getArraysCommon.getArraysCommon)(["a", "b", "c"], ["b", "c", "d"])).toEqual(["b", "c"]);
-    expect((0, _getArraysCommon.getArraysCommon)(["a", "b", "c"], ["b", "c", "d"], ["c", "d", "e"])).toEqual(["c"]);
-  });
-  it("should handle arrays of objects", function () {
-    var obj1 = {
-      id: 1
-    };
-    var obj2 = {
-      id: 2
-    };
-    var obj3 = {
-      id: 3
-    };
-    expect((0, _getArraysCommon.getArraysCommon)([obj1, obj2, obj3], [obj2, obj3], [obj3])).toEqual([obj3]);
-  });
-});

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

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

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

@@ -1,99 +0,0 @@
-"use strict";
-
-var _getArraysDiff = require("@/Array/getArraysDiff");
-describe("getArraysDiff function", function () {
-  // Normal cases
-  test("should handle standard arrays", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [2, 3, 4], [3, 4, 5])).toEqual([1, 5]);
-    expect((0, _getArraysDiff.getArraysDiff)([-1, 0, 1], [0, 1, 2], [1, 2, 3])).toEqual([-1, 3]);
-    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2, 0.3], [0.2, 0.3, 0.4], [0.3, 0.4, 0.5])).toEqual([0.1, 0.5]);
-    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["b", "c", "d"], ["c", "d", "e"])).toEqual(["a", "e"]);
-    expect((0, _getArraysDiff.getArraysDiff)(["あ", "い", "う"], ["い", "う", "え"], ["う", "え", "お"])).toEqual(["あ", "お"]);
-    expect((0, _getArraysDiff.getArraysDiff)([true, false], [false, true], [true, false])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [2, "b", false], [3, "c", true])).toEqual([1, "a", 2, "b", false, 3, "c"]);
-  });
-
-  // Cases with empty arrays
-  test("should handle empty arrays", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([], [1, 2], [2, 3])).toEqual([1, 3]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [], [2, 3])).toEqual([1, 3]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [2, 3], [])).toEqual([1, 3]);
-    expect((0, _getArraysDiff.getArraysDiff)([], [], [1, 2, 3])).toEqual([1, 2, 3]);
-    expect((0, _getArraysDiff.getArraysDiff)(["a", "b"], [], ["b", "c"])).toEqual(["a", "c"]);
-    expect((0, _getArraysDiff.getArraysDiff)([], [true, false], [false, null])).toEqual([true, null]);
-    expect((0, _getArraysDiff.getArraysDiff)([{
-      x: 1
-    }], [], [{
-      z: 3
-    }])).toEqual([{
-      x: 1
-    }, {
-      z: 3
-    }]);
-    expect((0, _getArraysDiff.getArraysDiff)([], [[1, 2]], [[3, 4]])).toEqual([[1, 2], [3, 4]]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [], [3, "c", false])).toEqual([1, "a", true, 3, "c", false]);
-    expect((0, _getArraysDiff.getArraysDiff)([], [], [])).toEqual([]);
-  });
-
-  // Cases with no duplicate elements
-  test("should handle arrays with no duplicates", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2], [3, 4], [5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
-    expect((0, _getArraysDiff.getArraysDiff)(["a", "b"], ["c", "d"], ["e", "f"])).toEqual(["a", "b", "c", "d", "e", "f"]);
-    expect((0, _getArraysDiff.getArraysDiff)([true], [false], [null])).toEqual([true, false, null]);
-    expect((0, _getArraysDiff.getArraysDiff)([{
-      x: 1
-    }], [{
-      y: 2
-    }], [{
-      z: 3
-    }])).toEqual([{
-      x: 1
-    }, {
-      y: 2
-    }, {
-      z: 3
-    }]);
-    expect((0, _getArraysDiff.getArraysDiff)([[1]], [[2]], [[3]])).toEqual([[1], [2], [3]]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a"], [2, "b"], [3, "c"])).toEqual([1, "a", 2, "b", 3, "c"]);
-    expect((0, _getArraysDiff.getArraysDiff)([0.1], [0.2], [0.3])).toEqual([0.1, 0.2, 0.3]);
-    expect((0, _getArraysDiff.getArraysDiff)([new Date("2021-01-01")], [new Date("2021-01-02")], [new Date("2021-01-03")])).toEqual([new Date("2021-01-01"), new Date("2021-01-02"), new Date("2021-01-03")]);
-    expect((0, _getArraysDiff.getArraysDiff)([/a/], [/b/], [/c/])).toEqual([/a/, /b/, /c/]);
-  });
-
-  // Cases where all arrays have the same elements
-  test("should handle arrays with identical elements", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [1, 2, 3], [1, 2, 3])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["a", "b", "c"], ["a", "b", "c"])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([true, false], [true, false], [true, false])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [1, "a", true], [1, "a", true])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2], [0.1, 0.2], [0.1, 0.2])).toEqual([]);
-  });
-
-  // Cases where all arrays have the same elements but in different order
-  test("should handle arrays with identical elements in different order", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([1, 2, 3], [3, 1, 2], [2, 3, 1])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)(["a", "b", "c"], ["c", "a", "b"], ["b", "c", "a"])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([true, false, null], [null, true, false], [false, null, true])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [true, 1, "a"], ["a", true, 1])).toEqual([]);
-    expect((0, _getArraysDiff.getArraysDiff)([0.1, 0.2, 0.3], [0.3, 0.1, 0.2], [0.2, 0.3, 0.1])).toEqual([]);
-  });
-
-  // Cases with different types
-  test("should handle arrays with different types", function () {
-    expect((0, _getArraysDiff.getArraysDiff)([1, "a", true], [true, "a"], [1, 2])).toEqual([2]);
-    expect((0, _getArraysDiff.getArraysDiff)([{
-      x: 1
-    }, [1, 2], 3], ["a", true, null], [false, 5, {
-      y: 2
-    }])).toEqual([{
-      x: 1
-    }, [1, 2], 3, "a", true, null, false, 5, {
-      y: 2
-    }]);
-    expect((0, _getArraysDiff.getArraysDiff)([1, "2", true], ["1", 2, false], [true, "1", 2])).toEqual([1, "2", false]);
-    expect((0, _getArraysDiff.getArraysDiff)([0, ""], [false, null], [undefined, Number.NaN])).toEqual([0, "", false, null, undefined, Number.NaN]);
-    expect((0, _getArraysDiff.getArraysDiff)([1n, 2n], [BigInt(1), BigInt(2)], [1, 2])).toEqual([1, 2]);
-    expect((0, _getArraysDiff.getArraysDiff)([new Map()], [new Set()], [new WeakMap()])).toEqual([new Map(), new Set(), new WeakMap()]);
-    expect((0, _getArraysDiff.getArraysDiff)([Symbol.iterator], [Symbol.asyncIterator], [Symbol.toStringTag])).toEqual([Symbol.iterator, Symbol.asyncIterator, Symbol.toStringTag]);
-  });
-});

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

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

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

@@ -1,87 +0,0 @@
-"use strict";
-
-var _groupBy = require("@/Array/groupBy");
-describe("groupBy", function () {
-  it("should group numbers into odd and even", function () {
-    var array = [1, 2, 3, 4, 5];
-    var result = (0, _groupBy.groupBy)(array, function (num) {
-      return num % 2 === 0 ? "even" : "odd";
-    });
-    expect(result).toEqual({
-      odd: [1, 3, 5],
-      even: [2, 4]
-    });
-  });
-  it("should group strings based on their length", function () {
-    var array = ["one", "two", "three", "four", "five"];
-    var result = (0, _groupBy.groupBy)(array, function (str) {
-      return str.length.toString();
-    });
-    expect(result).toEqual({
-      "3": ["one", "two"],
-      "4": ["four", "five"],
-      "5": ["three"]
-    });
-  });
-  it("should group boolean values", function () {
-    var array = [true, false, true, false, true];
-    var result = (0, _groupBy.groupBy)(array, function (bool) {
-      return bool.toString();
-    });
-    expect(result).toEqual({
-      "true": [true, true, true],
-      "false": [false, false]
-    });
-  });
-  it("should group objects based on their properties", function () {
-    var array = [{
-      type: "fruit",
-      name: "apple"
-    }, {
-      type: "vegetable",
-      name: "carrot"
-    }, {
-      type: "fruit",
-      name: "banana"
-    }, {
-      type: "vegetable",
-      name: "lettuce"
-    }];
-    var result = (0, _groupBy.groupBy)(array, function (item) {
-      return item.type;
-    });
-    expect(result).toEqual({
-      fruit: [{
-        type: "fruit",
-        name: "apple"
-      }, {
-        type: "fruit",
-        name: "banana"
-      }],
-      vegetable: [{
-        type: "vegetable",
-        name: "carrot"
-      }, {
-        type: "vegetable",
-        name: "lettuce"
-      }]
-    });
-  });
-  it("should group all elements under undefined key when iterator returns undefined", function () {
-    var array = [1, 2, 3, 4, 5];
-    // @ts-ignore
-    var result = (0, _groupBy.groupBy)(array, function () {
-      return undefined;
-    });
-    expect(result).toEqual({
-      undefined: [1, 2, 3, 4, 5]
-    });
-  });
-  it("should return an empty object for an empty array", function () {
-    var array = [];
-    var result = (0, _groupBy.groupBy)(array, function (num) {
-      return num % 2 === 0 ? "even" : "odd";
-    });
-    expect(result).toEqual({});
-  });
-});

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

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

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

@@ -1,37 +0,0 @@
-"use strict";
-
-var _insertionSort = require("@/Array/insertionSort");
-describe("insertionSort", function () {
-  it("should return an empty array when sorting an empty array", function () {
-    expect((0, _insertionSort.insertionSort)([])).toEqual([]);
-  });
-  it("should return the same array when it's already sorted", function () {
-    expect((0, _insertionSort.insertionSort)([1, 2, 3])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a reverse-sorted array", function () {
-    expect((0, _insertionSort.insertionSort)([3, 2, 1])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a random array", 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, _insertionSort.insertionSort)(array)).toEqual(sortedArray);
-  });
-  it("should correctly sort an array with duplicate elements", function () {
-    expect((0, _insertionSort.insertionSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
-  });
-  it("should correctly sort an array with negative numbers", function () {
-    expect((0, _insertionSort.insertionSort)([5, -1, 3, 2, 4, -5, 1, -2, 0])).toEqual([-5, -2, -1, 0, 1, 2, 3, 4, 5]);
-  });
-  it("should sort array in descending order", function () {
-    expect((0, _insertionSort.insertionSort)([1, 2, 3], function (a, b) {
-      return b - a;
-    })).toEqual([3, 2, 1]);
-  });
-  it("should sort a portion of the array", function () {
-    expect((0, _insertionSort.insertionSort)([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/mergeSort.test.d.ts

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

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

@@ -1,49 +0,0 @@
-"use strict";
-
-var _mergeSort = require("@/Array/mergeSort");
-describe("mergeSort", function () {
-  it("should return an empty array when given an empty array", function () {
-    expect((0, _mergeSort.mergeSort)([])).toEqual([]);
-  });
-  it("should return the same array when it's already sorted", function () {
-    expect((0, _mergeSort.mergeSort)([1, 2, 3])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a reverse-sorted array", function () {
-    expect((0, _mergeSort.mergeSort)([3, 2, 1])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort a randomly ordered array", function () {
-    expect((0, _mergeSort.mergeSort)([2, 3, 1])).toEqual([1, 2, 3]);
-  });
-  it("should correctly sort an array with duplicate elements", function () {
-    expect((0, _mergeSort.mergeSort)([2, 3, 3, 1, 2])).toEqual([1, 2, 2, 3, 3]);
-  });
-  it("should handle a single-element array", function () {
-    expect((0, _mergeSort.mergeSort)([1])).toEqual([1]);
-  });
-  it("should correctly sort an array with negative numbers", function () {
-    expect((0, _mergeSort.mergeSort)([3, -1, 4, -5, 2, -3])).toEqual([-5, -3, -1, 2, 3, 4]);
-  });
-  it("should sort strings alphabetically", function () {
-    expect((0, _mergeSort.mergeSort)(["banana", "apple", "cherry"])).toEqual(["apple", "banana", "cherry"]);
-  });
-  it("should sort using custom comparison function", function () {
-    // Sort in descending order
-    var descendingCompare = function descendingCompare(a, b) {
-      return b - a;
-    };
-    expect((0, _mergeSort.mergeSort)([1, 3, 2], descendingCompare)).toEqual([3, 2, 1]);
-
-    // Sort strings by length
-    var lengthCompare = function lengthCompare(a, b) {
-      return a.length - b.length;
-    };
-    expect((0, _mergeSort.mergeSort)(["aaa", "a", "aa"], lengthCompare)).toEqual(["a", "aa", "aaa"]);
-  });
-  it("should handle arrays with mixed types when using appropriate compare function", function () {
-    var array = ["10", "2", "1"];
-    var numericCompare = function numericCompare(a, b) {
-      return Number(a) - Number(b);
-    };
-    expect((0, _mergeSort.mergeSort)(array, numericCompare)).toEqual(["1", "2", "10"]);
-  });
-});

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

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

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

@@ -1,50 +0,0 @@
-"use strict";
-
-var _pop = require("@/Array/pop");
-describe("pop", function () {
-  it("should remove and return the last element of the array", function () {
-    var array = [1, 2, 3];
-    var result = (0, _pop.pop)(array);
-    expect(result).toBe(3);
-    expect(array).toEqual([1, 2, 3]);
-  });
-  it("should return undefined for an empty array", function () {
-    var array = [];
-    var result = (0, _pop.pop)(array);
-    expect(result).toBeUndefined();
-  });
-  it("should handle arrays with one element", function () {
-    var array = [42];
-    var result = (0, _pop.pop)(array);
-    expect(result).toBe(42);
-    expect(array).toEqual([42]);
-  });
-  it("should handle arrays with multiple types", function () {
-    var array = [1, "two", true];
-    var result = (0, _pop.pop)(array);
-    expect(result).toBe(true);
-    expect(array).toEqual([1, "two", true]);
-  });
-  it("should handle arrays with nested arrays", function () {
-    var array = [1, [2, 3], 4];
-    var result = (0, _pop.pop)(array);
-    expect(result).toBe(4);
-    expect(array).toEqual([1, [2, 3], 4]);
-  });
-  it("should handle arrays with objects", function () {
-    var array = [{
-      a: 1
-    }, {
-      b: 2
-    }];
-    var result = (0, _pop.pop)(array);
-    expect(result).toEqual({
-      b: 2
-    });
-    expect(array).toEqual([{
-      a: 1
-    }, {
-      b: 2
-    }]);
-  });
-});