devix 0.0.1 → 0.0.12

package/.babelrc.json

@@ -0,0 +1,14 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "modules": false,
+        "targets": {
+          "node": "current"
+        }
+      }
+    ],
+    "@babel/preset-typescript"
+  ]
+}

package/.editorconfig

@@ -0,0 +1,14 @@
+# http://editorconfig.org
+root = true
+
+[*] # 表示所有文件适用
+charset = utf-8 # 设置文件字符集为 utf-8
+indent_style = space # 缩进风格（tab | space）
+indent_size = 2 # 缩进大小
+end_of_line = lf # 控制换行类型(lf | cr | crlf)
+trim_trailing_whitespace = true # 去除行首的任意空白字符
+insert_final_newline = true # 始终在文件末尾插入一个新行
+
+[*.md] # 表示仅 md 文件适用以下规则
+max_line_length = off
+trim_trailing_whitespace = false

package/.eslintignore

@@ -0,0 +1,2 @@
+/node_modules
+/dist

package/.eslintrc.json

@@ -0,0 +1,21 @@
+{
+  "env": {
+    "browser": true,
+    "es2021": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "rules": {
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/ban-types": "off"
+  }
+}

package/.prettierignore

@@ -0,0 +1,9 @@
+/dist/*
+.local
+.output.js
+/node_modules/**
+
+**/*.svg
+**/*.sh
+
+/public/*

package/.prettierrc.json

@@ -0,0 +1,8 @@
+{
+  "useTabs": false,
+  "tabWidth": 2,
+  "printWidth": 80,
+  "singleQuote": true,
+  "trailingComma": "none",
+  "semi": false
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OpenKnights
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# devix
+
+Devix is a comprehensive, powerful, and compact JavaScript utility library.
+
+## Install
+
+```shell
+npm install --save-dev devix
+```
+
+## Usage
+
+```javascript
+// Using ES Module
+import { [[ModuleName]] } from 'devix'
+
+// Using CommonJS
+var { [[ModuleName]]  } = require('devix')
+```

package/jest.config.ts

@@ -0,0 +1,25 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+import type { Config } from 'jest'
+
+const config: Config = {
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // Tool selection for test coverage.
+  coverageProvider: 'babel',
+
+  // Optimization for the extensionsToTreatAsEsm configuration.
+  extensionsToTreatAsEsm: ['.ts'],
+
+  // Regex matching to ignore collection paths.
+  coveragePathIgnorePatterns: ['/node_modules/']
+}
+
+export default config

package/package.json

@@ -1,19 +1,47 @@
 {
   "name": "devix",
-  "version": "0.0.1",
-  "description": "Devix is a comprehensive and powerful TypeScript utility library that is compact in size.",
+  "type": "module",
+  "version": "0.0.12",
+  "description": "Devix is a comprehensive, powerful, and compact JavaScript utility library.",
+  "author": "",
+  "license": "MIT",
+  "keywords": [],
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
     }
   },
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.esm.js",
+  "umd": "./dist/index.umd.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rollup -c",
+    "dev": "yarn build --watch",
+    "test": "jest",
+    "lint": "eslint src/**/*.{js,jsx,ts,tsx,json}",
+    "prettier": "prettier --config .prettierrc.json --write ./**/**/*.{js,jsx,ts,tsx,json}"
   },
-  "keywords": [],
-  "author": "",
-  "license": "MIT"
+  "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "@babel/preset-typescript": "^7.23.3",
+    "@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",
+    "@typescript-eslint/eslint-plugin": "^7.3.1",
+    "@typescript-eslint/parser": "^7.3.1",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "rollup": "^4.13.0",
+    "rollup-plugin-dts": "^6.1.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.2"
+  }
 }

package/rollup.config.js

