@cloudcome/utils-core 1.1.0 → 1.1.1

package/test/promise.test.ts

@@ -0,0 +1,199 @@
+import {
+  createMinDelayPromise,
+  isPromiseLike,
+  promiseDelay,
+  promiseShared,
+  promiseTimeout,
+  promiseWhen,
+} from '@/promise';
+import { describe, expect, it } from 'vitest';
+
+describe('promiseDelay', () => {
+  it('应在指定时间后解决 Promise', async () => {
+    const startTime = Date.now();
+    await promiseDelay(100);
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeGreaterThanOrEqual(0);
+  });
+
+  it('如果 ms 为 0，应立即解决 Promise', async () => {
+    const startTime = Date.now();
+    await promiseDelay(0);
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeLessThan(10);
+  });
+
+  it('应在调用 abort 后解决 Promise', async () => {
+    const ctrl = new AbortController();
+    const startTime = Date.now();
+    const promise = promiseDelay(1000, ctrl);
+    ctrl.abort();
+    await promise;
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeLessThan(1010);
+  });
+});
+
+describe('promiseTimeout', () => {
+  it('如果 Promise 在指定时间内解决，应返回其结果', async () => {
+    const result = await promiseTimeout(Promise.resolve('success'), 100);
+    expect(result).toBe('success');
+  });
+
+  it('如果 Promise 在指定时间内未解决，应抛出 "timeout" 错误', async () => {
+    await expect(promiseTimeout(promiseDelay(100), 0)).rejects.toThrow('timeout');
+  });
+
+  it('如果 Promise 在指定时间内恰好解决，应返回其结果', async () => {
+    const result = await promiseTimeout(Promise.resolve('success'), 10);
+    expect(result).toBe('success');
+  });
+});
+
+describe('promiseWhen', () => {
+  it('如果条件初始为真，应立即解决 Promise', async () => {
+    const startTime = Date.now();
+    await promiseWhen(() => true, 100);
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeLessThan(10);
+  });
+
+  it('应在条件变为真后解决 Promise', async () => {
+    let conditionMet = false;
+    setTimeout(() => {
+      conditionMet = true;
+    }, 100);
+    const startTime = Date.now();
+    await promiseWhen(() => conditionMet, 10);
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeGreaterThanOrEqual(100);
+  });
+
+  it('应使用较小的时间间隔检查条件', async () => {
+    let conditionMet = false;
+    setTimeout(() => {
+      conditionMet = true;
+    }, 50);
+    const startTime = Date.now();
+    await promiseWhen(() => conditionMet, 10);
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeGreaterThanOrEqual(50);
+  });
+});
+
+describe('isPromiseLike', () => {
+  it('应正确判断 Promise 类型', async () => {
+    try {
+      const p1 = Promise.resolve();
+      expect(isPromiseLike(p1)).toBe(true);
+      await p1;
+
+      const p2 = Promise.reject();
+      expect(isPromiseLike(p2)).toBe(true);
+      // 这里需要执行掉，否会打印未捕获的 promise 错误
+      await p2;
+
+      const p3 = new Promise<void>((r) => r());
+      expect(isPromiseLike(p3)).toBe(true);
+      await p3;
+    } catch (cause) {
+      //
+    }
+  });
+
+  it('应正确判断 Promise 类似对象', () => {
+    // biome-ignore lint/suspicious/noThenProperty: <explanation>
+    expect(isPromiseLike({ then: () => {} })).toBe(true);
+    // biome-ignore lint/suspicious/noThenProperty: <explanation>
+    expect(isPromiseLike({ then: 'not a function' })).toBe(false);
+    expect(isPromiseLike({})).toBe(false);
+    expect(isPromiseLike(null)).toBe(false);
+    expect(isPromiseLike(undefined)).toBe(false);
+    expect(isPromiseLike('string')).toBe(false);
+    expect(isPromiseLike(42)).toBe(false);
+    expect(isPromiseLike(true)).toBe(false);
+    expect(isPromiseLike(Symbol('sym'))).toBe(false);
+    expect(isPromiseLike(BigInt(123))).toBe(false);
+    expect(isPromiseLike(Number.NaN)).toBe(false);
+    expect(isPromiseLike(new Error('error'))).toBe(false);
+  });
+});
+
+describe('sharedPromise', () => {
+  it('应共享原始 Promise 的成功状态', async () => {
+    const value = Math.random();
+    const { promise, resolve } = Promise.withResolvers();
+    const { promise: status, resolve: done } = Promise.withResolvers<void>();
+    const shared1 = promiseShared(promise);
+
+    setTimeout(async () => {
+      // 在完成之前共享
+      resolve(value);
+
+      // 在完成之后共享
+      await expect(promiseShared(promise)).resolves.toBe(value);
+      done();
+    }, 10);
+
+    await expect(shared1).resolves.toBe(value);
+    await expect(promise).resolves.toBe(value);
+
+    await expect(status).resolves.toBe(undefined);
+  });
+
+  it('应共享原始 Promise 的拒绝状态', async () => {
+    const value = Math.random();
+    const { promise, reject } = Promise.withResolvers();
+    const { promise: status, resolve: done } = Promise.withResolvers<void>();
+    const shared1 = promiseShared(promise);
+
+    setTimeout(async () => {
+      // 在完成之前共享
+      reject(value);
+
+      // 在完成之后共享
+      await expect(promiseShared(promise)).rejects.toBe(value);
+      done();
+    }, 10);
+
+    await expect(shared1).rejects.toBe(value);
+    await expect(promise).rejects.toBe(value);
+
+    await expect(status).resolves.toBe(undefined);
+  });
+});
+
+describe('createMinDelayPromise', () => {
+  it('当实际执行时间小于最小等待时间时，应等待剩余时间', async () => {
+    const minWait = 100;
+    const end = createMinDelayPromise(minWait);
+    const startTime = Date.now();
+    await promiseDelay(50); // 模拟操作耗时
+    await end();
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeGreaterThanOrEqual(minWait - 10);
+    expect(endTime - startTime).toBeLessThanOrEqual(minWait + 10);
+  });
+
+  it('当实际执行时间大于最小等待时间时，应立即返回', async () => {
+    const minWait = 50;
+    const end = createMinDelayPromise(minWait);
+    const startTime = Date.now();
+    await promiseDelay(100); // 模拟操作耗时
+    await end();
+    const endTime = Date.now();
+    // 实际情况下，这个时间是接近 100，可能是 99，也有可能是 101
+    expect(endTime - startTime).toBeGreaterThanOrEqual(90);
+    expect(endTime - startTime).toBeLessThanOrEqual(110);
+  });
+
+  it('当最小等待时间为 0 时，应立即返回', async () => {
+    const minWait = 0;
+    const end = createMinDelayPromise(minWait);
+    const startTime = Date.now();
+    await end();
+    const endTime = Date.now();
+    expect(endTime - startTime).toBeLessThanOrEqual(10);
+    expect(endTime - startTime).toBeGreaterThanOrEqual(0);
+  });
+});

