@cloudcome/utils-core 1.1.1 → 1.2.0

package/test/type.test.ts

@@ -1,226 +0,0 @@
-import { fnNoop } from '@/fn';
-import {
-  isArray,
-  isAsyncFunction,
-  isBigInt,
-  isBoolean,
-  isDate,
-  isError,
-  isFunction,
-  isNever,
-  isNull,
-  isNullish,
-  isNumber,
-  isObject,
-  isPrimitive,
-  isPromise,
-  isString,
-  isSymbol,
-  isUndefined,
-  isVoid,
-  typeIs,
-} from '@/type';
-import { describe, expect, it } from 'vitest';
-
-describe('typeIs', () => {
-  it('应返回正确的类型名称', () => {
-    expect(typeIs('hello')).toBe('string');
-    expect(typeIs(42)).toBe('number');
-    expect(typeIs(true)).toBe('boolean');
-    expect(typeIs(Symbol('sym'))).toBe('symbol');
-    expect(typeIs(BigInt(123))).toBe('bigint');
-    expect(typeIs(undefined)).toBe('undefined');
-    expect(typeIs(null)).toBe('null');
-    expect(typeIs({})).toBe('object');
-    expect(typeIs([])).toBe('array');
-    expect(typeIs(() => {})).toBe('function');
-    expect(typeIs(Number.NaN)).toBe('number');
-    expect(typeIs(new Error('error'))).toBe('error');
-    expect(typeIs(Promise.resolve())).toBe('promise');
-  });
-});
-
-describe('isString', () => {
-  it('应正确判断字符串', () => {
-    expect(isString('hello')).toBe(true);
-    expect(isString(42)).toBe(false);
-  });
-});
-
-describe('isBoolean', () => {
-  it('应正确判断布尔值', () => {
-    expect(isBoolean(true)).toBe(true);
-    expect(isBoolean(false)).toBe(true);
-    expect(isBoolean(42)).toBe(false);
-  });
-});
-
-describe('isSymbol', () => {
-  it('应正确判断符号', () => {
-    expect(isSymbol(Symbol('sym'))).toBe(true);
-    expect(isSymbol('hello')).toBe(false);
-  });
-});
-
-describe('isBigInt', () => {
-  it('应正确判断大整数', () => {
-    expect(isBigInt(BigInt(123))).toBe(true);
-    expect(isBigInt(42)).toBe(false);
-  });
-});
-
-describe('isNumber', () => {
-  it('应正确判断数字', () => {
-    expect(isNumber(42)).toBe(true);
-    expect(isNumber(Number.NaN)).toBe(false);
-  });
-});
-
-describe('isUndefined', () => {
-  it('应正确判断 undefined', () => {
-    expect(isUndefined(undefined)).toBe(true);
-    expect(isUndefined(null)).toBe(false);
-  });
-});
-
-describe('isVoid', () => {
-  it('应正确判断 void', () => {
-    expect(isVoid(undefined)).toBe(true);
-    expect(isVoid(null)).toBe(false);
-  });
-});
-
-describe('isNever', () => {
-  it('应正确处理 never 类型', () => {
-    try {
-      // 这里需要传入一个 never 类型的值，但 TypeScript 无法直接创建 never 类型的值
-      // 因此我们使用一个类型断言来模拟 never 类型
-      const neverValue = ((): never => {
-        throw new Error('never');
-      })();
-      expect(() => isNever(neverValue)).not.toThrow();
-    } catch (cause) {
-      //
-    }
-  });
-});
-
-describe('isNull', () => {
-  it('应正确判断 null', () => {
-    expect(isNull(null)).toBe(true);
-    expect(isNull(undefined)).toBe(false);
-  });
-});
-
-describe('isNullish', () => {
-  it('应正确判断 nullish', () => {
-    expect(isNullish(null)).toBe(true);
-    expect(isNullish(undefined)).toBe(true);
-    expect(isNullish(void 0)).toBe(true);
-    expect(isNullish(0)).toBe(false);
-  });
-});
-
-describe('isPrimitive', () => {
-  it('应正确判断原始类型', () => {
-    expect(isPrimitive(null)).toBe(true);
-    expect(isPrimitive(42)).toBe(true);
-    expect(isPrimitive('hello')).toBe(true);
-    expect(isPrimitive(true)).toBe(true);
-    expect(isPrimitive(Symbol('sym'))).toBe(true);
-    expect(isPrimitive(BigInt(123))).toBe(true);
-    expect(isPrimitive({})).toBe(false);
-    expect(isPrimitive([])).toBe(false);
-    expect(isPrimitive(() => {})).toBe(false);
-  });
-});
-
-describe('isObject', () => {
-  it('应正确判断对象', () => {
-    expect(isObject({})).toBe(true);
-    expect(isObject([])).toBe(false);
-    expect(isObject(() => {})).toBe(false);
-  });
-});
-
-describe('isArray', () => {
-  it('应正确判断数组', () => {
-    expect(isArray([])).toBe(true);
-    expect(isArray({})).toBe(false);
-    expect(isArray(() => {})).toBe(false);
-  });
-});
-
-describe('isFunction', () => {
-  it('应正确判断函数', () => {
-    expect(isFunction(() => {})).toBe(true);
-    expect(isFunction({})).toBe(false);
-    expect(isFunction([])).toBe(false);
-  });
-});
-
-describe('isError', () => {
-  it('应正确判断 Error 类型', () => {
-    expect(isError(new Error('error'))).toBe(true);
-    expect(isError({})).toBe(false);
-  });
-});
-
-describe('isPromise', () => {
-  it('应正确判断 Promise 类型', () => {
-    expect(isPromise(Promise.resolve())).toBe(true);
-    expect(isPromise(new Promise(() => {}))).toBe(true);
-    const p = Promise.reject().catch(fnNoop);
-    expect(isPromise(p)).toBe(true);
-  });
-
-  it('应正确判断非 Promise 类型', () => {
-    expect(isPromise('hello')).toBe(false);
-    expect(isPromise(42)).toBe(false);
-    expect(isPromise(true)).toBe(false);
-    expect(isPromise(Symbol('sym'))).toBe(false);
-    expect(isPromise(BigInt(123))).toBe(false);
-    expect(isPromise(undefined)).toBe(false);
-    expect(isPromise(null)).toBe(false);
-    expect(isPromise({})).toBe(false);
-    expect(isPromise([])).toBe(false);
-    expect(isPromise(() => {})).toBe(false);
-    expect(isPromise(Number.NaN)).toBe(false);
-    expect(isPromise(new Error('error'))).toBe(false);
-  });
-});
-
-describe('isDate', () => {
-  it('应正确判断 Date 类型', () => {
-    expect(isDate(new Date())).toBe(true);
-    expect(isDate(Date.now())).toBe(false);
-  });
-});
-
-describe('isAsyncFunction', () => {
-  it('应正确判断异步函数', async () => {
-    async function exampleAsync() {}
-    const asyncArrow = async () => {};
-
-    expect(isAsyncFunction(exampleAsync)).toBe(true);
-    expect(isAsyncFunction(asyncArrow)).toBe(true);
-  });
-
-  it('应正确判断普通函数', () => {
-    function exampleSync() {}
-    const syncArrow = () => {};
-
-    expect(isAsyncFunction(exampleSync)).toBe(false);
-    expect(isAsyncFunction(syncArrow)).toBe(false);
-  });
-
-  it('应正确判断非函数类型', () => {
-    expect(isAsyncFunction({})).toBe(false);
-    expect(isAsyncFunction([])).toBe(false);
-    expect(isAsyncFunction('function')).toBe(false);
-    expect(isAsyncFunction(42)).toBe(false);
-    expect(isAsyncFunction(true)).toBe(false);
-    expect(isAsyncFunction(null)).toBe(false);
-    expect(isAsyncFunction(undefined)).toBe(false);
-  });
-});

