@cloudcome/utils-core 0.0.0 → 1.1.1

package/test/type.test.ts

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

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

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

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

@@ -0,0 +1,31 @@
+{
+  "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

@@ -0,0 +1,114 @@
+/**
+ * @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',
+      }),
+    ],
+  };
+});