package/test/qs.test.ts

@@ -0,0 +1,79 @@
+import { dateFormat } from '@/date';
+import { type QSReader, type QSWriter, qsParse, qsStringify } from '@/qs';
+import { isArray, isBoolean, isDate, isFunction, isNull, isNumber, isString, isUndefined } from '@/type';
+import { describe, expect, it } from 'vitest';
+
+describe('qsParse', () => {
+  it('默认 reader', () => {
+    expect(qsParse('?a=1')).toEqual({ a: '1' });
+    expect(qsParse('?a=1&b=2')).toEqual({ a: '1', b: '2' });
+    expect(qsParse('?a=1&b=1&b=2')).toEqual({ a: '1', b: ['1', '2'] });
+    expect(qsParse('?a=1&a=2&b=1')).toEqual({ a: ['1', '2'], b: '1' });
+    expect(qsParse('?a=1&a=2&a=3&a=4')).toEqual({ a: ['1', '2', '3', '4'] });
+    expect(qsParse('xx?a=1&a=2&a=3&a=4')).toEqual({ a: ['1', '2', '3', '4'] });
+    expect(qsParse('xx??a=1&a=2&a=3&a=4')).toEqual({ a: ['1', '2', '3', '4'] });
+  });
+
+  it('自定义 reader', () => {
+    const qsReader: QSReader<Record<string, string | number | boolean | Array<string | number | boolean>>> = (
+      value,
+      key,
+      qsObject,
+    ) => {
+      if (value === '1') {
+        return 1;
+      }
+
+      if (value === 'true') {
+        return true;
+      }
+
+      if (value.includes(',')) {
+        if (Object.hasOwn(qsObject, key)) {
+          if (!isArray(qsObject[key])) qsObject[key] = [qsObject[key]];
+        } else {
+          qsObject[key] = [];
+        }
+
+        qsObject[key].push(...value.split(','));
+        return;
+      }
+
+      return value;
+    };
+
+    expect(qsParse('?a=1', qsReader)).toEqual({ a: 1 });
+    expect(qsParse('?a=1&b=2', qsReader)).toEqual({ a: 1, b: '2' });
+    expect(qsParse('?a=1&b=2&a=3', qsReader)).toEqual({ a: [1, '3'], b: '2' });
+    expect(qsParse('?a=1&b=2&a=3&b=4,5', qsReader)).toEqual({ a: [1, '3'], b: ['2', '4', '5'] });
+    expect(qsParse('?a=1&b=2&a=3&c=4,5', qsReader)).toEqual({ a: [1, '3'], b: '2', c: ['4', '5'] });
+    expect(qsParse('?x=true', qsReader)).toEqual({ x: true });
+  });
+});
+
+describe('qsStringify', () => {
+  it('qsStringify 默认 writer', () => {
+    const i = new Date(2020, 0, 1, 0, 0, 0, 0);
+    const query = { a: 1, b: [2, 3], c: '4', d: undefined, e: null, f: true, g: false, i };
+    const string = 'a=1&b=2&b=3&c=4&f=true&g=false&i=2019-12-31T16%3A00%3A00.000Z';
+    expect(qsStringify(query)).toBe(string);
+  });
+
+  it('qsStringify 复写 writer', () => {
+    const qsWriter: QSWriter = (value, key, qsObject) => {
+      if (isString(value)) return `string-${value}`;
+      if (isNumber(value)) return `number-${value}`;
+      if (isBoolean(value)) return `boolean-${value ? 'true' : 'false'}`;
+      if (isUndefined(value)) return 'undefined';
+      if (isNull(value)) return 'null';
+      if (isDate(value)) return `date-${dateFormat(value, 'YYYY-MM-DD HH:mm:ss')}`;
+      return null;
+    };
+    const i = new Date(2020, 0, 1, 0, 0, 0, 0);
+    const query = { a: 1, b: [2, 3], c: '4', d: undefined, e: null, f: true, g: false, i };
+    const string =
+      'a=number-1&b=number-2&b=number-3&c=string-4&d=undefined&e=null&' +
+      'f=boolean-true&g=boolean-false&i=date-2020-01-01+00%3A00%3A00';
+    expect(qsStringify(query, qsWriter)).toBe(string);
+  });
+});

