@allkit/shared 0.0.1

package/src/lodash/index.ts

@@ -0,0 +1,396 @@
+import { isDef, isNullOrUnDef, isObject } from '../is'
+
+type OmitUndefined<T> = {
+  [K in keyof T]: undefined extends T[K] ? never : T[K]
+}
+
+/**
+ * 删除对象中的某些键值对
+ * @param obj - 源对象
+ * @param fields - 需要删除的字段数组
+ * @param ignoreEmpty - 是否忽略 undefined | null
+ * @returns 返回新的对象
+ * @example
+ * ```ts
+ * const obj = {
+      a: 1,
+      b: {
+        c: 2,
+        d: {
+          e: 3,
+        },
+      },
+      c: '',
+      d: undefined,
+    }
+    const cloneObj = omit(obj, ['a'])
+ * ```
+ */
+export function omit<T extends Record<string, any>, K extends keyof T>(
+  obj: T,
+  fields: K[] | string[],
+  ignoreEmpty = true,
+): Omit<T, K> {
+  if (!obj) return {} as Omit<T, K>
+  if (!ignoreEmpty) {
+    return fields.reduce((result, key) => {
+      const { [key]: _, ...rest } = result
+      return rest as T
+    }, obj)
+  }
+
+  const result = {} as OmitUndefined<T>
+  for (const key in obj) {
+    // @ts-ignore
+    if (!fields.includes(key) && !isNullOrUnDef(obj[key])) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}
+
+export type Writeable<T> = { -readonly [P in keyof T]: T[P] }
+
+/**
+ * 从对象中取出指定的键值对
+ * @param obj - 源对象
+ * @param keys - 需要取出的键值对
+ * @param ignoreEmpty - 是否忽略 undefined 
+ * @returns 返回新的对象
+ * @example
+ * ```ts
+ *    const obj = {
+      a: 1,
+      b: {
+        c: 2,
+        d: {
+          e: 3,
+        },
+      },
+    }
+    const cloneObj = pick(obj, ['b'])
+ * ``` 
+ */
+export function pick<T, U extends keyof T>(
+  obj: T,
+  keys: ReadonlyArray<U> | string[],
+  ignoreUndefined = true,
+) {
+  if (!obj) return {} as Writeable<Pick<T, U>>
+  return keys.reduce(
+    (ret, key) => {
+      const value = obj[key as U]
+      if (!ignoreUndefined || isDef(value)) {
+        ret[key as U] = value
+      }
+      return ret
+    },
+    {} as Writeable<Pick<T, U>>,
+  )
+}
+
+/**
+ * 从对象中取出指定的键值对,第二个参数predicate（断言函数)
+ * @param obj - 源对象
+ * @param predicate - 断言函数,判断为真值的属性会被返回
+ * @returns 返回新的对象
+ * @example
+ * ```ts
+ *    const obj = {
+      a: 1,
+      b: {
+        c: 2,
+        d: {
+          e: 3,
+        },
+      },
+      c: '',
+      d: undefined,
+    }
+    const cloneObj = pickBy(obj, (value) => !!value)
+ * ``` 
+ */
+export function pickBy<T>(
+  obj: T,
+  predicate: (val: NonNullable<T>[keyof T], key: keyof T) => boolean,
+) {
+  if (!obj) return {} as Partial<T>
+  const ret: Partial<T> = {}
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const typedKey = key as keyof T
+      const value = obj[typedKey]
+      if (predicate(value, typedKey)) {
+        ret[typedKey] = value
+      }
+    }
+  }
+  return ret
+}
+
+type OmitBy<T, F> = { [K in keyof T as F extends T[K] ? never : K]: T[K] }
+
+/**
+ * 从对象中去除属性,通过第二个参数predicate（断言函数)
+ * 与 {@link pickBy} 反向版
+ * @param obj - 源对象
+ * @param predicate - 断言函数,判断为真值的属性会被**去除**
+ * @returns 返回新的对象
+ * @example
+ * ```ts
+ * const obj = {
+      a: 1,
+      b: {
+        c: 2,
+        d: {
+          e: 3,
+        },
+      },
+      c: '',
+      d: undefined,
+    }
+    const cloneObj = omitBy(obj, (value) => !value)
+ * ```
+ */
+export function omitBy<T>(
+  object: T,
+  predicate: (value: T[keyof T], key: keyof T) => boolean,
+): OmitBy<T, T[keyof T]> {
+  const result = { ...object }
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      const typedKey = key as keyof T
+      const value = object[typedKey]
+      if (predicate(value, typedKey)) {
+        delete result[key]
+      }
+    }
+  }
+  return result
+}
+
+/**
+ * 防抖函数
+ * @param fn - 需要防抖的函数
+ * @param delay - 防抖的时间
+ * @example
+ * ```ts
+ * let handleSearch =()=>{}
+ * const debounceSearch = debounce(handleSearch)
+ * ```
+ */
+export const debounce = (fn: Function, delay = 0) => {
+  let timer: number
+
+  return function (this: unknown, ...args: any[]) {
+    if (timer) {
+      window.clearTimeout(timer)
+    }
+
+    timer = window.setTimeout(() => {
+      fn.apply(this, args)
+    }, delay)
+  }
+}
+
+/**
+ * 节流函数
+ * @param fn  - 需要节流的函数
+ * @param limit - 节流的时间
+ * @param exeLastFunc - 是否执行最后一次函数
+ * @example
+ * ```ts
+ * let handleSearch =()=>{}
+ * const throttleSearch = throttle(handleSearch)
+ * ```
+ */
+export const throttle = <T extends (...args: any) => any>(
+  fn: T,
+  limit = 200,
+  exeLastFunc = true,
+) => {
+  let timer: number
+  let start = 0
+
+  return function loop(this: unknown, ...args: Parameters<T>) {
+    const now = Date.now()
+    const duration = now - start
+    if (duration >= limit) {
+      fn.apply(this, args)
+      // 更新最后执行时间
+      start = now
+    } else if (exeLastFunc) {
+      window.clearTimeout(timer)
+      timer = window.setTimeout(() => {
+        fn.apply(this, args)
+        start = Date.now()
+      }, limit - duration)
+    }
+  }
+}
+
+let counter = 0
+/**
+ * 生成当前浏览器唯一id
+ * (自增+页面渲染时间+ random随机数)
+ * 对于一般的唯一ID 生成来说是足够的
+ * @param length -随机数长度 默认16
+ * @example
+ * ```ts
+ * let uid11 = uniqueId(11) //11位
+ * let uid16 = uniqueId() //16位
+ * let uid19 = uniqueId(19) //19 位
+ * let uid32 = uniqueId(32)
+ * ```
+ * @returns 唯一id
+ */
+export function uniqueId(length: number = 16): string {
+  const pNow = new Date().getTime().toString()
+  const random = Math.random().toString().replace('.', '').slice(1, 10)
+  const padLength = length - pNow.length - counter.toString().length - random.length
+  const padding = '0'.repeat(padLength > 0 ? padLength : 0)
+  const uniqueId = '' + `${counter}${pNow}${padding}${random}`.slice(0, length)
+  counter++
+  return uniqueId
+}
+
+/**
+ * 将 Blob 对象转换为 base64 字符串
+ * @param blob - Blob 对象
+ * @param ignorePrefix - 是否忽略 dateUrl 前缀
+ * @example
+ * ```ts
+ * let base64 = blobToBase64(blob)
+ * let base64 = blobToBase64(blob,false)
+ * ```
+ */
+export function blobToBase64(blob: Blob, ignorePrefix = true): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onloadend = () => {
+      if (typeof reader.result === 'string') {
+        if (ignorePrefix) {
+          return resolve(reader.result && reader.result.split(',')[1])
+        }
+        resolve(reader.result)
+      } else {
+        reject(new Error('Failed to convert Blob to base64'))
+      }
+    }
+    reader.onerror = reject
+    reader.readAsDataURL(blob)
+  })
+}
+
+type DeepKeyOf<T> = T extends object
+  ? {
+      [K in keyof T]-?: K extends string ? K | `${K}.${DeepKeyOf<T[K]>}` : never
+    }[keyof T]
+  : never
+
+type DeepValueOf<T, K extends string> = K extends `${infer P}.${infer Rest}`
+  ? P extends keyof T
+    ? DeepValueOf<T[P], Rest>
+    : ''
+  : K extends keyof T
+    ? T[K]
+    : ''
+
+/**
+ * 从对象中获取指定路径的值
+ * @param object -对象
+ * @param path  - 指定路径
+ * @example
+ * ```ts
+ * const obj = {
+ *   a: { b: { c: 3 } }
+ * }
+ * const value = get(obj, 'a.b.c')
+ * ```
+ */
+export function get<T, K extends DeepKeyOf<T>>(obj: T, path: K) {
+  const keys = (path as string).split('.')
+  let result = obj
+
+  keys.forEach((key) => {
+    result = isObject(result) ? (result[key] ?? '') : ''
+  })
+  return result as DeepValueOf<T, K>
+}
+
+/**
+ * 对象转查询字符串
+ * @param obj - 对象
+ * @returns 查询字符串
+ * @example
+ * ```ts
+ * const str = objToQString({ a: 1, b: 2 })
+ * // 输出: 'a=1&b=2'
+ * ```
+ */
+export function objToQString(obj: Record<string, any>): string {
+  if (!obj || typeof obj !== 'object') return ''
+  return Object.entries(obj)
+    .map(([key, value]) => {
+      if (value === undefined || value === null) return ''
+      const strValue = typeof value === 'object' ? JSON.stringify(value) : String(value)
+      return `${key}=${encodeURIComponent(strValue)}`
+    })
+    .filter(Boolean)
+    .join('&')
+}
+
+/**
+ * 查询字符串转对象
+ * @param qString - 查询字符串
+ * @returns 对象
+ * @example
+ * ```ts
+ * const obj = qStringToObj('a=1&b=2')
+ * // 输出: { a: 1, b: 2 }
+ * ```
+ */
+export function qStringToObj(qString: string | null): Record<string, any> {
+  if (!qString || typeof qString !== 'string') return {}
+
+  // 快速检测空字符串
+  if (!qString.trim()) return {}
+
+  // 快速检测完整 URL 且无查询参数
+  if (/^https?:\/\/[^?]+$/.test(qString)) return {}
+
+  // 提取查询参数部分，支持完整 URL 格式
+  const queryPart = qString.includes('?') ? qString.split('?')[1] : qString
+  if (!queryPart) return {}
+
+  const result: Record<string, any> = {}
+  const pairs = queryPart.split('&')
+
+  for (const pair of pairs) {
+    const [key, value] = pair.split('=')
+    if (!key) continue
+
+    const decodedKey = decodeURIComponent(key)
+    const decodedValue = value ? decodeURIComponent(value) : ''
+
+    // 尝试解析 JSON 值（数组和对象）
+    let parsedValue: any = decodedValue
+    try {
+      parsedValue = JSON.parse(decodedValue)
+    } catch {
+      // JSON 解析失败，继续处理
+    }
+
+    // 尝试转换为数字（如果不是对象或数组）
+    if (typeof parsedValue !== 'object' || parsedValue === null) {
+      const num = Number(parsedValue)
+      if (!isNaN(num)) {
+        parsedValue = num
+      }
+    }
+
+    result[decodedKey] = parsedValue
+  }
+
+  return result
+}

