@taicode/common-base 1.1.0 → 1.1.2

package/output/catch/catch.d.ts

@@ -0,0 +1,9 @@
+type CatchType<F extends () => unknown> = F extends () => Promise<infer R> ? R : F extends () => infer R ? R : never;
+/**
+ * 通用错误捕获函数，支持 Promise 和函数执行
+ * 将结果转换成 [result, error] 的形式
+ */
+export declare function catchIt<T>(input: Promise<T>): Promise<[T | undefined, unknown]>;
+export declare function catchIt<F extends () => unknown>(input: F): Promise<[CatchType<F> | undefined, unknown]>;
+export {};
+//# sourceMappingURL=catch.d.ts.map

package/output/catch/catch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEpH;;;GAGG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AACtF,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA"}

package/output/catch/catch.js

@@ -0,0 +1,26 @@
+export async function catchIt(input) {
+    const returned = [undefined, undefined];
+    try {
+        if (input instanceof Promise) {
+            // 处理 Promise
+            await input
+                .then((result) => (returned[0] = result))
+                .catch((error) => (returned[1] = error));
+        }
+        else if (typeof input === 'function') {
+            // 处理函数
+            const result = input();
+            if (result instanceof Promise) {
+                // 如果函数返回 Promise，递归调用
+                return catchIt(result);
+            }
+            else {
+                returned[0] = result;
+            }
+        }
+    }
+    catch (error) {
+        returned[1] = error;
+    }
+    return returned;
+}

package/output/catch/catch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=catch.test.d.ts.map

package/output/catch/catch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catch.test.d.ts","sourceRoot":"","sources":["../../source/catch/catch.test.ts"],"names":[],"mappings":""}

package/output/catch/catch.test.js