package/test/regexp.test.ts

@@ -0,0 +1,97 @@
+import {
+  isDigit,
+  isEmail,
+  isFloat,
+  isIDNo,
+  isIPV4,
+  isInteger,
+  isNumerical,
+  isPhone,
+  isURL,
+  regexpEscape,
+} from '@/regexp';
+import { expect, test } from 'vitest';
+
+test('reEscape', () => {
+  const str = 'a*';
+  const re = new RegExp(regexpEscape(str), 'i');
+
+  expect(re.source).toEqual('a\\*');
+  expect(re.test('a*')).toEqual(true);
+  expect(re.test('A*')).toEqual(true);
+});
+
+test('isURL', () => {
+  expect(isURL('')).toBe(false);
+  expect(isURL('http://aba.com')).toBe(true);
+  expect(isURL("http://aba.com:8080/'1@!.+%a?a(x)")).toBe(true);
+  expect(isURL("http://192.168.0.1/'1@!.+%a?a(x)")).toBe(true);
+  expect(isURL("http://192.168.0.1:8080/'1@!.+%a?a(x)")).toBe(true);
+});
+
+test('isEmail', () => {
+  expect(isEmail('')).toBe(false);
+  expect(isEmail('http://aba.com')).toBe(false);
+  expect(isEmail('http@aba.com')).toBe(true);
+  expect(isEmail('ht.tp@aba.com')).toBe(true);
+});
+
+test('isPhone', () => {
+  expect(isPhone('')).toBe(false);
+  expect(isPhone('19912345678')).toBe(true);
+});
+
+test('isIPV4', () => {
+  expect(isIPV4('')).toBe(false);
+  expect(isIPV4('11.11.111.11')).toBe(true);
+  expect(isIPV4('222.233.455.11')).toBe(false);
+});
+
+test('isIdNo', () => {
+  // http://id.8684.cn/
+  expect(isIDNo('350213197706189461')).toBe(true);
+  expect(isIDNo('350213197706189462')).toBe(false);
+});
+
+test('isInteger', () => {
+  expect(isInteger('1')).toBe(true);
+  expect(isInteger('-1')).toBe(true);
+  expect(isInteger('12300')).toBe(true);
+  expect(isInteger('-12300')).toBe(true);
+  expect(isInteger('0')).toBe(true);
+  expect(isInteger('0.0')).toBe(false);
+  expect(isInteger('0.1')).toBe(false);
+  expect(isInteger('-0')).toBe(false);
+  expect(isInteger('-0123')).toBe(false);
+  expect(isInteger('0123')).toBe(false);
+});
+
+test('isFloat', () => {
+  expect(isFloat('0')).toBe(false);
+  expect(isFloat('0.1')).toBe(true);
+  expect(isFloat('1.1')).toBe(true);
+  expect(isFloat('1.01')).toBe(true);
+  expect(isFloat('10.01')).toBe(true);
+  expect(isFloat('-10.01')).toBe(true);
+  expect(isFloat('010.01')).toBe(false);
+  expect(isFloat('10.010')).toBe(true);
+  expect(isFloat('10.0')).toBe(true);
+  expect(isFloat('10.')).toBe(false);
+  expect(isFloat('10')).toBe(false);
+});
+
+test('.isNumrical', () => {
+  expect(isNumerical('0')).toBe(true);
+  expect(isNumerical('0.0')).toBe(true);
+  expect(isNumerical('0.1')).toBe(true);
+  expect(isNumerical('1.1')).toBe(true);
+  expect(isNumerical('-1.1')).toBe(true);
+});
+
+test('isDigit', () => {
+  expect(isDigit('1')).toBe(true);
+  expect(isDigit('12')).toBe(true);
+  expect(isDigit('012')).toBe(true);
+  expect(isDigit('+012')).toBe(false);
+  expect(isDigit('-012')).toBe(false);
+});

