@allkit/shared 0.0.3 → 0.0.5

package/src/is/index.ts

@@ -1,293 +0,0 @@
-const toString = Object.prototype.toString
-
-export function is(val: unknown, type: string) {
-  return toString.call(val) === `[object ${type}]`
-}
-/**
- * 判断不是undefined
- * @param val  -内容
- * @example
- * ```ts
- * let result= isDef('test')
- * ```
- */
-export function isDef<T = unknown>(val?: T): val is T {
-  return typeof val !== 'undefined'
-}
-/**
- * 判断是undefined
- * @param val  -内容
- * @example
- * ```ts
- * let result= isUnDef('test')
- * ```
- */
-export function isUnDef<T = unknown>(val?: T): val is T {
-  return !isDef(val)
-}
-
-/**
- * 判断是Object,包含数组
- * @param val  -内容
- * @example
- * ```ts
- * let result= isObject({name:1})
- * ```
- */
-export function isObject(val: any): val is Record<any, any> {
-  return val !== null && typeof val === 'object'
-}
-
-/**
- * 判断是原始Object,不包含数组
- * @param val  -内容
- * @example
- * ```ts
- * let result= isPlainObject({name:1})
- * ```
- */
-export function isPlainObject(val: unknown): val is Record<string, unknown> {
-  return is(val, 'Object')
-}
-
-/**
- * 检测当前类型是否是空对象
- * @param obj - 检测当前类型
- * @returns 如果为空的对象则返回true、否则返回false
- */
-export const isEmptyObject = (obj: any): boolean => {
-  return isPlainObject(obj) && Object.keys(obj).length === 0
-}
-
-/**
- * 检测当前类型是否空(空string|undefined|null)
- * @param val - 检测当前类型
- * @returns 如果为空的对象则返回true、否则返回false
- */
-export const isEmptyValue = (val: string | number | null | undefined): boolean => {
-  if (isNullOrUnDef(val)) return true
-  if (val === '') return true
-  return false
-}
-
-/**
- * 判断是空,包括空数组,空对象,空Map
- * @param val  -内容
- * @example
- * ```ts
- * let result= isEmpty({name:1})
- * ```
- */
-export function isEmpty<T = unknown>(val: T): val is T {
-  if (isArray(val) || isString(val)) {
-    return val.length === 0
-  }
-
-  if (val instanceof Map || val instanceof Set) {
-    return val.size === 0
-  }
-
-  if (isObject(val)) {
-    return Object.keys(val).length === 0
-  }
-
-  return false
-}
-
-/**
- * 判断是日期对象
- * @param val  -内容
- * @example
- * ```ts
- * let result= isDate(new Date())
- * ```
- */
-export function isDate(val: unknown): val is Date {
-  return is(val, 'Date')
-}
-
-/**
- * 判断是否为null
- * @param val - 任意值
- * @returns  boolean
- */
-export function isNull(val: unknown): val is null {
-  return val === null
-}
-
-/**
- * 判断是null和undefined
- * @param val  -内容
- * @example
- * ```ts
- * let result= isNullAndUnDef('')
- * ```
- */
-export function isNullAndUnDef(val: unknown): val is null | undefined {
-  return isUnDef(val) && isNull(val)
-}
-
-/**
- * 判断是null或undefined
- * @param val  -内容
- * @example
- * ```ts
- * let result= isNullOrUnDef('')
- * ```
- */
-export function isNullOrUnDef(val: unknown): val is null | undefined {
-  return isUnDef(val) || isNull(val)
-}
-
-/**
- * 是否是number
- * @param val  -内容
- * @example
- * ```ts
- * let result= isNumber('test')
- * ```
- */
-export function isNumber(val: unknown): val is number {
-  return is(val, 'Number')
-}
-
-/**
- * 是否是Promise
- * @param val  -内容
- * @example
- * ```ts
- * let result= isPromise('test')
- * ```
- */
-export function isPromise<T = any>(val: any): val is Promise<T> {
-  return is(val, 'Promise') && isFunction(val.then) && isFunction(val.catch)
-}
-
-export function isString(val: unknown): val is string {
-  return is(val, 'String')
-}
-
-/**
- * 是否是函数
- * @param val  -内容
- * @example
- * ```ts
- * let result= isFunction('test')
- * ```
- */
-
-export function isFunction(val: unknown): val is Function {
-  return typeof val === 'function'
-}
-
-export function isBoolean(val: unknown): val is boolean {
-  return is(val, 'Boolean')
-}
-
-/**
- * 是否是正则
- * @param val  -内容
- * @example
- * ```ts
- * let result= isRegExp(window)
- * ```
- */
-export function isRegExp(val: unknown): val is RegExp {
-  return is(val, 'RegExp')
-}
-/**
- * 是否是数组
- * @param val  -内容
- * @example
- * ```ts
- * let result= isArray(window)
- * ```
- */
-export function isArray(val: any): val is Array<any> {
-  return val && Array.isArray(val)
-}
-
-/**
- * 是否是Window
- * @param val  -内容
- * @example
- * ```ts
- * let result= isWindow(window)
- * ```
- */
-export function isWindow(val: any): val is Window {
-  return typeof window !== 'undefined' && is(val, 'Window')
-}
-
-export function isElement(val: unknown): val is Element {
-  return isObject(val) && !!val.tagName
-}
-
-/**
- * 是否是Map
- * @param val  -内容
- * @example
- * ```ts
- * let result= isMap(window)
- * ```
- */
-export function isMap(val: unknown): val is Map<any, any> {
-  return is(val, 'Map')
-}
-
-export function isSet(val: unknown): val is Set<any> {
-  return is(val, 'Set')
-}
-
-export const isServer = typeof window === 'undefined'
-
-export const isClient = !isServer
-
-/**
- * 是否是isUrl
- * @param val  -内容
- * @example
- * ```ts
- * let result= isUrl('http://www.baidu.com')
- * ```
- */
-export function isUrl(path: string): boolean {
-  const reg =
-    // eslint-disable-next-line no-useless-escape
-    /(((^https?:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)$/
-  return reg.test(path)
-}
-
-/**
- * 判断是否为整数
- * @param val - 任意值
- * @returns 如果是整数则返回true，否则返回false
- */
-export function isInteger(val: unknown): boolean {
-  if (typeof val === 'number') {
-    return Number.isInteger(val) && !Number.isNaN(val) && Number.isFinite(val)
-  }
-  if (typeof val === 'string') {
-    // 不使用 trim()，直接判断字符串是否为有效的整数格式
-    const integerRegex = /^-?[1-9]\d*$|^0$/
-    return integerRegex.test(val)
-  }
-  return false
-}
-
-/**
- * 判断是否为数字（整数或浮点数）
- * @param val - 任意值
- * @returns 如果是数字则返回true，否则返回false
- */
-export function isNumeric(val: unknown): boolean {
-  if (typeof val === 'number') {
-    return !Number.isNaN(val) && Number.isFinite(val)
-  }
-  if (typeof val === 'string') {
-    // 不使用 trim()，直接判断字符串是否为有效的数字格式
-    const numericRegex = /^-?[1-9]\d*(\.\d+)?$|^0(\.\d+)?$|^-?0\.\d+$/
-    return numericRegex.test(val)
-  }
-  return false
-}

package/src/lodash/__test__/lodash.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { deepClone, omit, omitBy, pick, pickBy } from '../'
-
-describe('lodash.ts', () => {
-  test('deepClone - param is a plain object', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-    }
-    const cloneObj = deepClone(obj)
-    expect(cloneObj).toEqual(obj)
-    expect(cloneObj).not.toBe(obj)
-  })
-
-  test('deepClone - param is an array', () => {
-    const arr = [
-      1,
-      {
-        a: 1,
-      },
-      3,
-      4,
-      { b: 2 },
-    ]
-    const cloneObj = deepClone(arr)
-    expect(cloneObj).toEqual(arr)
-    expect(cloneObj).not.toBe(arr)
-  })
-
-  test('pick - param set to default', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-    }
-    const cloneObj = pick(obj, ['b'])
-    expect(cloneObj).toEqual({ b: { c: 2, d: { e: 3 } } })
-    expect(cloneObj).not.toBe(obj)
-  })
-
-  test('pickBy - param set to true', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-      c: '',
-      d: undefined,
-    }
-    const cloneObj = pickBy(obj, (value) => !!value)
-    const result = pick(obj, ['a', 'b'])
-    expect(cloneObj).toEqual(result)
-    expect(cloneObj).not.toBe(result)
-  })
-
-  test('omit - param is  default', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-      c: '',
-      d: undefined,
-    }
-    const cloneObj = omit(obj, ['a'])
-    const result = {
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-      c: '',
-    }
-    expect(cloneObj).toEqual(result)
-    expect(cloneObj).not.toBe(result)
-  })
-
-  test('omitBy - param set to false', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-        d: {
-          e: 3,
-        },
-      },
-      c: '',
-      d: undefined,
-    }
-    const cloneObj = omitBy(obj, (value) => !value)
-    const result = omit(obj, ['c'])
-    expect(cloneObj).toEqual(result)
-    expect(cloneObj).not.toBe(result)
-  })
-})

