devix 0.0.22 → 0.0.23-beta.10

package/README.md

@@ -1,36 +1,36 @@
 # devix
 
-> devix 是一个全面的、强大的、紧凑的 JavaScript 实用程序库（ 简体中文 | [English](README_en.md) ）
+> Devix is a comprehensive, powerful, and compact JavaScript utility library.（ English | [简体中文](README.md) ）
 
-## 安装
+## Install
 
-请确保您在 Node.js 环境下使用 npm 或其他包管理器安装此库。
+Please make sure you install this library using npm or another package manager in a Node.js environment.
 
 ```shell
 npm install --save-dev devix
 ```
 
-然后，利用现代的模块捆绑工具，如 Vite 或 Webpack，以模块化的语法引入此库。
+Then, utilize modern module bundling tools such as Vite or Webpack to import this library using modular syntax.
 
 ```javascript
-// 使用 ES Module
+// Using ES Module
 import { [[ModuleName]] } from 'devix'
 
-// 使用 CommonJS
+// Using CommonJS
 const { [[ModuleName]]  } = require('devix')
 ```
 
-## 使用
+## Usage
 
 ```javascript
 import { localCache, bubblingSort, isType } from 'devix'
 
-// 使用 localCache
+// Using localCache
 localCache.setCache('userInfo', { name: 'king', age: 18 })
 const userInfo = localCache.get('userInfo')
 console.log('userInfo', userInfo)
 
-// 使用 bubblingSort、
+// Using bubblingSort、
 const arr1 = [123, 346, 62, 2456, 56123, 1, 64, 61, 453, 72345]
 const sortArr1 = bubblingSort(arr1, 'DESC')
 console.log('sortArr1', sortArr1)
@@ -43,7 +43,7 @@ const arr2 = [
 const sortArr2 = bubblingSort(arr2, 'DESC', 'age')
 console.log('sortArr2', sortArr2)
 
-// 使用 isType
+// Using isType
 console.log(`isType(userInfo,'object') -> true`, isType(userInfo, 'object'))
 console.log(
   `isType(userInfo.name,'string') -> true`,
@@ -52,51 +52,51 @@ console.log(
 console.log(`isType(userInfo.age,'number') -> true`, isType(userInfo, 'number'))
 ```
 
-## 方法
+## API
 
-### 缓存相关
+### Cache Apis
 
-提供缓存操作的相关方法。
+Provides methods related to cache operations.
 
 - localCache
 - sessionCache
 
-### 拷贝相关
+### Clone Apis
 
-用于数据复制操作的相关方法。
+Methods for data cloning operations.
 
 - deepClone
 - shallowClone
 
-### 限频相关
+### Retalimit Apis
 
-包含控制操作触发频率的相关方法。
+Includes methods for controlling the frequency of operations.
 
 - throttle
 - debounce
 
-### 排序相关
+### Sort Apis
 
-提供各种排序操作的方法。
+Offers methods for various sorting operations.
 
 - bubblingSort
 
-### 时间相关
+### Time Apis
 
-包括处理时间相关操作的方法。
+Consists of methods for handling time-related operations.
 
 - formatTimer
 - setTimer
 
-### 类型相关
+### Typeof Apis
 
-用于数据类型检测的相关方法。
+Methods for data type detection.
 
 - isType
 
-### 其他方法
+### Other Apis
 
-包括各种其他功能性函数和方法。
+Includes a variety of other functional functions and methods.
 
 - compose
 - currying

package/dist/index.js

