umt 1.9.0 → 2.1.0

package/module/es5/Validate/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/module/es5/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./Advance";
+export * from "./Array";
+export * from "./Color";
+export * from "./Consts";
+export * from "./Date";
+export * from "./Error";
+export * from "./IP";
+export * from "./Math";
+export * from "./Object";
+export * from "./Simple";
+export * from "./String";
+export * from "./Time";
+export * from "./Tool";
+export * from "./types";
+export * from "./UA";
+export * from "./Validate";

package/module/es5/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _Advance = require("./Advance");
+Object.keys(_Advance).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Advance[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Advance[key];
+    }
+  });
+});
+var _Array = require("./Array");
+Object.keys(_Array).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Array[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Array[key];
+    }
+  });
+});
+var _Color = require("./Color");
+Object.keys(_Color).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Color[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Color[key];
+    }
+  });
+});
+var _Consts = require("./Consts");
+Object.keys(_Consts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Consts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Consts[key];
+    }
+  });
+});
+var _Date = require("./Date");
+Object.keys(_Date).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Date[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Date[key];
+    }
+  });
+});
+var _Error = require("./Error");
+Object.keys(_Error).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Error[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Error[key];
+    }
+  });
+});
+var _IP = require("./IP");
+Object.keys(_IP).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _IP[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _IP[key];
+    }
+  });
+});
+var _Math = require("./Math");
+Object.keys(_Math).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Math[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Math[key];
+    }
+  });
+});
+var _Object = require("./Object");
+Object.keys(_Object).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Object[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Object[key];
+    }
+  });
+});
+var _Simple = require("./Simple");
+Object.keys(_Simple).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Simple[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Simple[key];
+    }
+  });
+});
+var _String = require("./String");
+Object.keys(_String).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _String[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _String[key];
+    }
+  });
+});
+var _Time = require("./Time");
+Object.keys(_Time).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Time[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Time[key];
+    }
+  });
+});
+var _Tool = require("./Tool");
+Object.keys(_Tool).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Tool[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Tool[key];
+    }
+  });
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _types[key];
+    }
+  });
+});
+var _UA = require("./UA");
+Object.keys(_UA).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _UA[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _UA[key];
+    }
+  });
+});
+var _Validate = require("./Validate");
+Object.keys(_Validate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Validate[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Validate[key];
+    }
+  });
+});

package/module/es5/tests/integration/Array/drop-and-first.test.d.ts

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

package/module/es5/tests/integration/Array/drop-and-first.test.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _first = require("@/Array/first");
+var _drop = require("@/Array/drop");
+describe("Integration test for 'drop' and 'first' functions", function () {
+  it("should drop n elements from the array and return the first element", function () {
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5]))).toBe(2);
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 2))).toBe(3);
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 3))).toBe(4);
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 4))).toBe(5);
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 2, "right"))).toBe(1);
+    expect((0, _first.first)((0, _drop.drop)([1, 2, 3, 4, 5], 3, "left"))).toBe(4);
+  });
+});

package/module/es5/tests/integration/Tool/parseJson-and-Validate.test.d.ts

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

package/module/es5/tests/integration/Tool/parseJson-and-Validate.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _parseJson = require("@/Tool/parseJson");
+var _boolean2 = require("@/Validate/boolean");
+var _number = require("@/Validate/number");
+var _object = require("@/Validate/object");
+describe("Integration test for 'parseJson' and 'Validate' functions", function () {
+  it("should parse JSON string with number values", function () {
+    var jsonString = '{"key": 123}';
+    var schema = (0, _object.object)({
+      key: (0, _number.number)()
+    });
+    var result = (0, _parseJson.parseJson)(jsonString);
+    var isValid = schema(result).validate;
+    expect(isValid).toEqual(true);
+  });
+  it("should parse JSON string with boolean values", function () {
+    var jsonString = '{"key": true}';
+    var schema = (0, _object.object)({
+      key: (0, _boolean2["boolean"])()
+    });
+    var result = (0, _parseJson.parseJson)(jsonString);
+    var isValid = schema(result).validate;
+    expect(isValid).toEqual(true);
+  });
+});

package/module/es5/tests/unit/Advance/rangeAdvance.test.d.ts

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