@@ -0,0 +1,258 @@
+import { describe, it, expect, vi } from 'vitest';
+import { catchIt } from './catch';
+describe('catchIt', () => {
+    describe('处理 Promise', () => {
+        it('应该正确处理成功的 Promise', async () => {
+            const successValue = 'success';
+            const promise = Promise.resolve(successValue);
+            const [result, error] = await catchIt(promise);
+            expect(result).toBe(successValue);
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理失败的 Promise', async () => {
+            const errorValue = new Error('test error');
+            const promise = Promise.reject(errorValue);
+            const [result, error] = await catchIt(promise);
+            expect(result).toBeUndefined();
+            expect(error).toBe(errorValue);
+        });
+        it('应该正确处理返回不同数据类型的 Promise', async () => {
+            // 数字类型
+            const [numberResult, numberError] = await catchIt(Promise.resolve(42));
+            expect(numberResult).toBe(42);
+            expect(numberError).toBeUndefined();
+            // 对象类型
+            const obj = { key: 'value' };
+            const [objectResult, objectError] = await catchIt(Promise.resolve(obj));
+            expect(objectResult).toBe(obj);
+            expect(objectError).toBeUndefined();
+            // 数组类型
+            const arr = [1, 2, 3];
+            const [arrayResult, arrayError] = await catchIt(Promise.resolve(arr));
+            expect(arrayResult).toBe(arr);
+            expect(arrayError).toBeUndefined();
+            // null 和 undefined
+            const [nullResult, nullError] = await catchIt(Promise.resolve(null));
+            expect(nullResult).toBeNull();
+            expect(nullError).toBeUndefined();
+            const [undefinedResult, undefinedError] = await catchIt(Promise.resolve(undefined));
+            expect(undefinedResult).toBeUndefined();
+            expect(undefinedError).toBeUndefined();
+        });
+        it('应该正确处理不同类型的错误', async () => {
+            // Error 对象
+            const error = new Error('test error');
+            const [, caughtError1] = await catchIt(Promise.reject(error));
+            expect(caughtError1).toBe(error);
+            // 字符串错误
+            const [, caughtError2] = await catchIt(Promise.reject('string error'));
+            expect(caughtError2).toBe('string error');
+            // 数字错误
+            const [, caughtError3] = await catchIt(Promise.reject(404));
+            expect(caughtError3).toBe(404);
+            // 对象错误
+            const objError = { code: 500, message: 'server error' };
+            const [, caughtError4] = await catchIt(Promise.reject(objError));
+            expect(caughtError4).toBe(objError);
+        });
+    });
+    describe('处理同步函数', () => {
+        it('应该正确处理返回值的同步函数', async () => {
+            const syncFn = () => 'sync result';
+            const [result, error] = await catchIt(syncFn);
+            expect(result).toBe('sync result');
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理抛出错误的同步函数', async () => {
+            const errorValue = new Error('sync error');
+            const syncFn = () => {
+                throw errorValue;
+            };
+            const [result, error] = await catchIt(syncFn);
+            expect(result).toBeUndefined();
+            expect(error).toBe(errorValue);
+        });
+        it('应该正确处理返回不同数据类型的同步函数', async () => {
+            // 数字
+            const [numberResult] = await catchIt(() => 42);
+            expect(numberResult).toBe(42);
+            // 字符串
+            const [stringResult] = await catchIt(() => 'hello');
+            expect(stringResult).toBe('hello');
+            // 对象
+            const obj = { test: true };
+            const [objectResult] = await catchIt(() => obj);
+            expect(objectResult).toBe(obj);
+            // 数组
+            const arr = [1, 2, 3];
+            const [arrayResult] = await catchIt(() => arr);
+            expect(arrayResult).toBe(arr);
+            // boolean
+            const [boolResult] = await catchIt(() => true);
+            expect(boolResult).toBe(true);
+            // null
+            const [nullResult] = await catchIt(() => null);
+            expect(nullResult).toBeNull();
+            // undefined
+            const [undefinedResult] = await catchIt(() => undefined);
+            expect(undefinedResult).toBeUndefined();
+        });
+        it('应该确保同步函数被调用', async () => {
+            const mockFn = vi.fn(() => 'test');
+            await catchIt(mockFn);
+            expect(mockFn).toHaveBeenCalledOnce();
+        });
+    });
+    describe('处理返回 Promise 的函数', () => {
+        it('应该正确处理返回成功 Promise 的函数', async () => {
+            const asyncFn = () => Promise.resolve('async result');
+            const [result, error] = await catchIt(asyncFn);
+            expect(result).toBe('async result');
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理返回失败 Promise 的函数', async () => {
+            const errorValue = new Error('async error');
+            const asyncFn = () => Promise.reject(errorValue);
+            const [result, error] = await catchIt(asyncFn);
+            expect(result).toBeUndefined();
+            expect(error).toBe(errorValue);
+        });
+        it('应该正确处理返回不同数据类型 Promise 的函数', async () => {
+            // 数字
+            const [numberResult] = await catchIt(() => Promise.resolve(123));
+            expect(numberResult).toBe(123);
+            // 对象
+            const obj = { async: true };
+            const [objectResult] = await catchIt(() => Promise.resolve(obj));
+            expect(objectResult).toBe(obj);
+        });
+        it('应该确保返回 Promise 的函数被调用', async () => {
+            const mockAsyncFn = vi.fn(() => Promise.resolve('test'));
+            await catchIt(mockAsyncFn);
+            expect(mockAsyncFn).toHaveBeenCalledOnce();
+        });
+    });
+    describe('边界情况', () => {
+        it('应该正确处理函数中抛出的同步错误', async () => {
+            const syncError = new Error('sync throw error');
+            const errorFn = () => {
+                throw syncError;
+            };
+            const [result, error] = await catchIt(errorFn);
+            expect(result).toBeUndefined();
+            expect(error).toBe(syncError);
+        });
+        it('应该正确处理 Promise 链中的错误', async () => {
+            const chainError = new Error('chain error');
+            const promise = Promise.resolve()
+                .then(() => {
+                throw chainError;
+            });
+            const [result, error] = await catchIt(promise);
+            expect(result).toBeUndefined();
+            expect(error).toBe(chainError);
+        });
+        it('应该正确处理延迟的 Promise', async () => {
+            const delayedPromise = new Promise((resolve) => {
+                setTimeout(() => resolve('delayed result'), 10);
+            });
+            const [result, error] = await catchIt(delayedPromise);
+            expect(result).toBe('delayed result');
+            expect(error).toBeUndefined();
+        });
+        it('应该正确处理返回 falsy 值的函数', async () => {
+            // 返回 0
+            const [zeroResult] = await catchIt(() => 0);
+            expect(zeroResult).toBe(0);
+            // 返回空字符串
+            const [emptyStringResult] = await catchIt(() => '');
+            expect(emptyStringResult).toBe('');
+            // 返回 false
+            const [falseResult] = await catchIt(() => false);
+            expect(falseResult).toBe(false);
+            // 返回 null
+            const [nullResult] = await catchIt(() => null);
+            expect(nullResult).toBeNull();
+            // 返回 undefined
+            const [undefinedResult] = await catchIt(() => undefined);
+            expect(undefinedResult).toBeUndefined();
+        });
+    });
+    describe('类型安全性', () => {
+        it('应该保持正确的类型推导 - Promise', async () => {
+            // TypeScript 编译时应该能正确推导类型
+            const stringPromise = Promise.resolve('string');
+            const [stringResult] = await catchIt(stringPromise);
+            // stringResult 应该被推导为 string | undefined
+            const numberPromise = Promise.resolve(42);
+            const [numberResult] = await catchIt(numberPromise);
+            // numberResult 应该被推导为 number | undefined
+            // 运行时验证
+            expect(typeof stringResult).toBe('string');
+            expect(typeof numberResult).toBe('number');
+        });
+        it('应该保持正确的类型推导 - 同步函数', async () => {
+            const stringFn = () => 'hello';
+            const [stringResult] = await catchIt(stringFn);
+            const numberFn = () => 42;
+            const [numberResult] = await catchIt(numberFn);
+            // 运行时验证
+            expect(typeof stringResult).toBe('string');
+            expect(typeof numberResult).toBe('number');
+        });
+        it('应该保持正确的类型推导 - 异步函数', async () => {
+            const asyncStringFn = () => Promise.resolve('async hello');
+            const [asyncStringResult] = await catchIt(asyncStringFn);
+            const asyncNumberFn = () => Promise.resolve(100);
+            const [asyncNumberResult] = await catchIt(asyncNumberFn);
+            // 运行时验证
+            expect(typeof asyncStringResult).toBe('string');
+            expect(typeof asyncNumberResult).toBe('number');
+        });
+    });
+    describe('实际使用场景', () => {
+        it('应该适用于 API 调用场景', async () => {
+            // 模拟成功的 API 调用
+            const mockApiCall = () => Promise.resolve({
+                data: { id: 1, name: 'test' },
+                status: 200
+            });
+            const [result, error] = await catchIt(mockApiCall);
+            expect(result).toEqual({ data: { id: 1, name: 'test' }, status: 200 });
+            expect(error).toBeUndefined();
+            // 模拟失败的 API 调用
+            const failedApiCall = () => Promise.reject({
+                status: 404,
+                message: 'Not Found'
+            });
+            const [failedResult, apiError] = await catchIt(failedApiCall);
+            expect(failedResult).toBeUndefined();
+            expect(apiError).toEqual({ status: 404, message: 'Not Found' });
+        });
+        it('应该适用于文件操作场景', async () => {
+            // 模拟成功的文件读取
+            const mockFileRead = () => Promise.resolve('file content');
+            const [content, error] = await catchIt(mockFileRead);
+            expect(content).toBe('file content');
+            expect(error).toBeUndefined();
+            // 模拟失败的文件读取
+            const failedFileRead = () => Promise.reject(new Error('File not found'));
+            const [failedContent, fileError] = await catchIt(failedFileRead);
+            expect(failedContent).toBeUndefined();
+            expect(fileError).toBeInstanceOf(Error);
+            expect(fileError.message).toBe('File not found');
+        });
+        it('应该适用于数据解析场景', async () => {
+            // 模拟成功的 JSON 解析
+            const jsonParseSuccess = () => JSON.parse('{"key": "value"}');
+            const [parsed, parseError] = await catchIt(jsonParseSuccess);
+            expect(parsed).toEqual({ key: 'value' });
+            expect(parseError).toBeUndefined();
+            // 模拟失败的 JSON 解析
+            const jsonParseFailed = () => JSON.parse('invalid json');
+            const [failedParsed, jsonError] = await catchIt(jsonParseFailed);
+            expect(failedParsed).toBeUndefined();
+            expect(jsonError).toBeInstanceOf(SyntaxError);
+        });
+    });
+});