package/test/unique.test.ts

@@ -1,71 +0,0 @@
-import { uniqueBigInt, uniqueString } from '@/unique';
-
-describe('uniqueBigInt', () => {
-  test('默认参数返回 bigint 类型', () => {
-    const result = uniqueBigInt();
-    expect(typeof result).toBe('bigint');
-  });
-
-  test('指定 randomLength 为 0 时返回值正确', () => {
-    const result = uniqueBigInt(0);
-    expect(typeof result).toBe('bigint');
-    expect(result.toString().length).toBeGreaterThanOrEqual(13); // 时间戳部分至少 13 位
-  });
-
-  test('指定 randomLength 为正整数时返回值正确', () => {
-    const randomLength = 5;
-    const result = uniqueBigInt(randomLength);
-    expect(typeof result).toBe('bigint');
-    expect(result.toString().length).toBeGreaterThanOrEqual(13 + randomLength); // 时间戳 + 随机部分
-  });
-
-  test('多次调用生成的值具有唯一性', () => {
-    const results = new Set<bigint>();
-    for (let i = 0; i < 1000; i++) {
-      results.add(uniqueBigInt());
-    }
-    expect(results.size).toBe(1000); // 确保无重复值
-  });
-});
-
-describe('uniqueString', () => {
-  test('默认参数返回字符串且长度正确', () => {
-    const result = uniqueString();
-    expect(typeof result).toBe('string');
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  test('指定 minLength 参数时返回字符串长度符合要求', () => {
-    const minLength = 30;
-    const result = uniqueString(minLength);
-    expect(result.length).toBeGreaterThanOrEqual(minLength);
-  });
-
-  test('指定 dict 参数时使用指定字符集', () => {
-    const customDict = 'ABC123';
-    const result = uniqueString(0, customDict);
-    expect(result).toEqual(expect.stringMatching(new RegExp(`^[${customDict}]+$`)));
-  });
-
-  test('同时指定 minLength 和 dict 参数时满足条件', () => {
-    const minLength = 3;
-    const customDict = 'XYZ';
-    const result = uniqueString(minLength, customDict);
-    expect(result.length).toBeGreaterThanOrEqual(minLength);
-    expect(result).toEqual(expect.stringMatching(new RegExp(`^[${customDict}]+$`)));
-  });
-
-  test('多次调用生成唯一字符串', () => {
-    const results = new Set<string>();
-    for (let i = 0; i < 1000; i++) {
-      results.add(uniqueString());
-    }
-    expect(results.size).toBe(1000);
-  });
-
-  test('使用字符串类型 dict 参数时正确应用字符集', () => {
-    const customDict = 'abcdef';
-    const result = uniqueString(customDict);
-    expect(result).toEqual(expect.stringMatching(new RegExp(`^[${customDict}]+$`)));
-  });
-});

package/test/url.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { type TURLMeta, urlParse, urlStringify } from '../src/url';
-
-describe('urlParse 函数', () => {
-  it('应正确解析完整的 URL', () => {
-    const url = 'https://user:pass@example.com:8080/path/to/resource?query=param#hash';
-    const parsed = urlParse(url);
-    expect(parsed).toEqual({
-      hash: '#hash',
-      host: 'example.com:8080',
-      hostname: 'example.com',
-      password: 'pass',
-      pathname: '/path/to/resource',
-      port: '8080',
-      protocol: 'https:',
-      search: '?query=param',
-      username: 'user',
-    });
-  });
-
-  it('应正确处理缺少部分组件的 URL', () => {
-    const url = 'https://example.com/path/to/resource';
-    const parsed = urlParse(url);
-    expect(parsed).toEqual({
-      hash: '',
-      host: 'example.com',
-      hostname: 'example.com',
-      password: '',
-      pathname: '/path/to/resource',
-      port: '',
-      protocol: 'https:',
-      search: '',
-      username: '',
-    });
-  });
-
-  it('应正确处理不完整的 URL：没有协议', () => {
-    const url = 'example.com/path/to/resource';
-    const parsed = urlParse(url);
-    expect(parsed).toEqual({
-      hash: '',
-      host: '',
-      hostname: '',
-      password: '',
-      pathname: '',
-      port: '',
-      protocol: '',
-      search: '',
-      username: '',
-    });
-  });
-
-  it('应正确处理不完整的 URL：没有协议、域名', () => {
-    const url = '/path/to/resource';
-    const parsed = urlParse(url);
-    expect(parsed).toEqual({
-      hash: '',
-      host: '',
-      hostname: '',
-      password: '',
-      pathname: '',
-      port: '',
-      protocol: '',
-      search: '',
-      username: '',
-    });
-  });
-
-  it('应正确处理不完整的 URL：只有域名', () => {
-    const url = 'example.com';
-    const parsed = urlParse(url);
-    expect(parsed).toEqual({
-      hash: '',
-      host: '',
-      hostname: '',
-      password: '',
-      pathname: '',
-      port: '',
-      protocol: '',
-      search: '',
-      username: '',
-    });
-  });
-});
-
-describe('urlStringify 函数', () => {
-  it('应正确将 URLComponents 对象转换为 URL 字符串', () => {
-    const urlObj = {
-      protocol: 'https:',
-      hostname: 'example.com',
-      port: '8080',
-      pathname: '/path/to/resource',
-      search: '?query=param',
-      hash: '#hash',
-      username: 'user',
-      password: 'pass',
-    } as TURLMeta;
-    const url = urlStringify(urlObj);
-    expect(url).toBe('https://user:pass@example.com:8080/path/to/resource?query=param#hash');
-  });
-
-  it('应正确处理缺少部分组件的 URLInfo 对象', () => {
-    const urlObj = {
-      protocol: 'https:',
-      hostname: 'example.com',
-      pathname: '/path/to/resource',
-    } as TURLMeta;
-    const url = urlStringify(urlObj);
-    expect(url).toBe('https://example.com/path/to/resource');
-  });
-
-  it('没有协议', () => {
-    const urlObj = {
-      hostname: 'example.com',
-      pathname: '/path/to/resource',
-    } as TURLMeta;
-    const url = urlStringify(urlObj);
-    expect(url).toBe('example.com/path/to/resource');
-  });
-
-  it('只有域名', () => {
-    const urlObj = {
-      hostname: 'example.com',
-    } as TURLMeta;
-    const url = urlStringify(urlObj);
-    expect(url).toBe('example.com');
-  });
-
-  it('只有路径', () => {
-    const urlObj = {
-      pathname: '/path/to/resource',
-    } as TURLMeta;
-    const url = urlStringify(urlObj);
-    expect(url).toBe('/path/to/resource');
-  });
-});

package/test/version.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { versionCompare, versionParse } from '../src/version';
-
-describe('版本号工具函数测试', () => {
-  describe('versionParse 函数', () => {
-    it('应正确解析标准版本号', () => {
-      const result = versionParse('1.2.3');
-      expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
-    });
-
-    it('应处理缺失的版本号部分', () => {
-      const result = versionParse('1.2');
-      expect(result).toEqual({ major: 1, minor: 2, patch: 0 });
-    });
-
-    it('应处理非数字字符', () => {
-      const result = versionParse('1.a.3');
-      expect(result).toEqual({ major: 1, minor: 0, patch: 3 });
-    });
-
-    it('应处理空字符串', () => {
-      const result = versionParse('');
-      expect(result).toEqual({ major: 0, minor: 0, patch: 0 });
-    });
-  });
-
-  describe('versionCompare 函数', () => {
-    it('应正确比较主版本号', () => {
-      expect(versionCompare('2.0.0', '1.0.0')).toBe(1);
-      expect(versionCompare('1.0.0', '2.0.0')).toBe(-1);
-    });
-
-    it('应正确比较次版本号', () => {
-      expect(versionCompare('1.2.0', '1.1.0')).toBe(1);
-      expect(versionCompare('1.1.0', '1.2.0')).toBe(-1);
-    });
-
-    it('应正确比较修订号', () => {
-      expect(versionCompare('1.2.3', '1.2.2')).toBe(1);
-      expect(versionCompare('1.2.2', '1.2.3')).toBe(-1);
-    });
-
-    it('应处理相等版本号', () => {
-      expect(versionCompare('1.2.3', '1.2.3')).toBe(0);
-    });
-
-    it('应处理不完整版本号', () => {
-      expect(versionCompare('1.2', '1.2.0')).toBe(0);
-      expect(versionCompare('1', '1.0.0')).toBe(0);
-    });
-  });
-});

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "jsx": "preserve",
-    "jsxImportSource": "vue",
-    "target": "ES2024",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-
-    "strict": true,
-    "noEmit": true,
-    "allowJs": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "verbatimModuleSyntax": true,
-    "allowImportingTsExtensions": false,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-
-    "lib": ["ES2024", "DOM"],
-    "types": ["node", "vite/client", "vitest/globals"],
-    "plugins": [],
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-
-  "include": ["**/*.ts", "**/.*.ts", "**/*.mts", "**/*.tsx", "**/*.vue"],
-  "exclude": []
-}

package/vite.config.mts

@@ -1,114 +0,0 @@
-/**
- * @file vite.config.mts
- * @ref https://vitejs.dev/
- */
-
-import dts from 'vite-plugin-dts';
-import { externalizeDeps } from 'vite-plugin-externalize-deps';
-import tsconfigPaths from 'vite-tsconfig-paths';
-import { defineConfig } from 'vitest/config';
-import pkg from './package.json';
-
-export default defineConfig((env) => {
-  const isProd = env.mode === 'production';
-  const isTest = env.mode === 'test';
-
-  return {
-    base: '/',
-    server: {
-      port: 15170,
-    },
-    preview: {
-      port: 15171,
-    },
-    define: {
-      PKG_NAME: JSON.stringify(isTest ? 'pkg-name-for-test' : pkg.name),
-      PKG_VERSION: JSON.stringify(isTest ? 'pkg-version-for-test' : pkg.version),
-      PKG_DESCRIPTION: JSON.stringify(isTest ? 'pkg-description-for-test' : pkg.description),
-      IS_TEST: JSON.stringify(isTest),
-    },
-    build: {
-      minify: false,
-      sourcemap: true,
-      copyPublicDir: false,
-      reportCompressedSize: false,
-      lib: {
-        entry:
-          // expose-start
-          {
-            index: 'src/index.ts',
-            array: './src/array.ts',
-            async: './src/async.ts',
-            base64: './src/base64.ts',
-            cache: './src/cache.ts',
-            color: './src/color.ts',
-            crypto: './src/crypto.ts',
-            date: './src/date.ts',
-            dict: './src/dict.ts',
-            easing: './src/easing.ts',
-            emitter: './src/emitter.ts',
-            enum: './src/enum.ts',
-            env: './src/env.ts',
-            error: './src/error.ts',
-            exception: './src/exception.ts',
-            fn: './src/fn.ts',
-            number: './src/number.ts',
-            object: './src/object.ts',
-            path: './src/path.ts',
-            promise: './src/promise.ts',
-            qs: './src/qs.ts',
-            regexp: './src/regexp.ts',
-            string: './src/string.ts',
-            time: './src/time.ts',
-            timer: './src/timer.ts',
-            tree: './src/tree.ts',
-            type: './src/type.ts',
-            types: './src/types.ts',
-            unique: './src/unique.ts',
-            url: './src/url.ts',
-            version: './src/version.ts',
-          },
-        // expose-end
-      },
-      rollupOptions: {
-        output: [
-          {
-            format: 'esm',
-            entryFileNames: '[name].mjs',
-            chunkFileNames: '[name].mjs',
-          },
-          {
-            format: 'cjs',
-            entryFileNames: '[name].cjs',
-            chunkFileNames: '[name].cjs',
-          },
-        ],
-      },
-    },
-    test: {
-      globals: true,
-      environment: 'jsdom',
-      coverage: {
-        all: true,
-        include: ['src/**/*.ts'],
-        reporter: ['lcov', 'text'],
-      },
-    },
-    // esbuild: {
-    //   drop: isProd ? ['console', 'debugger'] : [],
-    // },
-    plugins: [
-      tsconfigPaths(),
-      externalizeDeps({
-        deps: true,
-        devDeps: true,
-        peerDeps: true,
-        optionalDeps: true,
-        nodeBuiltins: true,
-      }),
-      dts({
-        include: 'src',
-      }),
-    ],
-  };
-});