@@ -0,0 +1,306 @@
+'use strict';
+
+function getDataType(target) {
+  const type = typeof target;
+  return type != "object" ? type : Object.prototype.toString.call(target).slice(8, -1).toLowerCase();
+}
+const typeCheckers = {
+  // DataType
+  undefined: (target) => typeof target === "undefined",
+  null: (target) => target === null,
+  number: (target) => typeof target === "number",
+  string: (target) => typeof target === "string",
+  boolean: (target) => typeof target === "boolean",
+  symbol: (target) => typeof target === "symbol",
+  bigint: (target) => typeof target === "bigint",
+  // ObjectType
+  object: (target) => target !== null && typeof target === "object",
+  array: (target) => Array.isArray(target),
+  date: (target) => target instanceof Date,
+  function: (target) => typeof target === "function",
+  set: (target) => target instanceof Set,
+  map: (target) => target instanceof Map,
+  regexp: (target) => target instanceof RegExp,
+  promise: (target) => target instanceof Promise,
+  // ExpandType
+  empty: (target) => !(target !== null && target !== "" && typeof target !== "undefined")
+};
+const isType = (type, target) => {
+  const dataType = typeCheckers[type] ? typeCheckers[type](target) : getDataType(target) === type;
+  return dataType;
+};
+
+function currying(fn) {
+  function curried(...args) {
+    if (args.length >= fn.length) {
+      return fn.apply(this, args);
+    } else {
+      return function(...args2) {
+        return curried.apply(this, args.concat(args2));
+      };
+    }
+  }
+  return curried;
+}
+function compose(...fns) {
+  const length = fns.length;
+  if (length <= 0) return;
+  for (let i = 0; i < length; i++) {
+    const fn = fns[i];
+    if (typeof fn !== "function") {
+      throw new Error(`argument with index ${i} is not a function`);
+    }
+  }
+  return function(...args) {
+    let index = 0;
+    let result = fns[index].apply(this, args);
+    while (++index < length) {
+      result = fns[index].call(this, result);
+    }
+    return result;
+  };
+}
+function insertStr(soure, start, newStr) {
+  return soure.slice(0, start) + newStr + soure.slice(start);
+}
+function stringCase(soure, separa = ["", ""], cases = ["upper", "upper"]) {
+  const [separator, separate] = separa;
+  const [firstCase, argsCase] = cases;
+  const newStr = soure.split(separator);
+  for (let i = 0; i < newStr.length; i++) {
+    newStr[i] = setCaseType(newStr[i], i === 0 ? firstCase : argsCase);
+  }
+  return newStr.join(separate);
+}
+function setCaseType(soure, caseType) {
+  const newStr = soure.slice(0, 1)[caseType === "upper" ? "toUpperCase" : "toLowerCase"]() + soure.slice(1).toLowerCase();
+  return newStr;
+}
+const transformGetParams = (params) => {
+  let result = "";
+  for (const propName of Object.keys(params)) {
+    const value = params[propName];
+    const part = `${encodeURIComponent(propName)}=`;
+    if (isType("empty", value)) continue;
+    if (!isType("object", value)) {
+      result += `${part + encodeURIComponent(value)}&`;
+      continue;
+    }
+    for (const key of Object.keys(value)) {
+      if (isType("empty", value)) continue;
+      const params2 = propName + `[${key}]`;
+      const subPart = `${encodeURIComponent(params2)}=`;
+      result += `${subPart + encodeURIComponent(value[key])}&`;
+    }
+  }
+  return result.slice(0, -1);
+};
+
+function debounce(callback, delay = 0, immediate = false) {
+  let timer = null;
+  let isInvoke = false;
+  function _debounce(...args) {
+    return new Promise((resolve, reject) => {
+      if (timer !== null) clearTimeout(timer);
+      if (immediate && !isInvoke) {
+        try {
+          const result = callback.apply(this, args);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+        isInvoke = true;
+        return;
+      }
+      timer = setTimeout(() => {
+        try {
+          const result = callback.apply(this, args);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        } finally {
+          timer = null;
+          isInvoke = false;
+        }
+      }, delay);
+    });
+  }
+  _debounce.cancel = function() {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+    isInvoke = false;
+  };
+  return _debounce;
+}
+function throttle(callback, interval, options = {}) {
+  const {
+    leading = true,
+    trailing = false
+  } = options;
+  let startTime = 0;
+  let timer = null;
+  function _throttle(...args) {
+    return new Promise((resolve, reject) => {
+      try {
+        const nowTime = Date.now();
+        let result;
+        if (!leading && startTime === 0) startTime = nowTime;
+        const waitTime = interval - (nowTime - startTime);
+        if (waitTime <= 0) {
+          if (timer) clearTimeout(timer);
+          result = callback.apply(this, args);
+          resolve(result);
+          startTime = nowTime;
+          timer = null;
+          return;
+        }
+        if (trailing && !timer) {
+          timer = setTimeout(() => {
+            result = callback.apply(this, args);
+            resolve(result);
+            startTime = Date.now();
+            timer = null;
+          }, waitTime);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  _throttle.cancel = function() {
+    if (timer) clearTimeout(timer);
+    startTime = 0;
+    timer = null;
+  };
+  return _throttle;
+}
+
+//! Function Shallow Copy
+function shallowClone(source) {
+  if (isType("array", source)) return source.slice();
+  if (isType("object", source)) return {
+    ...source
+  };
+  return source;
+}
+//! Function Deep Copy
+const isFormat = (target) => isType("object", target) || isType("function", target);
+function handleSpeciBoundar(source, deepClone2, hash) {
+  if (isType("symbol", source)) return Symbol(source.description);
+  if (!isFormat(source)) return source;
+  if (isType("set", source)) {
+    const newSet = /* @__PURE__ */ new Set();
+    source.forEach((value) => newSet.add(deepClone2(value, hash)));
+    return newSet;
+  }
+  if (isType("map", source)) {
+    const newMap = /* @__PURE__ */ new Map();
+    source.forEach((value, key) => newMap.set(key, deepClone2(value, hash)));
+    return newMap;
+  }
+}
+function deepClone(source, hash = /* @__PURE__ */ new WeakMap()) {
+  if (hash.get(source)) return hash.get(source);
+  const result = handleSpeciBoundar(source, deepClone, hash);
+  if (result) return result;
+  const isArray = isType("array", source);
+  const cloneObject = isArray ? [] : {};
+  hash.set(source, cloneObject);
+  if (isArray) {
+    source.forEach((item, index) => {
+      cloneObject[index] = deepClone(item, hash);
+    });
+  } else {
+    Object.keys(source).forEach((key) => {
+      cloneObject[key] = deepClone(source[key], hash);
+    });
+    Object.getOwnPropertySymbols(source).forEach((sym) => {
+      cloneObject[Symbol(sym.description)] = deepClone(source[sym], hash);
+    });
+  }
+  return cloneObject;
+}
+
+exports.SortType = void 0;
+(function(SortType2) {
+  SortType2["ASC"] = "ASC";
+  SortType2["DESC"] = "DESC";
+})(exports.SortType || (exports.SortType = {}));
+function swap(array, index1, index2) {
+  [array[index1], array[index2]] = [array[index2], array[index1]];
+}
+function compare(value1, value2, type) {
+  return type === exports.SortType.ASC ? value1 > value2 : value1 < value2;
+}
+function bubblingSort(array, type = "ASC", key) {
+  const length = array.length;
+  if (length < 2) return array;
+  for (let i = 0; i < length - 1; i++) {
+    for (let j = 0; j < length - 1 - i; j++) {
+      const value1 = key ? array[j][key] : array[j];
+      const value2 = key ? array[j + 1][key] : array[j + 1];
+      if (compare(value1, value2, type)) swap(array, j, j + 1);
+    }
+  }
+  return array;
+}
+
+const formatRules = /* @__PURE__ */ new Map([["yyyy", "year"], ["MM", "month"], ["dd", "day"], ["HH", "hours"], ["mm", "minutes"], ["ss", "seconds"], ["W", "week"]]);
+const WeekList = /* @__PURE__ */ new Map([[1, "\u4E00"], [2, "\u4E8C"], [3, "\u4E09"], [4, "\u56DB"], [5, "\u4E94"], [6, "\u516D"], [0, "\u65E5"]]);
+function processWeek(weekNum) {
+  return WeekList.get(weekNum) || "";
+}
+function formatNumber(value) {
+  return value.toString().padStart(2, "0");
+}
+function createTimerObj(date) {
+  const dayOfWeek = date.getDay() === 0 ? 7 : date.getDay();
+  return {
+    year: date.getFullYear().toString(),
+    month: formatNumber(date.getMonth() + 1),
+    day: formatNumber(date.getDate()),
+    hours: formatNumber(date.getHours()),
+    minutes: formatNumber(date.getMinutes()),
+    seconds: formatNumber(date.getSeconds()),
+    week: processWeek(dayOfWeek),
+    weekNum: dayOfWeek.toString()
+  };
+}
+const formatTimer = (cellValue, formatType = "yyyy-MM-dd HH:mm:ss") => {
+  if (!cellValue) return (/* @__PURE__ */ new Date()).toISOString();
+  const date = new Date(cellValue);
+  const timerObj = createTimerObj(date);
+  if (isType("string", formatType) && !formatType.trim()) return timerObj;
+  const timerStr = Array.from(formatRules).reduce((currentFormat, [rule, key]) => {
+    return currentFormat.replace(new RegExp(rule, "g"), timerObj[key]);
+  }, formatType);
+  return timerStr;
+};
+async function setTimer(execute, delay = 0, immediate = false) {
+  let timer = null;
+  const interval = async () => {
+    await execute();
+    timer = setTimeout(interval, delay);
+  };
+  if (immediate) await execute();
+  setTimeout(interval, delay);
+  return {
+    cancel: () => {
+      if (timer !== null) clearTimeout(timer);
+    }
+  };
+}
+
+exports.bubblingSort = bubblingSort;
+exports.compose = compose;
+exports.currying = currying;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.formatTimer = formatTimer;
+exports.insertStr = insertStr;
+exports.isType = isType;
+exports.setTimer = setTimer;
+exports.shallowClone = shallowClone;
+exports.stringCase = stringCase;
+exports.throttle = throttle;
+exports.transformGetParams = transformGetParams;