@@ -0,0 +1,59 @@
+import dts from 'rollup-plugin-dts'
+import resolve from '@rollup/plugin-node-resolve'
+import commonjs from '@rollup/plugin-commonjs'
+import typescript from 'rollup-plugin-typescript2'
+import json from '@rollup/plugin-json'
+import terser from '@rollup/plugin-terser'
+import babel from '@rollup/plugin-babel'
+import { DEFAULT_EXTENSIONS } from '@babel/core'
+
+const packname = 'Evenex'
+const entries = ['src/index.ts']
+const plugins = [
+  resolve({
+    preferBuiltins: true
+  }),
+  json(),
+  commonjs(),
+  typescript(),
+  babel({
+    babelHelpers: 'bundled',
+    exclude: 'node_modules/**',
+    extensions: [...DEFAULT_EXTENSIONS, '.ts']
+  }),
+  terser()
+]
+
+const rollup_config = [
+  ...entries.map((input) => ({
+    input,
+    output: [
+      {
+        file: input.replace('src/', 'dist/').replace('.ts', '.esm.js'),
+        format: 'es'
+      },
+      {
+        file: input.replace('src/', 'dist/').replace('.ts', '.cjs.js'),
+        format: 'cjs'
+      },
+      {
+        name: packname,
+        file: input.replace('src/', 'dist/').replace('.ts', '.umd.js'),
+        format: 'umd'
+      }
+    ],
+    plugins
+  })),
+  ...entries.map((input) => ({
+    input,
+    output: [
+      {
+        file: input.replace('src/', 'dist/').replace('.ts', '.d.ts'),
+        format: 'esm'
+      }
+    ],
+    plugins: [dts({ respectExternal: true })]
+  }))
+]
+
+export default rollup_config

package/src/cache.ts

@@ -0,0 +1,48 @@
+import { isType } from './typeof'
+
+enum CacheType {
+  Local,
+  Session
+}
+
+/**
+ *  Encapsulate storage cache class
+ *
+ * @class StorageCache
+ * @template T
+ */
+class StorageCache<T = any> {
+  private storage: Storage
+
+  constructor(type: CacheType) {
+    this.storage = type === CacheType.Local ? localStorage : sessionStorage
+  }
+
+  getCache(key: string): T {
+    const value: any = this.storage.getItem(key)
+    return value ? JSON.parse(value) : null
+  }
+
+  setCache(key: string, value: T): void {
+    this.storage.setItem(key, JSON.stringify(value))
+  }
+
+  updateCache(key: string, property: string, value: T) {
+    const cache: any = this.getCache(key)
+    if (isType('object', cache)) {
+      cache[property] = value
+      this.setCache(key, cache)
+    }
+  }
+
+  deleteCache(key: string): void {
+    this.storage.removeItem(key)
+  }
+
+  clearCache(): void {
+    this.storage.clear()
+  }
+}
+
+export const localCache = new StorageCache(CacheType.Local)
+export const sessionCache = new StorageCache(CacheType.Session)

package/src/clone.ts

