@allkit/shared 0.0.1

package/skill/references/storage.md

@@ -0,0 +1,113 @@
+# storage
+
+本地存储工具函数，自动处理 JSON 序列化，支持 TypeScript 类型推断
+
+## Functions
+
+### setLocal
+
+设置 LocalStorage
+
+```ts
+function setLocal<T>(key: string, content: T): void
+```
+
+### getLocal
+
+获取 LocalStorage
+
+```ts
+function getLocal<T>(key: string): T
+```
+
+### removeLocal
+
+删除 LocalStorage
+
+```ts
+function removeLocal(key: string): void
+```
+
+### clearLocal
+
+清空 LocalStorage
+
+```ts
+function clearLocal(): void
+```
+
+### setSession
+
+设置 SessionStorage
+
+```ts
+function setSession<T>(key: string, content: T): void
+```
+
+### getSession
+
+获取 SessionStorage
+
+```ts
+function getSession<T>(key: string): T
+```
+
+### removeSession
+
+删除 SessionStorage
+
+```ts
+function removeSession(key: string): void
+```
+
+### clearSession
+
+清空 SessionStorage
+
+```ts
+function clearSession(): void
+```
+
+### setStore
+
+设置本地存储
+
+```ts
+function setStore<T>(key: string, value: T, type?: 'local' | 'session'): void
+```
+
+### getStore
+
+获取本地存储
+
+```ts
+function getStore<T>(key: string, type?: 'local' | 'session'): T
+```
+
+### removeStore
+
+删除本地存储
+
+```ts
+function removeStore(key: string, type?: 'local' | 'session'): void
+```
+
+## Example
+
+```ts
+import { setLocal, getLocal, setSession, getSession } from '@allkit/shared'
+
+// LocalStorage
+setLocal('token', '123')
+const token = getLocal<string>('token') // '123'
+removeLocal('token')
+
+// SessionStorage
+setSession('userInfo', { name: '张三', age: 18 })
+const userInfo = getSession<{ name: string; age: number }>('userInfo')
+removeSession('userInfo')
+
+// 通用方法
+setStore('token', '123', 'local')
+const token2 = getStore<string>('token', 'local')
+```

package/skill/references/string.md

@@ -0,0 +1,126 @@
+# string
+
+字符串操作工具函数
+
+## Functions
+
+### camelize
+
+中划线转小驼峰
+
+```ts
+function camelize(str: string): string
+```
+
+**Example**
+
+```ts
+camelize('user-info')  // 'userInfo'
+camelize('hello-world-test') // 'helloWorldTest'
+```
+
+### kebabCase
+
+驼峰转中划线
+
+```ts
+function kebabCase(str: string): string
+```
+
+**Example**
+
+```ts
+kebabCase('userInfo')  // 'user-info'
+kebabCase('helloWorldTest') // 'hello-world-test'
+```
+
+### snakeCase
+
+驼峰转下划线
+
+```ts
+function snakeCase(str: string): string
+```
+
+**Example**
+
+```ts
+snakeCase('userInfo')  // 'user_info'
+snakeCase('helloWorldTest') // 'hello_world_test'
+```
+
+### lowerFirst
+
+首字母转小写
+
+```ts
+function lowerFirst(str: string): string
+```
+
+**Example**
+
+```ts
+lowerFirst('UserInfo')  // 'userInfo'
+lowerFirst('Hello') // 'hello'
+```
+
+### upperFirst
+
+首字母转大写
+
+```ts
+function upperFirst(str: string): string
+```
+
+**Example**
+
+```ts
+upperFirst('userInfo')  // 'UserInfo'
+upperFirst('hello') // 'Hello'
+```
+
+### trim
+
+去除字符串首尾空白
+
+```ts
+function trim(str: string, chars?: string): string
+```
+
+**Example**
+
+```ts
+trim('  hello  ') // 'hello'
+trim('--hello--', '-') // 'hello'
+```
+
+### repeat
+
+重复字符串
+
+```ts
+function repeat(str: string, count: number): string
+```
+
+**Example**
+
+```ts
+repeat('a', 3) // 'aaa'
+repeat('ab', 2) // 'abab'
+```
+
+### padStart / padEnd
+
+字符串补全
+
+```ts
+function padStart(str: string, length: number, chars?: string): string
+function padEnd(str: string, length: number, chars?: string): string
+```
+
+**Example**
+
+```ts
+padStart('5', 2, '0') // '05'
+padEnd('hi', 4, '!') // 'hi!!'
+```

