@syzlm/function 1.0.0 → 1.0.1

package/tests/numbers.test.ts

@@ -1,140 +0,0 @@
-import { range, round, clamp, toFixed } from '../src/numbers/numberUtils';
-
-describe('数字工具函数测试', () => {
-  describe('range 函数', () => {
-    it('应该正确生成数字范围', () => {
-      expect(range(1, 5)).toEqual([1, 2, 3, 4, 5]);
-      expect(range(0, 3)).toEqual([0, 1, 2, 3]);
-    });
-
-    it('应该正确生成带步长的数字范围', () => {
-      expect(range(1, 10, 2)).toEqual([1, 3, 5, 7, 9]);
-      expect(range(0, 10, 3)).toEqual([0, 3, 6, 9]);
-    });
-
-    it('应该正确处理开始等于结束的情况', () => {
-      expect(range(5, 5)).toEqual([5]);
-      expect(range(10, 10, 2)).toEqual([10]);
-    });
-
-    it('应该正确处理负数范围', () => {
-      expect(range(-5, 0)).toEqual([-5, -4, -3, -2, -1, 0]);
-      expect(range(-3, 3, 2)).toEqual([-3, -1, 1, 3]);
-    });
-  });
-
-  describe('round 函数', () => {
-    it('应该正确四舍五入到整数', () => {
-      expect(round(1.234)).toBe(1);
-      expect(round(1.567)).toBe(2);
-      expect(round(1.499)).toBe(1);
-    });
-
-    it('应该正确保留指定小数位数', () => {
-      expect(round(1.234, 2)).toBe(1.23);
-      expect(round(1.567, 2)).toBe(1.57);
-      expect(round(1.499, 2)).toBe(1.5);
-    });
-
-    it('应该正确处理负数', () => {
-      expect(round(-1.234)).toBe(-1);
-      expect(round(-1.567)).toBe(-2);
-      expect(round(-1.499, 2)).toBe(-1.5);
-    });
-
-    it('应该正确处理零', () => {
-      expect(round(0)).toBe(0);
-      expect(round(0.499)).toBe(0);
-      expect(round(0.5)).toBe(1);
-    });
-  });
-
-  describe('clamp 函数', () => {
-    it('应该正确限制数字在指定范围内', () => {
-      expect(clamp(5, 1, 10)).toBe(5);
-      expect(clamp(0, 1, 10)).toBe(1);
-      expect(clamp(15, 1, 10)).toBe(10);
-    });
-
-    it('应该正确处理等于边界的情况', () => {
-      expect(clamp(1, 1, 10)).toBe(1);
-      expect(clamp(10, 1, 10)).toBe(10);
-    });
-
-    it('应该正确处理负数范围', () => {
-      expect(clamp(-5, -10, 0)).toBe(-5);
-      expect(clamp(-15, -10, 0)).toBe(-10);
-      expect(clamp(5, -10, 0)).toBe(0);
-    });
-
-    it('应该正确处理零', () => {
-      expect(clamp(0, -5, 5)).toBe(0);
-      expect(clamp(0, 1, 10)).toBe(1);
-      expect(clamp(0, -10, -1)).toBe(-1);
-    });
-  });
-
-  describe('toFixed 函数', () => {
-    it('应该正确格式化数字到指定小数位数', () => {
-      expect(toFixed(1.234, 2)).toBe('1.23');
-      expect(toFixed(1.567, 2)).toBe('1.57');
-      expect(toFixed(1.499, 2)).toBe('1.50');
-    });
-
-    it('应该正确处理零', () => {
-      expect(toFixed(0, 2)).toBe('0.00');
-      expect(toFixed(0.499, 1)).toBe('0.5');
-      expect(toFixed(0.5, 0)).toBe('1');
-    });
-
-    it('应该正确处理负数', () => {
-      expect(toFixed(-1.234, 2)).toBe('-1.23');
-      expect(toFixed(-1.567, 2)).toBe('-1.57');
-      expect(toFixed(-1.499, 2)).toBe('-1.50');
-    });
-
-    it('应该正确处理整数', () => {
-      expect(toFixed(123, 2)).toBe('123.00');
-      expect(toFixed(123456, 3)).toBe('123456.000');
-    });
-
-    it('应该正确处理高精度小数', () => {
-      // 测试经典的精度问题
-      expect(toFixed(1.005, 2)).toBe('1.01');
-      expect(toFixed(0.1 + 0.2, 1)).toBe('0.3');
-      expect(toFixed(2.005, 2)).toBe('2.01');
-      expect(toFixed(1.0005, 3)).toBe('1.001');
-    });
-
-    it('应该正确处理更多精度的情况', () => {
-      expect(toFixed(1.23456789, 6)).toBe('1.234568');
-      expect(toFixed(0.0000005, 6)).toBe('0.000001');
-    });
-
-    it('应该正确处理科学计数法', () => {
-      expect(toFixed(1.234e10, 2)).toBe('12340000000.00');
-      expect(toFixed(1.234e-3, 5)).toBe('0.00123');
-      expect(toFixed(1.23456789e-5, 8)).toBe('0.00001235');
-    });
-
-    it('应该正确处理默认小数位数', () => {
-      expect(toFixed(1.234)).toBe('1');
-      expect(toFixed(1.567)).toBe('2');
-    });
-
-    it('应该正确处理负数小数位数', () => {
-      expect(toFixed(1.234, -2)).toBe('1');
-      expect(toFixed(1.567, -1)).toBe('2');
-    });
-
-    it('应该正确处理大量小数位数', () => {
-      expect(toFixed(1.23456789, 10)).toBe('1.2345678900');
-    });
-
-    it('应该正确处理需要进位到整数部分的情况', () => {
-      expect(toFixed(9.999, 2)).toBe('10.00');
-      expect(toFixed(99.999, 1)).toBe('100.0');
-      expect(toFixed(999.999, 0)).toBe('1000');
-    });
-  });
-});