@@ -0,0 +1,64 @@
+import { isType } from './typeof'
+
+//! Function Shallow Copy
+export function shallowClone<T = any>(source: T): T {
+  if (isType('array', source)) return (source as any[]).slice() as T
+  if (isType('object', source)) return { ...source } as T
+
+  return source
+}
+
+//! Function Deep Copy
+const isFormat = (target: any) =>
+  isType('object', target) || isType('function', target)
+
+function handleSpeciBoundar<T = any>(
+  source: any,
+  deepClone: Function,
+  hash: WeakMap<object, T>
+) {
+  if (isType('symbol', source)) return Symbol(source.description)
+
+  if (!isFormat(source)) return source
+
+  if (isType('set', source)) {
+    const newSet = new Set()
+    source.forEach((value: T) => newSet.add(deepClone(value, hash)))
+
+    return newSet
+  }
+  if (isType('map', source)) {
+    const newMap = new Map()
+    source.forEach((value: T, key: T) =>
+      newMap.set(key, deepClone(value, hash))
+    )
+    return newMap
+  }
+}
+
+export function deepClone(source: any, hash = new WeakMap<object, any>()) {
+  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: any = isArray ? [] : {}
+
+  hash.set(source, cloneObject)
+
+  if (isArray) {
+    ;(source as Array<any>).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
+}

package/src/format.ts

@@ -0,0 +1,65 @@
+import { isType } from './typeof'
+import { TFormatTimer, ITimerObj } from './types'
+
+const formatRules = new Map<string, keyof ITimerObj>([
+  ['yyyy', 'year'],
+  ['MM', 'month'],
+  ['dd', 'day'],
+  ['HH', 'hours'],
+  ['mm', 'minutes'],
+  ['ss', 'seconds'],
+  ['W', 'week']
+])
+
+const WeekList = new Map<number, string>([
+  [1, '一'],
+  [2, '二'],
+  [3, '三'],
+  [4, '四'],
+  [5, '五'],
+  [6, '六'],
+  [0, '日']
+])
+
+function processWeek(weekNum: number): string {
+  return WeekList.get(weekNum) || ''
+}
+
+function formatNumber(value: number): string {
+  return value.toString().padStart(2, '0')
+}
+
+function createTimerObj(date: Date): ITimerObj {
+  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()
+  }
+}
+
+export const formatTimer: TFormatTimer = (
+  cellValue,
+  formatType = 'yyyy-MM-dd HH:mm:ss'
+) => {
+  if (!cellValue) return 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
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './others'
+export * from './typeof'
+export * from './cache'
+export * from './retalimit'
+export * from './clone'
+export * from './sort'
+export * from './format'

package/src/others.ts

@@ -0,0 +1,68 @@
+export function currying(fn: Function) {
+  function curried(this: any, ...args: any[]) {
+    if (args.length >= fn.length) {
+      return fn.apply(this, args)
+    } else {
+      return function (this: any, ...args2: any[]) {
+        return curried.apply(this, args.concat(args2))
+      }
+    }
+  }
+  return curried
+}
+
+export function compose(...fns: Function[]) {
+  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 (this: any, ...args: any[]) {
+    let index = 0
+    let result = fns[index].apply(this, args)
+    while (++index < length) {
+      result = fns[index].call(this, result)
+    }
+    return result
+  }
+}
+
+export function insertStr(soure: string, start: number, newStr: string) {
+  return soure.slice(0, start) + newStr + soure.slice(start)
+}
+
+export function stringCase(soure: string, separator = '', separate = '') {
+  const newStr = soure.split(separator)
+  for (let i = 0; i < newStr.length; i++) {
+    newStr[i] =
+      newStr[i].slice(0, 1).toUpperCase() + newStr[i].slice(1).toLowerCase()
+  }
+  return newStr.join(separate)
+}
+
+export function setTimer(
+  execute: (...args: any[]) => any,
+  delay: number,
+  immediate: boolean
+) {
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  const interval = () => {
+    execute()
+    timer = setTimeout(interval, delay)
+  }
+
+  if (immediate) execute()
+
+  setTimeout(interval, delay)
+
+  return {
+    cancel: () => {
+      if (timer !== null) clearTimeout(timer)
+    }
+  }
+}

package/src/retalimit.ts

@@ -0,0 +1,100 @@
+import { ThrottleOptions } from './types'
+
+export function debounce<T extends (...args: any[]) => any>(
+  callback: T,
+  delay: number = 0,
+  immediate: boolean = false
+): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void
+} {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let isInvoke: boolean = false
+
+  function _debounce(this: any, ...args: Parameters<T>) {
+    return new Promise<ReturnType<T>>((resolve, reject) => {
+      if (timer !== null) clearTimeout(timer)
+
+      if (immediate && !isInvoke) {
+        try {
+          const result: ReturnType<T> = callback.apply(this, args)
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        }
+        isInvoke = true
+        return
+      }
+
+      timer = setTimeout(() => {
+        try {
+          const result: ReturnType<T> = callback.apply(this, args)
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        } finally {
+          timer = null
+          isInvoke = false
+        }
+      }, delay)
+    })
+  }
+
+  _debounce.cancel = function (): void {
+    if (timer !== null) clearTimeout(timer)
+    timer = null
+    isInvoke = false
+  }
+
+  return _debounce
+}
+
+export function throttle<T extends (...args: any[]) => any>(
+  callback: T,
+  interval: number,
+  options: ThrottleOptions = {}
+): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void
+} {
+  const { leading = true, trailing = false } = options
+  let startTime: number = 0
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  function _throttle(this: any, ...args: Parameters<T>) {
+    return new Promise<ReturnType<T>>((resolve, reject) => {
+      try {
+        const nowTime = Date.now()
+        let result: ReturnType<T>
+        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
+}

package/src/sort.ts

@@ -0,0 +1,32 @@
+enum SortType {
+  ASC = 'ASC',
+  DESC = 'DESC'
+}
+
+function swap<T>(array: T[], index1: number, index2: number): void {
+  ;[array[index1], array[index2]] = [array[index2], array[index1]]
+}
+
+function compare<T>(value1: T, value2: T, type: SortType): boolean {
+  return type === SortType.ASC ? value1 > value2 : value1 < value2
+}
+
+export function bubblingSort<T>(
+  array: T[],
+  type: SortType = SortType.ASC,
+  key?: keyof T
+): T[] {
+  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
+}

package/src/typeof.ts

@@ -0,0 +1,26 @@
+export default function getDataType(target: any) {
+  const type = typeof target
+  return type === 'object'
+    ? type
+    : Object.prototype.toString.call(target).slice(8, -1).toLowerCase()
+}
+
+const typeCheckers: { [key: string]: (target: any) => boolean } = {
+  string: (target) => typeof target === 'string',
+  number: (target) => typeof target === 'number',
+  boolean: (target) => typeof target === 'boolean',
+  null: (target) => target === null,
+  undefined: (target) => typeof target === 'undefined',
+  symbol: (target) => typeof target === 'symbol',
+  bigint: (target) => typeof target === 'bigint',
+  object: (target) => target !== null && typeof target === 'object',
+  array: (target) => Array.isArray(target),
+  function: (target) => typeof target === 'function',
+  set: (target) => target instanceof Set,
+  map: (target) => target instanceof Map,
+  date: (target) => target instanceof Date,
+  regexp: (target) => target instanceof RegExp
+}
+
+export const isType = (type: string, target: any) =>
+  typeCheckers[type]?.(target) || false

package/src/types.ts

@@ -0,0 +1,22 @@
+//! format types
+export interface ITimerObj {
+  year: string
+  month: string
+  day: string
+  hours: string
+  minutes: string
+  seconds: string
+  week: string
+  weekNum: string
+}
+
+export type TFormatTimer = (
+  cellValue: string | number | Date,
+  formatType?: string
+) => string | ITimerObj
+
+//! retalimit types
+export type ThrottleOptions = {
+  leading?: boolean
+  trailing?: boolean
+}

package/test/test.js

@@ -0,0 +1,117 @@
+import { debounce } from '../dist/index.esm.js'
+
+// function debounce(callback, delay = 0, immediate = false) {
+//   let timer = null
+//   let isInvoke = false
+//   function _debounce(...args) {
+//     return new Promise((resolve, reject) => {
+//       try {
+//         if (timer) clearTimeout(timer)
+
+//         let result = undefined
+//         if (immediate && !isInvoke) {
+//           result = callback.apply(this, args)
+//           resolve(result)
+//           isInvoke = true
+//           return
+//         }
+
+//         timer = setTimeout(() => {
+//           result = callback.apply(this, args)
+//           resolve(result)
+//           timer = null
+//           isInvoke = false
+//         }, delay)
+//       } catch (error) {
+//         reject(error)
+//       }
+//     })
+//   }
+
+//   _debounce.cancel = function () {
+//     if (timer) clearTimeout(timer)
+//     timer = null
+//     isInvoke = false
+//   }
+
+//   return _debounce
+// }
+
+// function throttle(
+//   callback,
+//   interval,
+//   { leading = true, trailing = false } = {}
+// ) {
+//   let startTime = 0
+//   let timer = null
+//   function _throttle(...args) {
+//     return new Promise((resolve, reject) => {
+//       try {
+//         const nowTime = Date.now()
+//         let result = undefined
+//         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
+// }
+
+// const foo1 = debounce(
+//   (message) => {
+//     console.log('message', message)
+//     return message
+//   },
+//   3000,
+//   true
+// )
+
+// const foop1 = foo1('111')
+// foop1.then((res) => {
+//   console.log(`res:`, res)
+// })
+// // foo1('222')
+// foo1('333')
+
+// setTimeout(() => {
+//   foo1.cancel()
+// }, 1000)
+
+const foo3 = debounce(function (...args) {
+  console.log('this', this)
+  console.log('args', args)
+})
+
+const obj1 = {
+  name: 'obj',
+  foo3
+}
+
+obj1.foo3('333')

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "lib": ["esnext", "DOM", "DOM.Iterable"],
+    "useDefineForClassFields": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "esModuleInterop": false,
+    "strict": true,
+    "strictNullChecks": true,
+    "typeRoots": ["node_modules/@types", "src/types.ts"]
+  },
+  "include": ["src/*.ts"]
+}