package/skill/references/timer.md

@@ -0,0 +1,78 @@
+# timer
+
+定时器工具函数
+
+## Functions
+
+### sleep
+
+睡眠函数
+
+```ts
+function sleep(timer: number): Promise<void>
+```
+
+**Example**
+
+```ts
+await sleep(1000) // 等待 1 秒
+```
+
+### raf
+
+监听下一动画帧（Promise）
+
+```ts
+function raf(): Promise<void>
+```
+
+**Example**
+
+```ts
+raf().then(() => {
+  console.log('执行下一帧')
+})
+```
+
+### doubleRaf
+
+监听双帧动画帧（Promise）
+
+```ts
+function doubleRaf(): Promise<void>
+```
+
+**Example**
+
+```ts
+doubleRaf().then(() => {
+  console.log('执行双帧后')
+})
+```
+
+### clearTimer
+
+清除定时器
+
+```ts
+function clearTimer(timerId: number | undefined): void
+```
+
+## Usage
+
+```ts
+import { sleep, raf, doubleRaf } from '@allkit/shared'
+
+// 睡眠
+await sleep(100)
+
+// 下一帧
+raf().then(() => {
+  console.log('执行下一帧')
+})
+
+// 双帧
+doubleRaf().then(() => {
+  console.log('执行双帧后')
+})
+```

package/src/clipboard/index.ts

@@ -0,0 +1,26 @@
+/**
+ * 复制文本到剪贴板
+ * @param value - 文本内容
+ * @example
+ * ```ts
+ * let isResult= copyTextToClipboard('test')
+ * ```
+ */
+export function copyTextToClipboard(value: string = '') {
+  // 动态创建 textarea 标签
+  const textarea = document.createElement('textarea')
+  // 将该 textarea 设为 readonly 防止 iOS 下自动唤起键盘，同时将 textarea 移出可视区域
+  textarea.readOnly = true
+  textarea.style.position = 'absolute'
+  textarea.style.left = '-9999px'
+  // 将要 copy 的值赋给 textarea 标签的 value 属性
+  textarea.value = value
+  // 将 textarea 插入到 body 中
+  document.body.appendChild(textarea)
+  // 选中值并复制
+  textarea.select()
+  textarea.setSelectionRange(0, textarea.value.length)
+  const result = document.execCommand('Copy')
+  document.body.removeChild(textarea)
+  return result
+}

package/src/cloneDeep/__test__/cloneDeep.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest'
+import { cloneDeep } from '../'
+describe('cloneDeep', () => {
+  test('simple object with no nested objects', () => {
+    const source = { a: 1, b: 'test' }
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result).not.toBe(source)
+  })
+
+  test('object with nested objects', () => {
+    const source = { a: 1, b: { c: 2 } }
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result.b).not.toBe(source.b)
+  })
+
+  test('object with multiple levels of nested objects', () => {
+    const source = { a: 1, b: { c: { d: 2 } } }
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result.b).not.toBe(source.b)
+    expect(result.b.c).not.toBe(source.b.c)
+  })
+
+  test('object with arrays and nested arrays', () => {
+    const source = { a: [1, [2]], b: { c: [3, 4] } }
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result.a).not.toBe(source.a)
+    expect(result.a[1]).not.toBe(source.a[1])
+    expect(result.b.c).not.toBe(source.b.c)
+  })
+
+  test('object with complex types of nested objects', () => {
+    const source = { a: { b: new Date(), c: /test/g, d: () => {} } }
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result).not.toBe(source)
+    expect(result.a).not.toBe(source.a)
+    expect(result.a.b).toBe(source.a.b)
+    expect(result.a.c).toBe(source.a.c)
+    expect(result.a.d).toBe(source.a.d)
+  })
+
+  test('object with non-enumerable properties', () => {
+    const source = { a: 1 }
+    Object.defineProperty(source, 'b', { value: 2, enumerable: false })
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+  })
+
+  test('object containing Set and Map instances', () => {
+    const source = {
+      a: new Set([{ a: 1 }, { a: 2 }]),
+      b: new Map([[{ b: 1 }, { b: 2 }]]),
+    }
+
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+
+    expect(result.a).not.toBe(source.a)
+    expect(result.b).not.toBe(source.b)
+
+    // Objects inside sets are cloned.
+    expect([...result.a].every((item) => !source.a.has(item))).toBe(true)
+
+    // Object keys in maps are *not* cloned.
+    // Object values in maps are cloned.
+    expect(
+      [...result.b].every(([key, value]) => source.b.has(key) && source.b.get(key) !== value),
+    ).toBe(true)
+  })
+
+  test('handle circular references', () => {
+    const source: any = { a: 1 }
+    source.b = source
+    const result = cloneDeep(source)
+    expect(result).not.toBe(source)
+    expect(result).toEqual(source)
+    expect(result.b).toBe(result)
+  })
+
+  test('avoid cloning an object more than once', () => {
+    const source: any = { a1: { b: 1 } }
+    source.a2 = source.a1
+    const result = cloneDeep(source)
+    expect(result).toEqual(source)
+    expect(result.a1).toBe(result.a2)
+    expect(result.a1).not.toBe(source.a1)
+  })
+})