package/module/es5/tests/unit/Advance/rangeAdvance.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _rangeAdvance = require("@/Advance/rangeAdvance");
+describe("rangeAdvance", function () {
+  it("returns an array of numbers from 0 to start when only start is provided", function () {
+    expect((0, _rangeAdvance.rangeAdvance)(5)).toEqual([0, 1, 2, 3, 4]);
+  });
+  it("returns an array of numbers from start to end when both start and end are provided", function () {
+    expect((0, _rangeAdvance.rangeAdvance)(2, 5)).toEqual([2, 3, 4]);
+  });
+  it("returns an array of numbers that satisfy the conditional expression when a conditional expression is provided", function () {
+    var isEven = function isEven(num) {
+      return num % 2 === 0;
+    };
+    expect((0, _rangeAdvance.rangeAdvance)(0, 10, isEven)).toEqual([0, 2, 4, 6, 8]);
+  });
+  it("returns an empty array when start is greater than end", function () {
+    expect((0, _rangeAdvance.rangeAdvance)(5, 2)).toEqual([]);
+  });
+  it("returns an empty array when start is equal to end and the conditional expression is not satisfied", function () {
+    var isOdd = function isOdd(num) {
+      return num % 2 !== 0;
+    };
+    expect((0, _rangeAdvance.rangeAdvance)(5, 5, isOdd)).toEqual([]);
+  });
+});

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

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

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

@@ -0,0 +1,7 @@
+"use strict";
+
+var _arraysJoin = require("@/Array/arraysJoin");
+test("{arraysJoin}", function () {
+  expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6])).toEqual([1, 2, 3, 4, 5, 6]);
+  expect((0, _arraysJoin.arraysJoin)([1, 2, 3], [4, 5, 6], [7, 8, 9])).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+});

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+
+var _binarySearch = require("@/Array/binarySearch");
+describe("binarySearch", function () {
+  it("should return the correct index when the target is present", function () {
+    var array = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    expect((0, _binarySearch.binarySearch)(array, 7)).toBe(3);
+    expect((0, _binarySearch.binarySearch)(array, 1)).toBe(0);
+    expect((0, _binarySearch.binarySearch)(array, 19)).toBe(9);
+  });
+  it("should return -1 when the target is not present", function () {
+    var array = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    expect((0, _binarySearch.binarySearch)(array, 2)).toBe(-1);
+    expect((0, _binarySearch.binarySearch)(array, 20)).toBe(-1);
+    expect((0, _binarySearch.binarySearch)(array, 0)).toBe(-1);
+  });
+  it("should handle an empty array", function () {
+    var array = [];
+    expect((0, _binarySearch.binarySearch)(array, 1)).toBe(-1);
+  });
+  it("should handle a single-element array", function () {
+    var array = [5];
+    expect((0, _binarySearch.binarySearch)(array, 5)).toBe(0);
+    expect((0, _binarySearch.binarySearch)(array, 1)).toBe(-1);
+  });
+  it("should handle a two-element array", function () {
+    var array = [3, 6];
+    expect((0, _binarySearch.binarySearch)(array, 3)).toBe(0);
+    expect((0, _binarySearch.binarySearch)(array, 6)).toBe(1);
+    expect((0, _binarySearch.binarySearch)(array, 4)).toBe(-1);
+  });
+});

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

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

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

