umt 2.2.1 → 2.3.0

package/module/es5/Tool/pipe.d.ts

@@ -0,0 +1,66 @@
+import { type Result } from "@/Error/safeExecute";
+/**
+ * A class to handle pipeline processing
+ * Allows chaining transformations in a fluent interface
+ * @template T Type of the current value
+ */
+export declare class Pipe<T> {
+    private readonly value;
+    /**
+     * @param value Current value in the pipe
+     */
+    constructor(value: T);
+    /**
+     * Applies a transformation function and returns a new Pipe instance
+     * @param fn Transformation function to apply
+     * @returns New Pipe instance with transformed value
+     */
+    map<U>(function_: (input: T) => U): Pipe<U>;
+    /**
+     * Applies a transformation function only if the condition is met
+     * @param predicate Condition function
+     * @param fn Transformation function to apply if condition is met
+     * @returns New Pipe instance with conditionally transformed value
+     */
+    when<U>(predicate: (input: T) => boolean, function_: (input: T) => U): Pipe<U | T>;
+    /**
+     * Executes a side effect without changing the value
+     * @param fn Function to execute as a side effect
+     * @returns Same Pipe instance
+     */
+    tap(function_: (input: T) => void): Pipe<T>;
+    /**
+     * Strictly filters the value based on a predicate function
+     * Throws an error if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with filtered value and narrowed type
+     * @throws Error if the predicate returns false
+     */
+    filterStrict<U extends T>(predicate: (input: T) => input is U): Pipe<U>;
+    /**
+     * Filters the value based on a predicate function
+     * Returns a default value if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @param defaultValue Default value to use if predicate returns false
+     * @returns New Pipe instance with filtered value or default value
+     */
+    filterWithDefault<U extends T>(predicate: (input: T) => input is U, defaultValue: U): Pipe<U>;
+    /**
+     * Filters the value based on a predicate function
+     * Returns a Result type containing either the filtered value or an error
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with Result containing filtered value or error
+     */
+    filterResult<U extends T>(predicate: (input: T) => input is U): Pipe<Result<U, Error>>;
+    /**
+     * Terminates the pipeline and returns the final value
+     * @returns Final result of the pipeline processing
+     */
+    end(): T;
+}
+/**
+ * Creates a new Pipe instance with an initial value
+ * @param initialValue Initial value for the pipeline
+ * @returns New Pipe instance
+ */
+export declare function pipe<T>(initialValue: T): Pipe<T>;

package/module/es5/Tool/pipe.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Pipe = void 0;
+exports.pipe = pipe;
+var _safeExecute = require("@/Error/safeExecute");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * A class to handle pipeline processing
+ * Allows chaining transformations in a fluent interface
+ * @template T Type of the current value
+ */
+var Pipe = exports.Pipe = /*#__PURE__*/function () {
+  /**
+   * @param value Current value in the pipe
+   */
+  function Pipe(value) {
+    _classCallCheck(this, Pipe);
+    this.value = value;
+  }
+
+  /**
+   * Applies a transformation function and returns a new Pipe instance
+   * @param fn Transformation function to apply
+   * @returns New Pipe instance with transformed value
+   */
+  return _createClass(Pipe, [{
+    key: "map",
+    value: function map(function_) {
+      return new Pipe(function_(this.value));
+    }
+
+    /**
+     * Applies a transformation function only if the condition is met
+     * @param predicate Condition function
+     * @param fn Transformation function to apply if condition is met
+     * @returns New Pipe instance with conditionally transformed value
+     */
+  }, {
+    key: "when",
+    value: function when(predicate, function_) {
+      return predicate(this.value) ? new Pipe(function_(this.value)) : new Pipe(this.value);
+    }
+
+    /**
+     * Executes a side effect without changing the value
+     * @param fn Function to execute as a side effect
+     * @returns Same Pipe instance
+     */
+  }, {
+    key: "tap",
+    value: function tap(function_) {
+      function_(this.value);
+      return this;
+    }
+
+    /**
+     * Strictly filters the value based on a predicate function
+     * Throws an error if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with filtered value and narrowed type
+     * @throws Error if the predicate returns false
+     */
+  }, {
+    key: "filterStrict",
+    value: function filterStrict(predicate) {
+      if (predicate(this.value)) {
+        return new Pipe(this.value);
+      }
+      throw new Error("Value did not match filter predicate");
+    }
+
+    /**
+     * Filters the value based on a predicate function
+     * Returns a default value if the predicate returns false
+     * @param predicate Condition function that determines if value should be filtered
+     * @param defaultValue Default value to use if predicate returns false
+     * @returns New Pipe instance with filtered value or default value
+     */
+  }, {
+    key: "filterWithDefault",
+    value: function filterWithDefault(predicate, defaultValue) {
+      return predicate(this.value) ? new Pipe(this.value) : new Pipe(defaultValue);
+    }
+
+    /**
+     * Filters the value based on a predicate function
+     * Returns a Result type containing either the filtered value or an error
+     * @param predicate Condition function that determines if value should be filtered
+     * @returns New Pipe instance with Result containing filtered value or error
+     */
+  }, {
+    key: "filterResult",
+    value: function filterResult(predicate) {
+      var _this = this;
+      return new Pipe((0, _safeExecute.safeExecute)(function () {
+        if (predicate(_this.value)) {
+          return _this.value;
+        }
+        throw new Error("Value did not match filter predicate");
+      }));
+    }
+
+    /**
+     * Terminates the pipeline and returns the final value
+     * @returns Final result of the pipeline processing
+     */
+  }, {
+    key: "end",
+    value: function end() {
+      return this.value;
+    }
+  }]);
+}();
+/**
+ * Creates a new Pipe instance with an initial value
+ * @param initialValue Initial value for the pipeline
+ * @returns New Pipe instance
+ */
+function pipe(initialValue) {
+  return new Pipe(initialValue);
+}

