umt 2.2.1 → 2.4.0

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/Validate/object/core.d.ts

@@ -2,7 +2,7 @@
  * Object validation core module
  * Provides validation functionality for objects with type-specific validation rules for each property
  */
-import type { ValidateCoreReturnType, ValidateType } from "@/Validate/type";
+import type { Types, ValidateCoreReturnType, ValidateType } from "@/Validate/type";
 /**
  * Creates an object validator with property-specific validation rules
  * @template T - Object type containing validation functions for each property
@@ -12,8 +12,4 @@ import type { ValidateCoreReturnType, ValidateType } from "@/Validate/type";
  */
 export declare const object: <T extends {
     [key: string]: (value: any) => ValidateCoreReturnType<any>;
-}>(option?: T, message?: string) => (value: { [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }) => {
-    validate: boolean;
-    message: string;
-    type: { [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; };
-};
+}>(option?: T, message?: string) => (value: Types<{ [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }>) => ValidateCoreReturnType<{ [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }>;

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

@@ -33,3 +33,4 @@ export type ValidateFunctionType<T> = (value: T) => boolean;
  * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
  */
 export type ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;
+export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ReturnType<T>["type"];

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;