package/tests/objects.test.ts

@@ -1,189 +0,0 @@
-import { deepClone, merge, get, set, isPlainObject } from '../src/objects/objectUtils';
-
-describe('对象工具函数测试', () => {
-  describe('deepClone 函数', () => {
-    it('应该正确深拷贝普通对象', () => {
-      const obj = { a: 1, b: { c: 2, d: [3, 4] } };
-      const cloned = deepClone(obj);
-      
-      expect(cloned).toEqual(obj);
-      expect(cloned).not.toBe(obj);
-      expect(cloned.b).not.toBe(obj.b);
-      expect(cloned.b.d).not.toBe(obj.b.d);
-    });
-
-    it('应该正确深拷贝数组', () => {
-      const arr = [1, { a: 2 }, [3, 4]];
-      const cloned = deepClone(arr);
-      
-      expect(cloned).toEqual(arr);
-      expect(cloned).not.toBe(arr);
-      expect(cloned[1]).not.toBe(arr[1]);
-      expect(cloned[2]).not.toBe(arr[2]);
-    });
-
-    it('应该正确深拷贝日期对象', () => {
-      const date = new Date();
-      const cloned = deepClone(date);
-      
-      expect(cloned).toEqual(date);
-      expect(cloned).not.toBe(date);
-      expect(cloned instanceof Date).toBe(true);
-    });
-
-    it('应该正确处理null和基本类型', () => {
-      expect(deepClone(null)).toBeNull();
-      expect(deepClone(42)).toBe(42);
-      expect(deepClone('string')).toBe('string');
-      expect(deepClone(true)).toBe(true);
-    });
-
-    it('应该正确处理嵌套的复杂对象', () => {
-      const complexObj = {
-        a: 1,
-        b: {
-          c: [2, 3, { d: 4 }],
-          e: new Date(),
-          f: { g: { h: 5 } }
-        }
-      };
-      
-      const cloned = deepClone(complexObj);
-      expect(cloned).toEqual(complexObj);
-      expect(cloned).not.toBe(complexObj);
-      expect(cloned.b).not.toBe(complexObj.b);
-      expect(cloned.b.c).not.toBe(complexObj.b.c);
-      expect(cloned.b.c[2]).not.toBe(complexObj.b.c[2]);
-      expect(cloned.b.e).not.toBe(complexObj.b.e);
-      expect(cloned.b.f).not.toBe(complexObj.b.f);
-      expect(cloned.b.f.g).not.toBe(complexObj.b.f.g);
-    });
-  });
-
-  describe('merge 函数', () => {
-    it('应该正确合并多个对象', () => {
-      const obj1 = { a: 1, b: 2 };
-      const obj2 = { b: 3, c: 4 };
-      const obj3 = { d: 5 };
-      
-      const result = merge(obj1, obj2, obj3);
-      
-      expect(result).toEqual({ a: 1, b: 3, c: 4, d: 5 });
-      expect(result).not.toBe(obj1);
-      expect(result).not.toBe(obj2);
-      expect(result).not.toBe(obj3);
-    });
-
-    it('应该正确处理空对象', () => {
-      const obj = { a: 1, b: 2 };
-      expect(merge(obj, {})).toEqual(obj);
-      expect(merge({}, obj)).toEqual(obj);
-      expect(merge({}, {})).toEqual({});
-    });
-
-    it('应该正确处理单个对象', () => {
-      const obj = { a: 1, b: 2 };
-      expect(merge(obj)).toEqual(obj);
-      expect(merge(obj)).not.toBe(obj); // 应该返回新对象
-    });
-
-    it('应该正确合并嵌套对象', () => {
-      const obj1 = { a: { b: 1 } };
-      const obj2 = { a: { c: 2 } };
-      
-      const result = merge(obj1, obj2);
-      
-      // 注意：merge函数使用Object.assign，只做浅合并
-      expect(result).toEqual({ a: { c: 2 } });
-    });
-  });
-
-  describe('get 函数', () => {
-    const obj = { a: { b: { c: 1, d: [2, 3] } }, e: 4 };
-    
-    it('应该正确获取嵌套属性', () => {
-      expect(get(obj, 'a.b.c')).toBe(1);
-      expect(get(obj, 'e')).toBe(4);
-    });
-
-    it('应该正确获取数组元素', () => {
-      expect(get(obj, 'a.b.d.0')).toBe(2);
-      expect(get(obj, 'a.b.d.1')).toBe(3);
-    });
-
-    it('应该在属性不存在时返回默认值', () => {
-      expect(get(obj, 'a.b.x', 'default')).toBe('default');
-      expect(get(obj, 'x', null)).toBeNull();
-    });
-
-    it('应该在路径中断时返回默认值', () => {
-      expect(get(obj, 'a.x.c', 'default')).toBe('default');
-      expect(get(null, 'a.b.c', 'default')).toBe('default');
-    });
-
-    it('应该在未提供默认值时返回undefined', () => {
-      expect(get(obj, 'a.b.x')).toBeUndefined();
-      expect(get(obj, 'x')).toBeUndefined();
-    });
-  });
-
-  describe('set 函数', () => {
-    it('应该正确设置嵌套属性', () => {
-      const obj = { a: { b: { c: 1 } } };
-      set(obj, 'a.b.c', 2);
-      expect(obj.a.b.c).toBe(2);
-    });
-
-    it('应该正确创建不存在的路径', () => {
-      const obj = {};
-      set(obj, 'a.b.c', 1);
-      expect(obj).toEqual({ a: { b: { c: 1 } } });
-    });
-
-    it('应该正确设置数组元素', () => {
-      const obj = { a: { b: [1, 2, 3] } };
-      set(obj, 'a.b.1', 4);
-      expect(obj.a.b).toEqual([1, 4, 3]);
-    });
-
-    it('应该在路径中断时创建对象', () => {
-      const obj = { a: null };
-      set(obj, 'a.b.c', 1);
-      expect(obj).toEqual({ a: { b: { c: 1 } } });
-    });
-
-    it('应该返回修改后的对象', () => {
-      const obj = { a: 1 };
-      const result = set(obj, 'b', 2);
-      expect(result).toBe(obj);
-      expect(result).toEqual({ a: 1, b: 2 });
-    });
-  });
-
-  describe('isPlainObject 函数', () => {
-    it('应该正确识别普通对象', () => {
-      expect(isPlainObject({})).toBe(true);
-      expect(isPlainObject({ a: 1 })).toBe(true);
-      expect(isPlainObject(Object.create(null))).toBe(true);
-    });
-
-    it('应该正确识别非普通对象', () => {
-      expect(isPlainObject(null)).toBe(false);
-      expect(isPlainObject([])).toBe(false);
-      expect(isPlainObject(new Date())).toBe(false);
-      expect(isPlainObject(new RegExp(''))).toBe(false);
-      expect(isPlainObject(function() {})).toBe(false);
-      expect(isPlainObject(42)).toBe(false);
-      expect(isPlainObject('string')).toBe(false);
-      expect(isPlainObject(true)).toBe(false);
-    });
-
-    it('应该正确识别自定义类的实例', () => {
-      class CustomClass {
-        constructor(public value: number) {}
-      }
-      
-      expect(isPlainObject(new CustomClass(42))).toBe(false);
-    });
-  });
-});