package/src/number/__test__/number.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from 'vitest'
+import { formatNumber, formatMoney } from '../'
+
+describe('number.ts - formatNumber', () => {
+  test('formatNumber - param is null', () => {
+    const num = null
+    const expected = ''
+    //@ts-ignore
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is NaN', () => {
+    const num = '***'
+    const expected = '***'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is number', () => {
+    const num = 1000
+    const expected = '1,000'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is number', () => {
+    const num = 1234567
+    const expected = '1,234,567'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is string', () => {
+    const num = '1000'
+    const expected = '1,000'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is string', () => {
+    const num = 1234567
+    const expected = '1,234,567'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is 0', () => {
+    const num = 0
+    const expected = '0'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is decimal', () => {
+    const num = 1234.5678
+    const expected = '1,235'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+  test('formatNumber - param is negative', () => {
+    const num = -1234.5678
+    const expected = '-1,235'
+    const formatNum = formatNumber(num)
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is precision eq 2', () => {
+    const num = 1234.5678
+    const expected = '1,234.57'
+    const formatNum = formatNumber(num, { precision: 2 })
+    expect(expected).toEqual(formatNum)
+  })
+
+  test('formatNumber - param is precision eq 2', () => {
+    const num = 1234
+    const expected = '1,234.00'
+    const formatNum = formatNumber(num, { precision: 2 })
+    expect(expected).toEqual(formatNum)
+  })
+})
+
+describe('number.ts - formatMoney', () => {
+  test('formatMoney - 小于等于4位', () => {
+    expect(formatMoney(0)).toBe('0')
+    expect(formatMoney(1)).toBe('1')
+    expect(formatMoney(999)).toBe('999')
+    expect(formatMoney(9999)).toBe('9,999')
+  })
+
+  test('formatMoney - 5-8位 (万)', () => {
+    expect(formatMoney(10000)).toBe('1万')
+    expect(formatMoney(100000)).toBe('10万')
+    expect(formatMoney(1000000)).toBe('100万')
+    expect(formatMoney(10000000)).toBe('1,000万')
+    expect(formatMoney(12345678)).toBe('1,234万5,678')
+  })
+
+  test('formatMoney - 9-12位 (亿)', () => {
+    expect(formatMoney(100000000)).toBe('1亿')
+    expect(formatMoney(1000000000)).toBe('10亿')
+    expect(formatMoney(1234567890)).toBe('12亿3,456万7,890')
+  })
+
+  test('formatMoney - 大于12位', () => {
+    expect(formatMoney(100000000000)).toBe('1,000亿')
+    expect(formatMoney(12345678901234)).toBe('123,456亿7890万1234')
+  })
+
+  test('formatMoney - 负数', () => {
+    expect(formatMoney(-1234)).toBe('-1,234')
+    expect(formatMoney(-10000000)).toBe('-1,000万')
+    expect(formatMoney(-100000000)).toBe('-1亿')
+  })
+
+  test('formatMoney - 自定义单位', () => {
+    expect(formatMoney(123456789, { yi: 'y', wan: 'w' })).toBe('1y2,345w6,789')
+    expect(formatMoney(10000000, { yi: 'Y', wan: 'W' })).toBe('1,000W')
+  })
+
+  test('formatMoney - 禁用千位分隔符', () => {
+    expect(formatMoney(123456789, { thousandSeparator: '' })).toBe('1亿2345万6789')
+    expect(formatMoney(10000000, { thousandSeparator: '' })).toBe('1000万')
+  })
+
+  test('formatMoney - null/undefined/NaN', () => {
+    expect(formatMoney(null as any)).toBe('')
+    expect(formatMoney(undefined as any)).toBe('')
+    expect(formatMoney(NaN)).toBe('')
+  })
+
+  test('formatMoney - 边界值', () => {
+    expect(formatMoney(1000)).toBe('1,000')
+    expect(formatMoney(9999)).toBe('9,999')
+    expect(formatMoney(10000)).toBe('1万')
+  })
+})

package/src/number/index.ts

@@ -0,0 +1,161 @@
+import Big from 'big.js'
+import { isNullOrUnDef } from '../is'
+import type { RoundingMode } from 'big.js'
+
+type BigSource = number | string | Big
+
+/**
+ * 返回一个实例化的Big对象
+ * @param n - 待处理的数字/字符串数字
+ * @example
+ * ```ts
+ * const value = useNumber('1')
+ * ```
+ */
+export function useNumber(n: BigSource): Big {
+  return new Big(n)
+}
+
+/**
+ * 4舍5入(精度兼容)
+ * @param m - 数字
+ * @param dp - 保留位数
+ * @param rm - 0: 向下取整 1: 四舍五入 2: 向上取整
+ * @example
+ * ```ts
+ * const value = round(5.23, 1, 1)
+ * ```
+ */
+export function round(m: BigSource, dp: number, rm: RoundingMode = 1) {
+  return new Big(m).round(dp, rm).toNumber()
+}
+
+export interface FormatOptions {
+  /**
+   * 保留小数位数
+   */
+  precision?: number
+  /**
+   * 千位分隔符
+   */
+  thousandSeparator?: string
+  /**
+   * 分割的位数(3位代表千分位分割)
+   */
+  bit?: number
+  /**
+   * 0: 向下取整 1: 四舍五入, 2: roundHalfEven, 3: 向上取整
+   */
+  roundMode?: RoundingMode
+}
+
+/**
+ * 格式化数字, 默认千位分隔符为","
+ * @param val - 要格式化的数字
+ * @param options - 配置项
+ * @returns 格式化后的数字字符串
+ * @example
+ * ```ts
+ * formatNumber(1000)  //输出 "1,000"
+ * formatNumber(1234567)  //输出 "1,234,567"
+ * formatNumber(1234.5678, { precision: 2, thousandSeparator: "-" }) // 输出: "1-234.5678"
+ * ```
+ */
+export function formatNumber(val: number | string, options: FormatOptions = {}): string {
+  const { bit = 3, precision = 0, thousandSeparator = ',', roundMode = 1 } = options
+  if (isNullOrUnDef(val)) return ''
+  if (isNaN(+val)) return val + ''
+  let value = useNumber(val).toFixed(precision, roundMode)
+  const arr = value.split('.')
+  value = arr[0]
+  const reg = new RegExp(`(\\d)(?=(\\d{${bit}})+$)`, 'g')
+  value = value.replace(reg, `$1${thousandSeparator}`)
+  const decimal = arr.length > 1 ? `.${arr?.[1]}` : ''
+  return value + decimal
+}
+
+export interface MoneyFormatOptions {
+  /**
+   * 亿的单位字符串，默认 '亿'
+   */
+  yi?: string
+  /**
+   * 万的单位字符串，默认 '万'
+   */
+  wan?: string
+  /**
+   * 千位分隔符，默认 ','，传空字符串或不传则不启用千位分隔
+   */
+  thousandSeparator?: string
+}
+
+const DEFAULT_MONEY_OPTIONS: Required<MoneyFormatOptions> = {
+  yi: '亿',
+  wan: '万',
+  thousandSeparator: ',',
+}
+
+/**
+ * 格式化金钱（支持万、亿）
+ * @param num - 数字
+ * @param options - 配置项
+ * @returns 格式化后的金钱字符串
+ * @example
+ * ```ts
+ * formatMoney(1234567)  // '1,234,567'
+ * formatMoney(10000000)  // '1,000万'
+ * formatMoney(100000000)  // '1亿'
+ * formatMoney(123456789)  // '1亿2,345万6,789'
+ * formatMoney(123456789, { yi: 'y', wan: 'w' })  // '1y2,345w6,789'
+ * formatMoney(123456789, { thousandSeparator: '' })  // '1亿2345万6789'
+ * ```
+ */
+export function formatMoney(num: number, options: MoneyFormatOptions = {}): string {
+  if (isNullOrUnDef(num) || isNaN(num)) return ''
+  if (num < 0) return '-' + formatMoney(-num, options)
+
+  const { yi, wan, thousandSeparator } = {
+    ...DEFAULT_MONEY_OPTIONS,
+    ...options,
+  }
+  const len = String(num).length
+  const enableSeparator = !!thousandSeparator
+
+  const addSeparator = (str: string) => {
+    if (!enableSeparator) return str
+    return str.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator!)
+  }
+
+  if (len <= 4) return addSeparator(String(num))
+
+  if (len <= 8) {
+    const wanNum = Math.floor(num / 10000)
+    const remainder = num % 10000
+    return remainder === 0
+      ? addSeparator(String(wanNum)) + wan
+      : addSeparator(String(wanNum)) + wan + addSeparator(remainder.toString().padStart(4, '0'))
+  }
+
+  if (len <= 12) {
+    const yiNum = Math.floor(num / 100000000)
+    const wanNum = Math.floor((num % 100000000) / 10000)
+    const remainder = num % 10000
+
+    if (yiNum === 0) return formatMoney(num % 100000000, options)
+
+    const yiPart = addSeparator(String(yiNum)) + yi
+    if (wanNum === 0 && remainder === 0) return yiPart
+    if (wanNum === 0) return yiPart + addSeparator(remainder.toString())
+    if (remainder === 0) return yiPart + addSeparator(String(wanNum)) + wan
+
+    return yiPart + addSeparator(String(wanNum)) + wan + addSeparator(remainder.toString())
+  }
+
+  const yiNum = Math.floor(num / 100000000)
+  const remainderFromYi = num % 100000000
+  return (
+    addSeparator(String(yiNum)) +
+    yi +
+    formatMoney(remainderFromYi, { ...options, thousandSeparator: '' })
+  )
+}