package/output/catch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './catch';
+//# sourceMappingURL=index.d.ts.map

package/output/catch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/catch/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/output/catch/index.js

@@ -0,0 +1 @@
+export * from './catch';

package/output/color/color.d.ts

@@ -0,0 +1,6 @@
+type SeedValue = number | string | null;
+export declare function getRandomColor(seed: SeedValue): (offset: SeedValue, range?: number) => string;
+export declare function getRandomColors(seed: SeedValue, interval: number, count: number): string[];
+export declare function interpolateColors(color1: string, color2: string, steps: number): (index: number) => string;
+export type { SeedValue };
+//# sourceMappingURL=color.d.ts.map

package/output/color/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../source/color/color.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;AAcvC,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,IAMpC,QAAQ,SAAS,EAAE,QAAO,MAAY,YAO/C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAO/E;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAgBrE,OAAO,MAAM,KAAG,MAAM,CAgB/B;AAED,YAAY,EAAE,SAAS,EAAE,CAAA"}

package/output/color/color.js

@@ -0,0 +1,57 @@
+function normalizeSeed(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.split('').reduce((sum, char) => sum + char.charCodeAt(0), 0);
+    }
+    return 0;
+}
+export function getRandomColor(seed) {
+    // 使用 asciiSum 生成 HSL 值
+    const hue = normalizeSeed(seed) % 360; // 色相（0-360）
+    const saturation = 80; // 饱和度（0-100）
+    const lightness = 45; // 明度（0-100）
+    return (offset, range = 360) => {
+        const normalizedOffset = normalizeSeed(offset);
+        console.log('normalizedOffset', offset, normalizedOffset);
+        const finalHue = (hue + normalizedOffset) % range;
+        return `hsl(${finalHue}, ${saturation}%, ${lightness}%)`;
+    };
+}
+export function getRandomColors(seed, interval, count) {
+    const colors = [];
+    const colorFunc = getRandomColor(seed);
+    for (let i = 0; i < count; i++) {
+        colors.push(colorFunc(i * interval));
+    }
+    return colors;
+}
+export function interpolateColors(color1, color2, steps) {
+    function parseHSL(color) {
+        const match = color.match(/hsl\((\d+),\s*(\d+)%?,\s*(\d+)%?\)/);
+        if (!match) {
+            throw new Error(`Invalid HSL color: ${color}`);
+        }
+        return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
+    }
+    function hslToString(h, s, l) {
+        return `hsl(${Math.round(h)}, ${Math.round(s)}%, ${Math.round(l)}%)`;
+    }
+    const [h1, s1, l1] = parseHSL(color1);
+    const [h2, s2, l2] = parseHSL(color2);
+    return (index) => {
+        if (index < 0 || index > steps) {
+            throw new Error(`Index out of bounds: ${index}. Valid range is 0 to ${steps}.`);
+        }
+        // 当steps为0时，直接返回第一个颜色
+        if (steps === 0) {
+            return hslToString(h1, s1, l1);
+        }
+        const ratio = index / steps;
+        const h = h1 + (h2 - h1) * ratio;
+        const s = s1 + (s2 - s1) * ratio;
+        const l = l1 + (l2 - l1) * ratio;
+        return hslToString(h, s, l);
+    };
+}