package/src/cloneDeep/index.ts

@@ -0,0 +1,168 @@
+import { isArray, isMap, isPlainObject, isSet, isUnDef } from '../is'
+
+/**
+ * A strategy for cloning objects with `cloneDeep`.
+ *
+ * Methods **must** call the `track` function with the new parent
+ * object **before** looping over the input object's
+ * properties/elements for cloning purposes. This protects against
+ * circular references.
+ *
+ * Methods may return the input object to indicate that cloning should
+ * be skipped.
+ *
+ * Methods may return null to indicate that the default cloning logic
+ * should be used.
+ */
+export interface CloningStrategy {
+  cloneMap: <K, V>(
+    parent: Map<K, V>,
+    track: (newParent: Map<K, V>) => Map<K, V>,
+    clone: <T>(value: T) => T,
+  ) => Map<K, V> | null
+  cloneSet: <T>(
+    parent: Set<T>,
+    track: (newParent: Set<T>) => Set<T>,
+    clone: <T>(value: T) => T,
+  ) => Set<T> | null
+  cloneArray: <T>(
+    parent: readonly T[],
+    track: (newParent: T[]) => T[],
+    clone: <T>(value: T) => T,
+  ) => T[] | null
+  cloneObject: <T extends object>(
+    parent: T,
+    track: (newParent: T) => T,
+    clone: <T>(value: T) => T,
+  ) => T | null
+  cloneOther: <T>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null
+}
+
+export const DefaultCloningStrategy: CloningStrategy = {
+  cloneMap<K, V>(
+    input: Map<K, V>,
+    track: (newParent: Map<K, V>) => Map<K, V>,
+    clone: <T>(value: T) => T,
+  ): Map<K, V> {
+    const output = track(new Map())
+    for (const [key, value] of input) {
+      output.set(key, clone(value))
+    }
+    return output
+  },
+  cloneSet<T>(
+    input: Set<T>,
+    track: (newParent: Set<T>) => Set<T>,
+    clone: <T>(value: T) => T,
+  ): Set<T> {
+    const output = track(new Set())
+    for (const value of input) {
+      output.add(clone(value))
+    }
+    return output
+  },
+  cloneArray<T>(
+    input: readonly T[],
+    track: (newParent: T[]) => T[],
+    clone: <T>(value: T) => T,
+  ): T[] {
+    // Use .forEach for correct handling of sparse arrays
+    const output = track(new Array(input.length))
+    input.forEach((value, index) => {
+      output[index] = clone(value)
+    })
+    return output
+  },
+  cloneObject<T extends object>(
+    input: T,
+    track: (newParent: T) => T,
+    clone: <T>(value: T) => T,
+  ): T {
+    const output = track(Object.create(Object.getPrototypeOf(input)))
+    for (const key of Reflect.ownKeys(input)) {
+      // By copying the property descriptors, we preserve computed
+      // properties and non-enumerable properties.
+      const descriptor = Object.getOwnPropertyDescriptor(input, key)!
+      if ('value' in descriptor) {
+        descriptor.value = clone(descriptor.value)
+      }
+      Object.defineProperty(output, key, descriptor)
+    }
+    return output
+  },
+  cloneOther<T>(input: T, track: (newParent: T) => T): T {
+    return track(input)
+  },
+}
+
+/**
+ * 深拷贝
+ *
+ * 默认情况下，唯一被克隆的对象是普通对象、类实例、数组、`Set`实例和`Map`,`Date`
+ * 其他的场景,通过第二个参数自定义Strategy,实现拷贝逻辑(copy Radashi)
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2 } }
+ * const clone = cloneDeep(obj)
+ * ```
+ */
+export function cloneDeep<T extends object>(root: T, customStrategy?: Partial<CloningStrategy>): T {
+  if (isUnDef(root)) {
+    return root
+  }
+  const strategy = { ...DefaultCloningStrategy, ...customStrategy }
+
+  const tracked = new Map<unknown, unknown>()
+  const track = (parent: unknown, newParent: unknown) => {
+    tracked.set(parent, newParent)
+    return newParent
+  }
+
+  const clone = <T>(value: T): T =>
+    value && typeof value === 'object'
+      ? ((tracked.get(value) ?? cloneDeep(value, strategy)) as T)
+      : value
+
+  const cloneDeep = (parent: unknown, strategy: CloningStrategy): unknown => {
+    const cloneParent = (
+      isPlainObject(parent)
+        ? strategy.cloneObject
+        : isArray(parent)
+          ? strategy.cloneArray
+          : isMap(parent)
+            ? strategy.cloneMap
+            : isSet(parent)
+              ? strategy.cloneSet
+              : strategy.cloneOther
+    ) as (
+      newParent: unknown,
+      track: (newParent: unknown) => unknown,
+      clone: (value: unknown) => unknown,
+    ) => unknown
+
+    const newParent = cloneParent(parent, track.bind(null, parent), clone)
+    if (!newParent) {
+      // Use the default strategy if null is returned.
+      return cloneDeep(parent, DefaultCloningStrategy)
+    }
+
+    tracked.set(parent, newParent)
+    return newParent
+  }
+
+  return cloneDeep(root, strategy) as T
+}
+
+/**
+ * @deprecated - 请使用cloneDeep
+ *
+ * 深拷贝(与cloneDeep完成相同,历史原因2个名字)
+ * 默认情况下，唯一被克隆的对象是普通对象、类实例、数组、`Set`实例和`Map`,`Date`
+ * 其他的场景,通过第二个参数自定义Strategy,实现拷贝逻辑
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2 } }
+ * const clone = deepClone(obj)
+ * ```
+ */
+export const deepClone = cloneDeep