package/src/lodash/__test__/obj-string.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { objToQString, qStringToObj } from '../'
-
-describe('lodash.ts  objToQString', () => {
-  test('objToQString - param simple object', () => {
-    const obj = {
-      a: 1,
-      b: 2,
-    }
-    const qString = objToQString(obj)
-    expect(qString).toEqual('a=1&b=2')
-  })
-
-  test('objToQString - param object with array', () => {
-    const obj = {
-      a: 1,
-      b: [2, 3],
-    }
-    const qString = objToQString(obj)
-    expect(qString).toEqual('a=1&b=%5B2%2C3%5D')
-  })
-
-  test('objToQString - param object with object', () => {
-    const obj = {
-      a: 1,
-      b: {
-        c: 2,
-      },
-    }
-    const qString = objToQString(obj)
-    expect(qString).toEqual('a=1&b=%7B%22c%22%3A2%7D')
-  })
-
-  test('objToQString - param object with array and object', () => {
-    const obj = {
-      a: 1,
-      b: [2, { c: 3 }],
-    }
-    const qString = objToQString(obj)
-    expect(qString).toEqual('a=1&b=%5B2%2C%7B%22c%22%3A3%7D%5D')
-  })
-
-  test('objToQString - param is empty object', () => {
-    const obj = {}
-    const qString = objToQString(obj)
-    expect(qString).toEqual('')
-  })
-
-  test('objToQString - param is null', () => {
-    const obj = null
-    // @ts-ignore
-    const qString = objToQString(obj)
-    expect(qString).toEqual('')
-  })
-
-  test('qStringToObj - param is simple string', () => {
-    const qString = 'a=1&b=2&c=a'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ a: 1, b: 2, c: 'a' })
-  })
-
-  test('qStringToObj - param is string with array', () => {
-    const qString = 'a=1&b=%5B2%2C3%5D'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ a: 1, b: [2, 3] })
-  })
-
-  test('qStringToObj - param is string with object', () => {
-    const qString = 'a=1&b=%7B%22c%22%3A2%7D'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ a: 1, b: { c: 2 } })
-  })
-
-  test('qStringToObj - param is string with array and object', () => {
-    const qString = 'a=1&b=%5B2%2C%7B%22c%22%3A3%7D%5D'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ a: 1, b: [2, { c: 3 }] })
-  })
-
-  test('qStringToObj - param is null', () => {
-    const qString = null
-    // @ts-ignore
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({})
-  })
-
-  test('qStringToObj - param is empty string', () => {
-    const qString = ''
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({})
-  })
-  test('qStringToObj - param is url', () => {
-    const qString = 'https://example.com/path/to/page'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({})
-  })
-  test('qStringToObj - param is url with token', () => {
-    const qString = 'https://example.com/path/to/page?token=abc123'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ token: 'abc123' })
-  })
-  test('qStringToObj - param is url arg 2', () => {
-    const qString = 'https://example.com/path/to/page?token=abc123&name=test'
-    const obj = qStringToObj(qString)
-    expect(obj).toEqual({ token: 'abc123', name: 'test' })
-  })
-})