package/tests/strings.test.ts

@@ -1,197 +0,0 @@
-import { toCamelCase, capitalize, randomString, parseStrEmpty, getFontLength, getFontWidth, thousandSign, thousandSignZero } from '../src/strings/stringUtils';
-
-describe('字符串工具函数测试', () => {
-  describe('toCamelCase 函数', () => {
-    it('应该正确将连字符分隔的字符串转换为驼峰命名', () => {
-      expect(toCamelCase('hello-world')).toBe('helloWorld');
-      expect(toCamelCase('hello-world-test')).toBe('helloWorldTest');
-    });
-
-    it('应该正确将下划线分隔的字符串转换为驼峰命名', () => {
-      expect(toCamelCase('hello_world')).toBe('helloWorld');
-      expect(toCamelCase('hello_world_test')).toBe('helloWorldTest');
-    });
-
-    it('应该正确将空格分隔的字符串转换为驼峰命名', () => {
-      expect(toCamelCase('hello world')).toBe('helloWorld');
-      expect(toCamelCase('hello world test')).toBe('helloWorldTest');
-    });
-
-    it('应该正确处理混合分隔符的字符串', () => {
-      expect(toCamelCase('hello-world_test')).toBe('helloWorldTest');
-      expect(toCamelCase('hello world-test')).toBe('helloWorldTest');
-    });
-
-    it('应该正确处理空字符串', () => {
-      expect(toCamelCase('')).toBe('');
-    });
-
-    it('应该正确处理单字符字符串', () => {
-      expect(toCamelCase('a')).toBe('a');
-    });
-  });
-
-  describe('capitalize 函数', () => {
-    it('应该正确将字符串首字母大写', () => {
-      expect(capitalize('hello')).toBe('Hello');
-      expect(capitalize('hello world')).toBe('Hello world');
-    });
-
-    it('应该正确处理空字符串', () => {
-      expect(capitalize('')).toBe('');
-    });
-
-    it('应该正确处理首字母已经大写的字符串', () => {
-      expect(capitalize('Hello')).toBe('Hello');
-    });
-
-    it('应该正确处理全大写的字符串', () => {
-      expect(capitalize('HELLO')).toBe('HELLO');
-    });
-  });
-
-  describe('randomString 函数', () => {
-    it('应该生成指定长度的随机字符串', () => {
-      expect(randomString(5)).toHaveLength(5);
-      expect(randomString(10)).toHaveLength(10);
-      expect(randomString(0)).toHaveLength(0);
-    });
-
-    it('应该生成只包含指定字符集的字符串', () => {
-      const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-      const str = randomString(20);
-      for (const char of str) {
-        expect(chars).toContain(char);
-      }
-    });
-
-    it('应该生成随机的字符串', () => {
-      const results = new Set();
-      for (let i = 0; i < 10; i++) {
-        results.add(randomString(10));
-      }
-      expect(results.size).toBeGreaterThan(1);
-    });
-  });
-
-  describe('parseStrEmpty 函数', () => {
-    it('应该将undefined、null转换为空字符串', () => {
-      expect(parseStrEmpty(undefined as any)).toBe('');
-      expect(parseStrEmpty(null as any)).toBe('');
-    });
-
-    it('应该将字符串"undefined"、"null"转换为空字符串', () => {
-      expect(parseStrEmpty('undefined')).toBe('');
-      expect(parseStrEmpty('null')).toBe('');
-    });
-
-    it('应该保持正常字符串不变', () => {
-      expect(parseStrEmpty('hello')).toBe('hello');
-      expect(parseStrEmpty('')).toBe('');
-      expect(parseStrEmpty('0')).toBe('0');
-      expect(parseStrEmpty('false')).toBe('false');
-    });
-  });
-
-  describe('getFontLength 函数', () => {
-    it('应该正确计算纯英文字符串的长度', () => {
-      expect(getFontLength('hello')).toBe(5);
-      expect(getFontLength('hello world')).toBe(11);
-    });
-
-    it('应该正确计算包含中文的字符串的长度', () => {
-      expect(getFontLength('你好')).toBe(4);
-      expect(getFontLength('hello你好')).toBe(5 + 4);
-    });
-
-    it('应该正确处理空字符串', () => {
-      expect(getFontLength('')).toBe(0);
-    });
-
-    it('应该正确处理特殊字符', () => {
-      expect(getFontLength('hello@#$%^&*()')).toBe(15);
-      expect(getFontLength('你好@#$%^&*()')).toBe(4 + 10);
-    });
-  });
-
-  describe('getFontWidth 函数', () => {
-    it('应该在有DOM环境时正确计算文字宽度', () => {
-      // 由于这个函数依赖DOM环境，在Node.js测试中会失败
-      // 我们可以添加一个简单的检查
-      if (typeof document !== 'undefined') {
-        expect(getFontWidth('hello')).toBeGreaterThan(0);
-        expect(getFontWidth('hello world')).toBeGreaterThan(getFontWidth('hello'));
-      } else {
-        // 在Node.js环境中跳过这个测试
-        console.log('跳过getFontWidth测试，因为没有DOM环境');
-      }
-    });
-  });
-
-  describe('thousandSign 函数', () => {
-    it('应该正确格式化整数', () => {
-      expect(thousandSign(1234)).toBe('1,234');
-      expect(thousandSign(1234567)).toBe('1,234,567');
-    });
-
-    it('应该正确格式化小数', () => {
-      expect(thousandSign(1234.56)).toBe('1,234.56');
-      expect(thousandSign(1234567.89)).toBe('1,234,567.89');
-    });
-
-    it('应该正确格式化字符串类型的数字', () => {
-      expect(thousandSign('1234')).toBe('1,234');
-      expect(thousandSign('1234.56')).toBe('1,234.56');
-    });
-
-    it('应该正确处理0', () => {
-      expect(thousandSign(0)).toBe('0');
-    });
-
-    it('应该正确处理null和undefined', () => {
-      expect(thousandSign(null as any)).toBe('0');
-      expect(thousandSign(undefined as any)).toBe('0');
-    });
-
-    it('应该正确处理负数', () => {
-      expect(thousandSign(-1234)).toBe('-1,234');
-      expect(thousandSign(-1234.56)).toBe('-1,234.56');
-    });
-  });
-
-  describe('thousandSignZero 函数', () => {
-    it('应该正确格式化并补零', () => {
-      expect(thousandSignZero(1234)).toBe('1,234.00');
-      expect(thousandSignZero(1234.5)).toBe('1,234.50');
-    });
-
-    it('应该使用指定的小数位数', () => {
-      expect(thousandSignZero(1234, 3)).toBe('1,234.000');
-      expect(thousandSignZero(1234.5678, 3)).toBe('1,234.568');
-    });
-
-    it('应该正确处理精度问题', () => {
-      // 测试1.005这个经典的精度问题
-      expect(thousandSignZero(1.005, 2)).toBe('1.01');
-    });
-
-    it('应该正确格式化字符串类型的数字', () => {
-      expect(thousandSignZero('1234')).toBe('1,234.00');
-      expect(thousandSignZero('1234.5')).toBe('1,234.50');
-    });
-
-    it('应该正确处理0', () => {
-      expect(thousandSignZero(0)).toBe('0.00');
-    });
-
-    it('应该正确处理null和undefined', () => {
-      expect(thousandSignZero(null as any)).toBe('0.00');
-      expect(thousandSignZero(undefined as any)).toBe('0.00');
-    });
-
-    it('应该正确处理负数', () => {
-      expect(thousandSignZero(-1234)).toBe('-1,234.00');
-      expect(thousandSignZero(-1234.5)).toBe('-1,234.50');
-    });
-  });
-});