package/module/es5/Validate/index.d.ts

@@ -15,4 +15,5 @@ export * from "./isNotEmpty";
 export * from "./isNumber";
 export * from "./isPerfectSquare";
 export * from "./isPrimeNumber";
+export * from "./isString";
 export * from "./isValueNaN";

package/module/es5/Validate/index.js

@@ -190,6 +190,17 @@ Object.keys(_isPrimeNumber).forEach(function (key) {
     }
   });
 });
+var _isString = require("./isString");
+Object.keys(_isString).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _isString[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _isString[key];
+    }
+  });
+});
 var _isValueNaN = require("./isValueNaN");
 Object.keys(_isValueNaN).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/isString.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Determines if the value is a string
+ * @param  {unknown} value - Value to check
+ * @returns boolean - True if the value is a string, false otherwise
+ * @example isString("test"); // true
+ * isString(123); // false
+ */
+declare const isString: (value: unknown) => value is string;
+export { isString };

package/module/es5/Validate/isString.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isString = void 0;
+/**
+ * Determines if the value is a string
+ * @param  {unknown} value - Value to check
+ * @returns boolean - True if the value is a string, false otherwise
+ * @example isString("test"); // true
+ * isString(123); // false
+ */
+var isString = exports.isString = function isString(value) {
+  return typeof value === "string";
+};

package/module/es5/index.d.ts

@@ -4,6 +4,7 @@ export * from "./Color";
 export * from "./Consts";
 export * from "./Date";
 export * from "./Error";
+export * from "./Function";
 export * from "./IP";
 export * from "./Math";
 export * from "./Object";

package/module/es5/index.js

@@ -69,6 +69,17 @@ Object.keys(_Error).forEach(function (key) {
     }
   });
 });
+var _Function = require("./Function");
+Object.keys(_Function).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Function[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Function[key];
+    }
+  });
+});
 var _IP = require("./IP");
 Object.keys(_IP).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/tests/unit/Function/curry.test.d.ts

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