package/output/color/color.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=color.test.d.ts.map

package/output/color/color.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.test.d.ts","sourceRoot":"","sources":["../../source/color/color.test.ts"],"names":[],"mappings":""}

package/output/color/color.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getRandomColor, getRandomColors, interpolateColors } from './color';
+describe('getRandomColor 函数', () => {
+    // Mock console.log to avoid noise in tests
+    beforeEach(() => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('应该为相同的种子生成一致的颜色', () => {
+        const colorFunc = getRandomColor(123);
+        const color1 = colorFunc(0);
+        const color2 = colorFunc(0);
+        expect(color1).toBe(color2);
+        expect(color1).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
+    });
+    it('应该处理数字种子', () => {
+        const colorFunc = getRandomColor(42);
+        const color = colorFunc(0);
+        expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
+    });
+    it('应该处理字符串种子', () => {
+        const colorFunc = getRandomColor('test');
+        const color = colorFunc(0);
+        expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
+    });
+    it('应该处理 null 种子', () => {
+        const colorFunc = getRandomColor(null);
+        const color = colorFunc(0);
+        expect(color).toBe('hsl(0, 80%, 45%)');
+    });
+    it('应该为不同的偏移量生成不同的颜色', () => {
+        const colorFunc = getRandomColor(123);
+        const color1 = colorFunc(0);
+        const color2 = colorFunc(100);
+        expect(color1).not.toBe(color2);
+    });
+    it('应该遵守自定义范围参数', () => {
+        const colorFunc = getRandomColor(123);
+        const color = colorFunc(50, 180);
+        // 解析HSL值
+        const match = color.match(/hsl\((\d+), 80%, 45%\)/);
+        expect(match).toBeTruthy();
+        const hue = parseInt(match[1]);
+        expect(hue).toBeLessThan(180);
+    });
+});
+describe('getRandomColors 函数', () => {
+    beforeEach(() => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('应该生成指定数量的颜色', () => {
+        const colors = getRandomColors(123, 50, 5);
+        expect(colors).toHaveLength(5);
+        colors.forEach(color => {
+            expect(color).toMatch(/^hsl\(\d+, 80%, 45%\)$/);
+        });
+    });
+    it('应该以间隔生成不同的颜色', () => {
+        const colors = getRandomColors(123, 50, 3);
+        expect(colors[0]).not.toBe(colors[1]);
+        expect(colors[1]).not.toBe(colors[2]);
+    });
+    it('应该处理零计数', () => {
+        const colors = getRandomColors(123, 50, 0);
+        expect(colors).toHaveLength(0);
+    });
+});
+describe('interpolateColors 函数', () => {
+    it('应该在两个 HSL 颜色之间插值', () => {
+        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 2);
+        const color0 = interpolate(0);
+        const color1 = interpolate(1);
+        const color2 = interpolate(2);
+        expect(color0).toBe('hsl(0, 80%, 45%)');
+        expect(color1).toBe('hsl(60, 80%, 45%)');
+        expect(color2).toBe('hsl(120, 80%, 45%)');
+    });
+    it('应该处理不同的饱和度和明度值', () => {
+        const interpolate = interpolateColors('hsl(0, 50%, 30%)', 'hsl(0, 90%, 70%)', 1);
+        const color0 = interpolate(0);
+        const color1 = interpolate(1);
+        expect(color0).toBe('hsl(0, 50%, 30%)');
+        expect(color1).toBe('hsl(0, 90%, 70%)');
+    });
+    it('应该为无效的 HSL 颜色格式抛出错误', () => {
+        expect(() => {
+            interpolateColors('invalid-color', 'hsl(120, 80%, 45%)', 2);
+        }).toThrow('Invalid HSL color: invalid-color');
+    });
+    it('应该为索引超出边界抛出错误', () => {
+        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 2);
+        expect(() => {
+            interpolate(-1);
+        }).toThrow('Index out of bounds: -1. Valid range is 0 to 2.');
+        expect(() => {
+            interpolate(3);
+        }).toThrow('Index out of bounds: 3. Valid range is 0 to 2.');
+    });
+    it('应该处理零步骤', () => {
+        const interpolate = interpolateColors('hsl(0, 80%, 45%)', 'hsl(120, 80%, 45%)', 0);
+        const color = interpolate(0);
+        // 当步骤为0时，应该返回第一个颜色
+        expect(color).toBe('hsl(0, 80%, 45%)');
+    });
+});