package/src/constants.ts

@@ -0,0 +1,27 @@
+/**
+ * 普通是与否枚举
+ */
+export enum EnumYesNo {
+  /**
+   * 是('1')
+   */
+  YES = 1,
+  /**
+   * 否('0')
+   */
+  NO = 0,
+}
+
+/**
+ * 普通是与否枚举(10,20)
+ */
+export enum EnumYesNoPlus {
+  /**
+   * 是('10')
+   */
+  YES = '10',
+  /**
+   * 否('20')
+   */
+  NO = '20',
+}

package/src/cookie/index.ts

@@ -0,0 +1,44 @@
+import Cookies from 'js-cookie'
+
+/**
+ * 设置cookie
+ * @param name - cookie的key
+ * @param value - cookie的内容
+ * @param options - cookie的配置
+ * @example
+ * ```ts
+ *  setCookie('name', 'value')
+ *  setCookie('name', 'value', { expires: 30 })
+ * ```
+ */
+export function setCookie(
+  name: string,
+  value: string,
+  options: Parameters<typeof Cookies.set>[2] = { expires: 30 },
+) {
+  Cookies.set(name, value, options)
+}
+
+/**
+ * 获取指定name的cookie值
+ * @param name - cookie的key
+ * @example
+ * ```ts
+ *  getCookie('name')
+ * ```
+ */
+export function getCookie(name: string) {
+  return Cookies.get(name)
+}
+
+/**
+ * 删除指定name的cookie
+ * @param name - cookie的key
+ * @example
+ * ```ts
+ *  removeCookie('name')
+ * ```
+ */
+export function removeCookie(name: string) {
+  Cookies.remove(name)
+}

package/src/date/__test__/date-diff.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'vitest'
+import { dateDiffFormat } from '../'
+
+describe('date.ts', () => {
+  test('dateDiffFormat - YY年MM个月DD天', () => {
+    const start = '2024-12-18'
+    const _date = dateDiffFormat(start, 1743762046095)
+    expect(_date).toEqual('0年3个月17天')
+  })
+
+  test('dateFormat - param is Date', () => {
+    const start = '2024-12-18'
+    const _date = dateDiffFormat(start, 1743762046095, 'MM个月DD天')
+
+    expect(_date).toEqual('3个月17天')
+  })
+
+  test('dateFormat - param is Date', () => {
+    const start = '2023-12-18'
+    const _date = dateDiffFormat(start, '2026-12-18', 'MM个月DD天')
+    expect(_date).toEqual('36个月0天')
+  })
+})