package/module/es5/tests/unit/Function/curry.test.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _curry = require("@/Function/curry");
+describe("curry", function () {
+  test("should curry a function with 0 arguments", function () {
+    var func = function func() {
+      return "hello";
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc()).toBe("hello");
+  });
+  test("should curry a function with 1 argument", function () {
+    var func = function func(a) {
+      return a * 2;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(5)).toBe(10);
+  });
+  test("should curry a function with 2 arguments", function () {
+    var func = function func(a, b) {
+      return a + b;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(2)(3)).toBe(5);
+    expect(curriedFunc(2, 3)).toBe(5);
+  });
+  test("should curry a function with 3 arguments", function () {
+    var func = function func(a, b, c) {
+      return a * b + c;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(2)(3)(4)).toBe(10);
+    expect(curriedFunc(2, 3)(4)).toBe(10);
+    expect(curriedFunc(2)(3, 4)).toBe(10);
+    expect(curriedFunc(2, 3, 4)).toBe(10);
+  });
+  test("should curry a function with 4 arguments", function () {
+    var func = function func(a, b, c, d) {
+      return a + b + c + d;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(1)(2)(3)(4)).toBe(10);
+    expect(curriedFunc(1, 2)(3)(4)).toBe(10);
+    expect(curriedFunc(1)(2, 3)(4)).toBe(10);
+    expect(curriedFunc(1)(2)(3, 4)).toBe(10);
+    expect(curriedFunc(1, 2, 3)(4)).toBe(10);
+    expect(curriedFunc(1, 2)(3, 4)).toBe(10);
+    expect(curriedFunc(1, 2, 3, 4)).toBe(10);
+  });
+  test("should curry a function with 5 arguments", function () {
+    var func = function func(a, b, c, d, e) {
+      return a + b + c + d + e;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(1)(2)(3)(4)(5)).toBe(15);
+    expect(curriedFunc(1, 2)(3)(4)(5)).toBe(15);
+    expect(curriedFunc(1)(2, 3)(4)(5)).toBe(15);
+    expect(curriedFunc(1)(2)(3, 4)(5)).toBe(15);
+    expect(curriedFunc(1)(2)(3)(4, 5)).toBe(15);
+    expect(curriedFunc(1, 2, 3)(4)(5)).toBe(15);
+    expect(curriedFunc(1, 2)(3, 4)(5)).toBe(15);
+    expect(curriedFunc(1, 2)(3)(4, 5)).toBe(15);
+    expect(curriedFunc(1, 2, 3, 4)(5)).toBe(15);
+    expect(curriedFunc(1, 2, 3)(4, 5)).toBe(15);
+    expect(curriedFunc(1, 2, 3, 4, 5)).toBe(15);
+  });
+  test("should curry a function with 6 arguments", function () {
+    var func = function func(a, b, c, d, e, f) {
+      return a + b + c + d + e + f;
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(1)(2)(3)(4)(5)(6)).toBe(21);
+    expect(curriedFunc(1, 2)(3)(4)(5)(6)).toBe(21);
+    expect(curriedFunc(1)(2, 3)(4)(5)(6)).toBe(21);
+    expect(curriedFunc(1)(2)(3, 4)(5)(6)).toBe(21);
+    expect(curriedFunc(1)(2)(3)(4, 5)(6)).toBe(21);
+    expect(curriedFunc(1)(2)(3)(4)(5, 6)).toBe(21);
+    expect(curriedFunc(1, 2, 3)(4)(5)(6)).toBe(21);
+    expect(curriedFunc(1, 2)(3, 4)(5)(6)).toBe(21);
+    expect(curriedFunc(1, 2)(3)(4, 5)(6)).toBe(21);
+    expect(curriedFunc(1, 2)(3)(4)(5, 6)).toBe(21);
+    expect(curriedFunc(1, 2, 3, 4)(5)(6)).toBe(21);
+    expect(curriedFunc(1, 2, 3)(4, 5)(6)).toBe(21);
+    expect(curriedFunc(1, 2, 3)(4)(5, 6)).toBe(21);
+    expect(curriedFunc(1, 2, 3, 4, 5)(6)).toBe(21);
+    expect(curriedFunc(1, 2, 3, 4)(5, 6)).toBe(21);
+    expect(curriedFunc(1, 2, 3, 4, 5, 6)).toBe(21);
+  });
+  test("should handle different argument types", function () {
+    var func = function func(a, b, c) {
+      return "".concat(a).concat(b).concat(c);
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc(1)("hello")(true)).toBe("1hellotrue");
+    expect(curriedFunc(1, "hello")(true)).toBe("1hellotrue");
+    expect(curriedFunc(1)("hello", true)).toBe("1hellotrue");
+    expect(curriedFunc(1, "hello", true)).toBe("1hellotrue");
+  });
+
+  // 追加テスト
+
+  test("should curry a function with object and array arguments", function () {
+    var func = function func(obj, arr) {
+      return obj.x + arr.reduce(function (a, b) {
+        return a + b;
+      }, 0);
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    expect(curriedFunc({
+      x: 5
+    })([1, 2, 3])).toBe(11);
+    expect(curriedFunc({
+      x: 5
+    }, [1, 2, 3])).toBe(11);
+  });
+  test("should curry a function with function arguments", function () {
+    var func = function func(f, x) {
+      return f(x);
+    };
+    var curriedFunc = (0, _curry.curry)(func);
+    var _double = function _double(x) {
+      return x * 2;
+    };
+    expect(curriedFunc(_double)(5)).toBe(10);
+    expect(curriedFunc(_double, 5)).toBe(10);
+  });
+  test("should preserve the original 'this' context", function () {
+    var obj = {
+      multiplier: 2,
+      multiply: function multiply(a, b) {
+        return a * b * this.multiplier;
+      }
+    };
+    var curriedMultiply = (0, _curry.curry)(obj.multiply.bind(obj));
+    expect(curriedMultiply(3)(4)).toBe(24);
+    expect(curriedMultiply(3, 4)).toBe(24);
+  });
+});

package/module/es5/tests/unit/Tool/pipe.test.d.ts

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