@allkit/shared 0.0.3 → 0.0.5

package/src/lodash/index.ts

@@ -1,396 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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: '' })
-  )
-}