package/test/string.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it } from 'vitest';
+import { randomString, randomUUID4, stringCamelCase, stringFormat, stringKebabCase, stringify } from '../src/string';
+
+describe('stringCamelCase', () => {
+  it('应将字符串转换为驼峰命名', () => {
+    expect(stringCamelCase('hello world')).toBe('helloWorld');
+    expect(stringCamelCase('hello_world')).toBe('helloWorld');
+    expect(stringCamelCase('hello-world')).toBe('helloWorld');
+  });
+
+  it('如果 bigger 为 true，应将首字母大写', () => {
+    expect(stringCamelCase('hello world', true)).toBe('HelloWorld');
+    expect(stringCamelCase('hello_world', true)).toBe('HelloWorld');
+    expect(stringCamelCase('hello-world', true)).toBe('HelloWorld');
+  });
+});
+
+describe('stringKebabCase', () => {
+  it('应将字符串转换为默认分隔符的短横线命名', () => {
+    expect(stringKebabCase('helloWorld')).toBe('hello-world');
+    expect(stringKebabCase('HelloWorld')).toBe('-hello-world');
+  });
+
+  it('应将字符串转换为自定义分隔符的短横线命名', () => {
+    expect(stringKebabCase('helloWorld', '_')).toBe('hello_world');
+    expect(stringKebabCase('HelloWorld', '_')).toBe('_hello_world');
+  });
+});
+
+describe('randomString', () => {
+  it('应生成指定长度的随机字符串', () => {
+    const result = randomString(10);
+    expect(result.length).toBe(10);
+  });
+
+  it('应使用自定义字符字典生成随机字符串', () => {
+    const dict = 'ABCDEF';
+    const result = randomString(8, dict);
+    expect(result).toHaveLength(8);
+    for (const char of result) {
+      expect(dict).toContain(char);
+    }
+  });
+});
+
+describe('stringFormat', () => {
+  it('应支持索引方式格式化字符串', () => {
+    const result = stringFormat('你好 {0}！我的名字是 {1}。', '张三', '李四');
+    expect(result).toBe('你好 张三！我的名字是 李四。');
+  });
+
+  it('应支持对象方式格式化字符串', () => {
+    const result = stringFormat('{greet}！我的名字是 {name}。', { greet: '你好', name: '王五' });
+    expect(result).toBe('你好！我的名字是 王五。');
+  });
+
+  it('应支持带回退值的对象方式格式化字符串', () => {
+    const result = stringFormat('{greet}！我的名字是 {name}。', { greet: '你好' }, '未知');
+    expect(result).toBe('你好！我的名字是 未知。');
+  });
+
+  it('应支持带回退函数的对象方式格式化字符串', () => {
+    const result = stringFormat('{greet}！我的名字是 {name}。', { greet: '你好' }, (key) => `默认${key}`);
+    expect(result).toBe('你好！我的名字是 默认name。');
+  });
+
+  it('应处理未找到的键值对', () => {
+    const result = stringFormat('{greet}！我的名字是 {name}。', { greet: '你好' });
+    expect(result).toBe('你好！我的名字是 name。');
+  });
+
+  it('应处理空字符串', () => {
+    const result = stringFormat('', { greet: '你好' });
+    expect(result).toBe('');
+  });
+
+  it('应处理未传递参数的情况', () => {
+    const result = stringFormat('{greet}！我的名字是 {name}。');
+    expect(result).toBe('greet！我的名字是 name。');
+  });
+
+  it('边界，值为 falsy 值', () => {
+    const result = stringFormat('{days}天{hours}时{minutes}分{seconds}秒', {
+      days: 0,
+      hours: 1,
+      minutes: 2,
+      seconds: 3,
+    });
+    expect(result).toBe('0天1时2分3秒');
+  });
+});
+
+describe('randomUUID4', () => {
+  it('验证长度', () => {
+    for (let i = 0; i < 10; i++) {
+      const uuid = randomUUID4();
+
+      // 验证长度
+      expect(uuid.length).toBe(36);
+    }
+  });
+
+  it('验证分隔符位置', () => {
+    for (let i = 0; i < 10; i++) {
+      const uuid = randomUUID4();
+
+      // 验证分隔符位置
+      expect(uuid[8]).toBe('-');
+      expect(uuid[13]).toBe('-');
+      expect(uuid[18]).toBe('-');
+      expect(uuid[23]).toBe('-');
+    }
+  });
+
+  it('验证版本号为 4', () => {
+    for (let i = 0; i < 10; i++) {
+      const uuid = randomUUID4();
+
+      // 验证版本号为 4
+      expect(uuid[14]).toBe('4');
+    }
+  });
+
+  it('验证变体', () => {
+    for (let i = 0; i < 10; i++) {
+      const uuid = randomUUID4();
+
+      // 验证变体符合 RFC 4122 (第19位为 '8', '9', 'a', 或 'b')
+      const variantChar = uuid[19];
+      expect(['8', '9', 'a', 'b']).toContain(variantChar);
+    }
+  });
+});
+
+describe('stringify', () => {
+  it('应将 null 转换为空字符串', () => {
+    expect(stringify(null)).toBe('');
+  });
+
+  it('应将 undefined 转换为空字符串', () => {
+    expect(stringify(undefined)).toBe('');
+  });
+
+  it('应将其他值转换为字符串', () => {
+    expect(stringify(123)).toBe('123');
+    expect(stringify(true)).toBe('true');
+    expect(stringify({})).toBe('[object Object]');
+    expect(stringify('hello')).toBe('hello');
+  });
+});