devix 0.0.22 → 0.0.23-beta.10

package/dist/index.mjs

@@ -0,0 +1,292 @@
+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;
+}
+
+var SortType;
+(function(SortType2) {
+  SortType2["ASC"] = "ASC";
+  SortType2["DESC"] = "DESC";
+})(SortType || (SortType = {}));
+function swap(array, index1, index2) {
+  [array[index1], array[index2]] = [array[index2], array[index1]];
+}
+function compare(value1, value2, type) {
+  return type === 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);
+    }
+  };
+}
+
+export { SortType, bubblingSort, compose, currying, debounce, deepClone, formatTimer, insertStr, isType, setTimer, shallowClone, stringCase, throttle, transformGetParams };

package/index.d.ts

@@ -0,0 +1,53 @@
+interface ITimerObj {
+    year: string;
+    month: string;
+    day: string;
+    hours: string;
+    minutes: string;
+    seconds: string;
+    week: string;
+    weekNum: string;
+}
+type TFormatTimer = (cellValue: string | number | Date, formatType?: string) => string | ITimerObj;
+type ThrottleOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+type TIsType = (type: string, target: any) => boolean;
+type Tcase = 'upper' | 'lower';
+type TCases = [Tcase, Tcase];
+type TTransGetParams = (params: IDataObject) => string;
+interface IDataObject {
+    [key: string]: any;
+}
+
+declare function currying(fn: Function): (this: any, ...args: any[]) => any;
+declare function compose(...fns: Function[]): ((this: any, ...args: any[]) => any) | undefined;
+declare function insertStr(soure: string, start: number, newStr: string): string;
+declare function stringCase(soure: string, separa?: string[], cases?: TCases): string;
+declare const transformGetParams: TTransGetParams;
+
+declare const isType: TIsType;
+
+declare function debounce<T extends (...args: any[]) => any>(callback: T, delay?: number, immediate?: boolean): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+    cancel: () => void;
+};
+declare function throttle<T extends (...args: any[]) => any>(callback: T, interval: number, options?: ThrottleOptions): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+    cancel: () => void;
+};
+
+declare function shallowClone<T = any>(source: T): T;
+declare function deepClone(source: any, hash?: WeakMap<object, any>): any;
+
+declare enum SortType {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+declare function bubblingSort<T>(array: T[], type?: string, key?: keyof T): T[];
+
+declare const formatTimer: TFormatTimer;
+declare function setTimer(execute: (...args: any[]) => any, delay?: number, immediate?: boolean): Promise<{
+    cancel: () => void;
+}>;
+
+export { SortType, bubblingSort, compose, currying, debounce, deepClone, formatTimer, insertStr, isType, setTimer, shallowClone, stringCase, throttle, transformGetParams };

package/lib/cache/index.d.ts

@@ -0,0 +1,24 @@
+declare enum CacheType {
+    Local = 0,
+    Session = 1
+}
+
+/**
+ *  Encapsulate storage cache class
+ *
+ * @class StorageCache
+ * @template T
+ */
+declare class StorageCache<T = any> {
+    private storage;
+    constructor(type: CacheType);
+    getCache(key: string): T;
+    setCache(key: string, value: T): void;
+    updateCache(key: string, property: string, value: T): void;
+    deleteCache(key: string): void;
+    clearCache(): void;
+}
+declare const localCache: StorageCache<any>;
+declare const sessionCache: StorageCache<any>;
+
+export { localCache, sessionCache };

package/lib/cache/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const isObject = (target) => target !== null && typeof target === "object";
+var CacheType;
+(function(CacheType2) {
+  CacheType2[CacheType2["Local"] = 0] = "Local";
+  CacheType2[CacheType2["Session"] = 1] = "Session";
+})(CacheType || (CacheType = {}));
+
+class StorageCache {
+  constructor(type) {
+    this.storage = type === CacheType.Local ? localStorage : sessionStorage;
+  }
+  getCache(key) {
+    const value = this.storage.getItem(key);
+    return value ? JSON.parse(value) : null;
+  }
+  setCache(key, value) {
+    this.storage.setItem(key, JSON.stringify(value));
+  }
+  updateCache(key, property, value) {
+    const cache = this.getCache(key);
+    if (!isObject(cache)) return;
+    cache[property] = value;
+    this.setCache(key, cache);
+  }
+  deleteCache(key) {
+    this.storage.removeItem(key);
+  }
+  clearCache() {
+    this.storage.clear();
+  }
+}
+const localCache = new StorageCache(CacheType.Local);
+const sessionCache = new StorageCache(CacheType.Session);
+
+exports.localCache = localCache;
+exports.sessionCache = sessionCache;

package/lib/cache/index.mjs

@@ -0,0 +1,35 @@
+const isObject = (target) => target !== null && typeof target === "object";
+var CacheType;
+(function(CacheType2) {
+  CacheType2[CacheType2["Local"] = 0] = "Local";
+  CacheType2[CacheType2["Session"] = 1] = "Session";
+})(CacheType || (CacheType = {}));
+
+class StorageCache {
+  constructor(type) {
+    this.storage = type === CacheType.Local ? localStorage : sessionStorage;
+  }
+  getCache(key) {
+    const value = this.storage.getItem(key);
+    return value ? JSON.parse(value) : null;
+  }
+  setCache(key, value) {
+    this.storage.setItem(key, JSON.stringify(value));
+  }
+  updateCache(key, property, value) {
+    const cache = this.getCache(key);
+    if (!isObject(cache)) return;
+    cache[property] = value;
+    this.setCache(key, cache);
+  }
+  deleteCache(key) {
+    this.storage.removeItem(key);
+  }
+  clearCache() {
+    this.storage.clear();
+  }
+}
+const localCache = new StorageCache(CacheType.Local);
+const sessionCache = new StorageCache(CacheType.Session);
+
+export { localCache, sessionCache };

package/package.json

@@ -1,82 +1,88 @@
 {
   "name": "devix",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.23-beta.10",
   "description": "Devix is a comprehensive, powerful, and compact JavaScript utility library.",
   "author": "king-3 <w2196592083@gmail.com>",
   "license": "MIT",
   "homepage": "https://github.com/OpenKnights/devix#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/OpenKnights/devix.git"
+    "url": "git+https://github.com/OpenKnights/devix.git"
   },
   "bugs": {
     "url": "https://github.com/OpenKnights/devix/issues"
   },
   "keywords": [
-    "devix",
-    "utils",
-    "tools",
-    "develop"
+    "template",
+    "library"
   ],
   "exports": {
     ".": {
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs.js"
+      "types": "./index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./lib/cache": {
+      "types": "./lib/cache/index.d.ts",
+      "require": "./lib/cache/index.js",
+      "import": "./lib/cache/index.mjs"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "require": "./*.js",
+      "import": "./*.mjs"
     }
   },
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.esm.js",
-  "umd": "./dist/index.umd.js",
-  "types": "dist/index.d.ts",
+  "types": "./index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "files": [
     "dist/",
+    "lib/",
     "package.json",
-    "README.md"
+    "README.md",
+    "index.d.ts"
   ],
   "scripts": {
-    "build": " pnpm prettier && pnpm lint && rollup -c",
-    "dev": "npx --yes tsx --watch example/index.ts",
+    "build": "rollup -c",
     "test": "jest",
-    "lint": "eslint src/**/*.{js,jsx,ts,tsx,json}",
-    "prettier": "prettier --config .prettierrc.json --write src/**/*.{js,jsx,ts,tsx,json}",
-    "releases": "npx bump && tsx publish.ts",
+    "lint": "npx eslint src/**/*.ts && npx eslint test/**/*.ts && npx eslint types/**/*.ts",
+    "prettier": "npx prettier --config .prettierrc.json --write ./**/*.{ts,json}",
+    "releases": "pwsh publish.ps1",
     "versihint": "npx bump"
   },
   "devDependencies": {
-    "@babel/core": "^7.24.0",
-    "@babel/preset-env": "^7.24.0",
-    "@babel/preset-typescript": "^7.23.3",
+    "@babel/core": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
+    "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
     "@types/jest": "^29.5.12",
-    "@types/koa": "^2.15.0",
-    "@types/koa-bodyparser": "^4.3.12",
-    "@types/koa-json": "^2.0.23",
-    "@types/koa-router": "^7.4.8",
-    "@types/node": "^20.12.7",
-    "@typescript-eslint/eslint-plugin": "^7.3.1",
-    "@typescript-eslint/parser": "^7.3.1",
+    "@typescript-eslint/eslint-plugin": "^7.8.0",
+    "@typescript-eslint/parser": "^7.8.0",
+    "esbuild": "^0.21.0",
     "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^18.0.0",
     "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
-    "fsxx": "^0.1.0",
     "jest": "^29.7.0",
-    "koa": "^2.15.3",
-    "koa-bodyparser": "^4.4.1",
-    "koa-json": "^2.0.2",
-    "koa-router": "^12.0.1",
     "prettier": "^3.2.5",
-    "rollup": "^4.13.0",
+    "rollup": "^4.17.2",
     "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-esbuild": "^6.1.1",
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-jest": "^29.1.2",
     "tslib": "^2.6.2",
-    "typescript": "^5.4.2",
-    "version-bump-prompt": "^6.1.0",
-    "zx": "^7.2.3"
+    "typescript": "^5.4.5",
+    "version-bump-prompt": "^6.1.0"
+  },
+  "dependencies": {
+    "devix": "0.0.23-beta.9"
   }
 }