package/tests/utils.test.ts

@@ -1,121 +0,0 @@
-import { debounce, throttle, delay } from '../src/utils/utilFunctions';
-
-describe('工具函数测试', () => {
-  // 清除所有定时器
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  describe('debounce 函数', () => {
-    it('应该在指定时间后只执行一次函数', () => {
-      const mockFn = jest.fn();
-      const debouncedFn = debounce(mockFn, 100);
-
-      // 连续调用三次
-      debouncedFn('arg1', 'arg2');
-      debouncedFn('arg1', 'arg2');
-      debouncedFn('arg1', 'arg2');
-
-      // 快速调用后检查是否有调用
-      expect(mockFn).not.toHaveBeenCalled();
-
-      // 等待指定时间后检查是否只调用了一次
-      jest.advanceTimersByTime(100);
-      expect(mockFn).toHaveBeenCalledTimes(1);
-      expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');
-    });
-
-    it('应该在每次调用后重置定时器', () => {
-      const mockFn = jest.fn();
-      const debouncedFn = debounce(mockFn, 100);
-
-      // 第一次调用
-      debouncedFn('arg1', 'arg2');
-      jest.advanceTimersByTime(50);
-
-      // 第二次调用（重置定时器）
-      debouncedFn('arg1', 'arg2');
-      jest.advanceTimersByTime(50);
-
-      // 检查是否还没有调用
-      expect(mockFn).not.toHaveBeenCalled();
-
-      // 等待剩余时间
-      jest.advanceTimersByTime(50);
-
-      // 检查是否只调用了一次
-      expect(mockFn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('throttle 函数', () => {
-    it('应该在指定时间内只执行一次函数', () => {
-      const mockFn = jest.fn();
-      const throttledFn = throttle(mockFn, 100);
-
-      // 第一次调用
-      throttledFn('arg1', 'arg2');
-      expect(mockFn).toHaveBeenCalledTimes(1);
-
-      // 在限制时间内再次调用
-      throttledFn('arg1', 'arg2');
-      throttledFn('arg1', 'arg2');
-      jest.advanceTimersByTime(50);
-      
-      // 检查是否只调用了一次
-      expect(mockFn).toHaveBeenCalledTimes(1);
-
-      // 等待限制时间后再次调用
-      jest.advanceTimersByTime(50);
-      throttledFn('arg1', 'arg2');
-      
-      // 检查是否调用了第二次
-      expect(mockFn).toHaveBeenCalledTimes(2);
-    });
-
-    it('应该在限制时间后恢复执行', () => {
-      const mockFn = jest.fn();
-      const throttledFn = throttle(mockFn, 100);
-
-      // 第一次调用
-      throttledFn('arg1', 'arg2');
-      expect(mockFn).toHaveBeenCalledTimes(1);
-
-      // 等待限制时间
-      jest.advanceTimersByTime(100);
-
-      // 再次调用
-      throttledFn('arg1', 'arg2');
-      expect(mockFn).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('delay 函数', () => {
-    it('应该在指定时间后resolve', async () => {
-      const start = Date.now();
-      
-      // 使用假定时器
-      const delayPromise = delay(100);
-      
-      // 检查是否还没有resolve
-      expect(delayPromise).toBeInstanceOf(Promise);
-      
-      // 快速检查是否有调用
-      const result = await Promise.race([delayPromise, Promise.resolve('early')]);
-      expect(result).toBe('early');
-      
-      // 使用真实定时器进行测试
-      jest.useRealTimers();
-      const realStart = Date.now();
-      await delay(100);
-      const elapsed = Date.now() - realStart;
-      
-      // 检查是否至少等待了指定时间
-      expect(elapsed).toBeGreaterThanOrEqual(90);
-    });
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2018",
-    "module": "ESNext",
-    "lib": ["ES2018", "dom", "dom.iterable"],
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.spec.ts"]
-}

package/typedoc.json

@@ -1,15 +0,0 @@
-{
-  "$schema": "https://typedoc.org/schema.json",
-  "entryPoints": ["src/index.ts"],
-  "out": "docs",
-  "name": "Function - TypeScript 工具函数库",
-  "includeVersion": true,
-  "readme": "README.md",
-  "theme": "default",
-  "sort": [
-    "source-order"
-  ],
-  "navigationLinks": {
-    "GitHub": "https://github.com/yourusername/function"
-  }
-}