package/output/color/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color';
+//# sourceMappingURL=index.d.ts.map

package/output/color/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/color/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA"}

package/output/color/index.js

@@ -0,0 +1 @@
+export * from './color';

package/output/debounce/debounce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 防抖装饰器 - 基于 TC39 Stage 3 Decorators 提案
+ * 在最后一次调用后等待指定时间才执行函数
+ */
+export declare function debounceFn<T extends (...args: any[]) => any>(fn: T, wait: number): T;
+export declare function debounce<T extends (...args: any[]) => any>(wait: number): (originalMethod: T, context: ClassMethodDecoratorContext) => T;
+//# sourceMappingURL=debounce.d.ts.map

package/output/debounce/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../source/debounce/debounce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,wBAAgB,UAAU,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1D,EAAE,EAAE,CAAC,EACL,IAAI,EAAE,MAAM,GACX,CAAC,CAmBH;AAGD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,EAAE,MAAM,IACrD,gBAAgB,CAAC,EAAE,SAAS,2BAA2B,KAAG,CAAC,CAS7E"}

package/output/debounce/debounce.js

@@ -0,0 +1,36 @@
+/**
+ * 防抖装饰器 - 基于 TC39 Stage 3 Decorators 提案
+ * 在最后一次调用后等待指定时间才执行函数
+ */
+// 通用防抖函数
+export function debounceFn(fn, wait) {
+    let timeout = null;
+    function debounced(...args) {
+        return new Promise((resolve, reject) => {
+            if (timeout)
+                clearTimeout(timeout);
+            timeout = setTimeout(async () => {
+                try {
+                    const result = await Promise.resolve(fn.apply(this, args));
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, wait);
+        });
+    }
+    return debounced;
+}
+// TC39 Stage 3 装饰器实现
+export function debounce(wait) {
+    return function (originalMethod, context) {
+        // 每个实例独立
+        context.addInitializer(function () {
+            const self = this;
+            const debouncedMethod = debounceFn(originalMethod.bind(self), wait);
+            self[context.name] = debouncedMethod;
+        });
+        return originalMethod;
+    };
+}

package/output/debounce/debounce.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debounce.test.d.ts.map

package/output/debounce/debounce.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.test.d.ts","sourceRoot":"","sources":["../../source/debounce/debounce.test.ts"],"names":[],"mappings":""}