@allkit/shared 0.0.4 → 0.0.5

package/dist/skills/shared/references/storage.md

@@ -1,113 +0,0 @@
-# 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/dist/skills/shared/references/string.md

@@ -1,126 +0,0 @@
-# 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/dist/skills/shared/references/timer.md

@@ -1,78 +0,0 @@
-# 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/eslint.config.js

@@ -1,10 +0,0 @@
-import allkitEslintConfig from '@allkit/eslint-config';
-
-export default [
-  {
-    ignores: ['dist/**', 'node_modules/**'],
-  },
-  ...allkitEslintConfig,
-];
-
-

package/scripts/build.mjs

@@ -1,95 +0,0 @@
-import { createReadStream, createWriteStream } from 'fs'
-import { createRequire } from 'module'
-import { dirname, resolve } from 'path'
-import { fileURLToPath } from 'url'
-import fse from 'fs-extra'
-// 引入 vite 的 build 方法，进行编译构建
-import { build } from 'vite'
-import { viteLibConfig } from '@allkit/vite-config'
-
-const { outputFile, copy } = fse
-
-const require = createRequire(import.meta.url)
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-// 输出目录
-const outputDir = resolve(__dirname, '../dist')
-
-const {
-  version,
-  peerDependencies,
-  name,
-  description,
-  publishConfig,
-  dependencies,
-  type,
-} = require('../package.json')
-// 生成 package.json
-const createPackageJson = () => {
-  const pkgName = name
-  const pkgUMD = './shared.umd.js'
-  const pkgESM = './shared.es.js'
-
-  const fileStr = `{
-    "name": "${pkgName}",
-    "version": "${version}",
-    "description": "${description}",
-    "main": "${pkgUMD}",
-    "module":"${pkgESM}",
-    "types": "index.d.ts",
-    "exports": {
-      ".": {
-        "import": "${pkgESM}",
-        "require": "${pkgUMD}"
-      }
-    },
-    "keywords": ["lodash", "dayjs", "big.js","${name || ''}"],
-    "license": "MIT",
-    "author": "Spig",
-    "publishConfig":${JSON.stringify(publishConfig)},
-    "dependencies":${JSON.stringify(dependencies)},
-    "peerDependencies":  ${peerDependencies ? JSON.stringify(peerDependencies) : '{}'}
-  }
-  `
-  // 单个组件 or 全量
-  const filePath = resolve(outputDir, 'package.json')
-  outputFile(filePath, fileStr, 'utf-8')
-}
-
-/** 全量构建 */
-const buildAll = async () => {
-  const config = viteLibConfig({
-    mode: 'production',
-    build: {
-      target: 'es2015',
-      lib: {
-        entry: './src/index.ts',
-        name: 'shared',
-        fileName: (format) => `shared.${format}.js`,
-      },
-    },
-  })
-  await build(config)
-
-  createPackageJson()
-}
-
-// copy文件
-// README.md
-// 样式 index.css
-// skills 目录
-const copyFiles = async () => {
-  const markdown = createReadStream(resolve(__dirname, '../README.md'))
-  markdown.pipe(createWriteStream(resolve(__dirname, '../dist/README.md')))
-
-  await copy(resolve(__dirname, '../skills'), resolve(__dirname, '../dist/skills'))
-}
-
-const buildLib = async () => {
-  await buildAll()
-  await copyFiles()
-}
-
-buildLib()

package/src/clipboard/index.ts

@@ -1,26 +0,0 @@
-/**
- * 复制文本到剪贴板
- * @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

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

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