@@ -0,0 +1,206 @@
+"use strict";
+
+var _checkFlagAlignment = require("@/Array/checkFlagAlignment");
+describe("checkFlagAlignment", function () {
+  it("横", function () {
+    var matrix = [[{
+      value: 10,
+      flag: true
+    }, {
+      value: 20,
+      flag: true
+    }, {
+      value: 30,
+      flag: true
+    }], [{
+      value: 40,
+      flag: false
+    }, {
+      value: 50,
+      flag: false
+    }, {
+      value: 60,
+      flag: false
+    }], [{
+      value: 70,
+      flag: false
+    }, {
+      value: 80,
+      flag: false
+    }, {
+      value: 90,
+      flag: false
+    }]];
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("縦", function () {
+    var matrix = [[{
+      value: 10,
+      flag: false
+    }, {
+      value: 20,
+      flag: true
+    }, {
+      value: 30,
+      flag: false
+    }], [{
+      value: 40,
+      flag: false
+    }, {
+      value: 50,
+      flag: true
+    }, {
+      value: 60,
+      flag: false
+    }], [{
+      value: 70,
+      flag: false
+    }, {
+      value: 80,
+      flag: true
+    }, {
+      value: 90,
+      flag: false
+    }]];
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("斜め(左上)", function () {
+    var matrix = [[{
+      value: 10,
+      flag: true
+    }, {
+      value: 20,
+      flag: false
+    }, {
+      value: 30,
+      flag: false
+    }], [{
+      value: 40,
+      flag: false
+    }, {
+      value: 50,
+      flag: true
+    }, {
+      value: 60,
+      flag: false
+    }], [{
+      value: 70,
+      flag: false
+    }, {
+      value: 80,
+      flag: false
+    }, {
+      value: 90,
+      flag: true
+    }]];
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("斜め(右上)", function () {
+    var matrix = [[{
+      value: 10,
+      flag: false
+    }, {
+      value: 20,
+      flag: false
+    }, {
+      value: 30,
+      flag: true
+    }], [{
+      value: 40,
+      flag: false
+    }, {
+      value: 50,
+      flag: true
+    }, {
+      value: 60,
+      flag: false
+    }], [{
+      value: 70,
+      flag: true
+    }, {
+      value: 80,
+      flag: false
+    }, {
+      value: 90,
+      flag: false
+    }]];
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("揃ってない時", function () {
+    var matrix = [[{
+      value: 10,
+      flag: false
+    }, {
+      value: 20,
+      flag: true
+    }, {
+      value: 30,
+      flag: false
+    }], [{
+      value: 40,
+      flag: false
+    }, {
+      value: 50,
+      flag: true
+    }, {
+      value: 60,
+      flag: false
+    }], [{
+      value: 70,
+      flag: false
+    }, {
+      value: 80,
+      flag: false
+    }, {
+      value: 90,
+      flag: false
+    }]];
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(false);
+  });
+  // 以下、大量データのテスト
+  it("横(大量)", function () {
+    var row = Array(1000).fill({
+      flag: true,
+      value: 1
+    });
+    var matrix = Array(1000).fill(row);
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("縦(大量)", function () {
+    var row = Array(1000).fill({
+      flag: false,
+      value: 1
+    });
+    var matrix = Array(1000).fill(row);
+    for (var i = 0; i < matrix.length; i++) {
+      matrix[i][0].flag = true;
+    }
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("斜め(大量)", function () {
+    var matrix = Array.from({
+      length: 1000
+    }, function () {
+      return Array.from({
+        length: 1000
+      }, function () {
+        return {
+          flag: false,
+          value: 1
+        };
+      });
+    });
+    for (var i = 0; i < 1000; i++) {
+      matrix[i][i].flag = true;
+    }
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(true);
+  });
+  it("揃ってない時(大量)", function () {
+    var row = Array(1000).fill({
+      flag: false,
+      value: 1
+    });
+    var matrix = Array(1000).fill(row);
+    expect((0, _checkFlagAlignment.checkFlagAlignment)(matrix)).toBe(false);
+  });
+});

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

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

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

@@ -0,0 +1,51 @@
+"use strict";
+
+var _chunk = require("@/Array/chunk");
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+describe("chunkArray function", function () {
+  it("splits an array into chunks of size n", function () {
+    var input = [0, 1, 2, 3, 4, 5, 6, 7];
+    var n = 3;
+    var expected = [[0, 1, 2], [3, 4, 5], [6, 7]];
+    var output = (0, _chunk.chunk)(input, n);
+    expect(output).toEqual(expected);
+    var lodashOutput = _lodash["default"].chunk(input, n);
+    expect(lodashOutput).toEqual(expected);
+  });
+  it("handles empty arrays", function () {
+    var input = [];
+    var n = 3;
+    var expected = [];
+    var output = (0, _chunk.chunk)(input, n);
+    expect(output).toEqual(expected);
+    var lodashOutput = _lodash["default"].chunk(input, n);
+    expect(lodashOutput).toEqual(expected);
+  });
+  it("handles n larger than array length", function () {
+    var input = [0, 1, 2];
+    var n = 5;
+    var expected = [[0, 1, 2]];
+    var output = (0, _chunk.chunk)(input, n);
+    expect(output).toEqual(expected);
+    var lodashOutput = _lodash["default"].chunk(input, n);
+    expect(lodashOutput).toEqual(expected);
+  });
+  it("type checks", function () {
+    var input = [0, 1, 2, 3, 4, 5, 6, 7];
+    var n = 3;
+    var output = (0, _chunk.chunk)(input, n);
+    var expected = [[0, 1, 2], [3, 4, 5], [6, 7]];
+    expect(output).toEqual(expected);
+    var lodashOutput = _lodash["default"].chunk(input, n);
+    expect(lodashOutput).toEqual(expected);
+  });
+  it("does not mutate the input array", function () {
+    var input = [0, 1, 2, 3, 4, 5, 6, 7];
+    var n = 3;
+    (0, _chunk.chunk)(input, n);
+    expect(input).toEqual([0, 1, 2, 3, 4, 5, 6, 7]);
+    _lodash["default"].chunk(input, n);
+    expect(input).toEqual([0, 1, 2, 3, 4, 5, 6, 7]);
+  });
+});

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

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

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

@@ -0,0 +1,53 @@
+"use strict";
+
+var _compact = require("@/Array/compact");
+var _lodash = _interopRequireDefault(require("lodash"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+describe("compact関数のテスト", function () {
+  test("真偽値と数値が混在する配列", function () {
+    expect((0, _compact.compact)([0, 1, false, 2, "", 3])).toEqual([1, 2, 3]);
+    expect(_lodash["default"].compact([0, 1, false, 2, "", 3])).toEqual([1, 2, 3]);
+  });
+  test("全て真の値が含まれる配列", function () {
+    expect((0, _compact.compact)([1, 2, 3, "a", true])).toEqual([1, 2, 3, "a", true]);
+    expect(_lodash["default"].compact([1, 2, 3, "a", true])).toEqual([1, 2, 3, "a", true]);
+  });
+  test("全て偽の値が含まれる配列", function () {
+    expect((0, _compact.compact)([0, false, "", null, undefined, NaN])).toEqual([]);
+    expect(_lodash["default"].compact([0, false, "", null, undefined, NaN])).toEqual([]);
+  });
+  test("空の配列", function () {
+    expect((0, _compact.compact)([])).toEqual([]);
+    expect(_lodash["default"].compact([])).toEqual([]);
+  });
+  test("配列にnullやundefinedが含まれる", function () {
+    expect((0, _compact.compact)([null, undefined, "hello"])).toEqual(["hello"]);
+    expect(_lodash["default"].compact([null, undefined, "hello"])).toEqual(["hello"]);
+  });
+  test("配列に0や''などの他の偽の値が含まれる", function () {
+    expect((0, _compact.compact)([0, 1, "", 2, " ", 3])).toEqual([1, 2, " ", 3]);
+    expect(_lodash["default"].compact([0, 1, "", 2, " ", 3])).toEqual([1, 2, " ", 3]);
+  });
+  test("配列にオブジェクトや配列などの真値が含まれる", function () {
+    expect((0, _compact.compact)([{}, [], 0, false, "text"])).toEqual([{}, [], "text"]);
+    expect(_lodash["default"].compact([{}, [], 0, false, "text"])).toEqual([{}, [], "text"]);
+  });
+  test("配列にNaNが含まれる", function () {
+    expect((0, _compact.compact)([NaN, 1, 2, NaN])).toEqual([1, 2]);
+    expect(_lodash["default"].compact([NaN, 1, 2, NaN])).toEqual([1, 2]);
+  });
+  test("多種多様なデータ型が含まれる", function () {
+    expect((0, _compact.compact)([0, 1, "a", "", null, undefined, [], {}, false, true, NaN])).toEqual([1, "a", [], {}, true]);
+    expect(_lodash["default"].compact([0, 1, "a", "", null, undefined, [], {}, false, true, NaN])).toEqual([1, "a", [], {}, true]);
+  });
+  test("配列が変更されずに新しい配列を返すこと", function () {
+    var original = [0, 1, false, 2];
+    var result = (0, _compact.compact)(original);
+    expect(result).toEqual([1, 2]);
+    expect(original).toEqual([0, 1, false, 2]);
+    var lodashOriginal = [0, 1, false, 2];
+    var lodashResult = _lodash["default"].compact(lodashOriginal);
+    expect(lodashResult).toEqual([1, 2]);
+    expect(lodashOriginal).toEqual([0, 1, false, 2]);
+  });
+});

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

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