package/src/lodash/__test__/uniqueId.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { uniqueId } from '../'
-
-describe('lodash.ts', () => {
-  test('uniqueId 11 length', () => {
-    const length = 11
-    const _uid = uniqueId(length)
-    const _uid1 = uniqueId(length)
-    expect(_uid.length).toEqual(length)
-    expect(_uid1.length).toEqual(length)
-    expect(_uid).not.toEqual(_uid1)
-  })
-
-  test('uniqueId 16 length', () => {
-    const length = 16
-    const _uid = uniqueId(length)
-    const _uid1 = uniqueId(length)
-    expect(_uid.length).toEqual(length)
-    expect(_uid1.length).toEqual(length)
-    expect(_uid).not.toEqual(_uid1)
-  })
-
-  test('uniqueId 19 length', () => {
-    const length = 19
-    const _uid = uniqueId(length)
-    const _uid1 = uniqueId(length)
-    expect(_uid.length).toEqual(length)
-    expect(_uid1.length).toEqual(length)
-    expect(_uid).not.toEqual(_uid1)
-  })
-
-  test('uniqueId 32 length', () => {
-    const length = 32
-    const _uid = uniqueId(length)
-    const _uid1 = uniqueId(length)
-    expect(_uid.length).toEqual(length)
-    expect(_uid1.length).toEqual(length)
-    expect(_uid).not.toEqual(_uid1)
-  })
-})