@taicode/common-base 3.7.5 → 3.7.7

package/output/batching-buffer/batching-buffer.test.js

@@ -1,358 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { BatchingBuffer } from './batching-buffer.js';
-describe('BatchingBuffer', () => {
-    let batchProcessor;
-    let itemProcessor;
-    beforeEach(() => {
-        batchProcessor = vi.fn();
-        itemProcessor = vi.fn();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.clearAllMocks();
-    });
-    describe('构造函数', () => {
-        it('应该正确初始化批量处理模式', () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 10,
-                flushInterval: 5000
-            });
-            expect(buffer.size).toBe(0);
-            expect(buffer.isEmpty).toBe(true);
-            expect(buffer.destroyed).toBe(false);
-        });
-        it('应该正确初始化单个处理模式', () => {
-            const buffer = new BatchingBuffer({
-                itemProcessor: itemProcessor,
-                bufferSize: 5,
-                flushInterval: 3000
-            });
-            expect(buffer.size).toBe(0);
-            expect(buffer.isEmpty).toBe(true);
-            expect(buffer.destroyed).toBe(false);
-        });
-        it('应该使用默认配置', () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor
-            });
-            expect(buffer.size).toBe(0);
-            expect(buffer.isEmpty).toBe(true);
-        });
-        it('应该在没有提供处理器时抛出错误', () => {
-            expect(() => {
-                new BatchingBuffer({});
-            }).toThrow('必须提供 batchProcessor 或 itemProcessor 其中之一');
-        });
-        it('应该在同时提供两个处理器时抛出错误', () => {
-            expect(() => {
-                new BatchingBuffer({
-                    batchProcessor: batchProcessor,
-                    itemProcessor: itemProcessor
-                });
-            }).toThrow('只能选择 batchProcessor 或 itemProcessor 中的一个');
-        });
-        it('应该在 bufferSize 无效时抛出错误', () => {
-            expect(() => {
-                new BatchingBuffer({
-                    batchProcessor: batchProcessor,
-                    bufferSize: 0
-                });
-            }).toThrow('bufferSize 必须大于 0');
-            expect(() => {
-                new BatchingBuffer({
-                    batchProcessor: batchProcessor,
-                    bufferSize: -1
-                });
-            }).toThrow('bufferSize 必须大于 0');
-        });
-        it('应该在 flushInterval 无效时抛出错误', () => {
-            expect(() => {
-                new BatchingBuffer({
-                    batchProcessor: batchProcessor,
-                    flushInterval: 0
-                });
-            }).toThrow('flushInterval 必须大于 0');
-            expect(() => {
-                new BatchingBuffer({
-                    batchProcessor: batchProcessor,
-                    flushInterval: -1
-                });
-            }).toThrow('flushInterval 必须大于 0');
-        });
-    });
-    describe('批量处理模式', () => {
-        let buffer;
-        beforeEach(() => {
-            buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 3,
-                flushInterval: 1000
-            });
-        });
-        afterEach(async () => {
-            await buffer.destroy();
-        });
-        it('应该在达到缓冲区大小时触发批量处理', () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(batchProcessor).not.toHaveBeenCalled();
-            buffer.add('item3');
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2', 'item3']);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该在时间间隔到达时触发批量处理', async () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(batchProcessor).not.toHaveBeenCalled();
-            vi.advanceTimersByTime(1000);
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该支持手动刷新', async () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            await buffer.flush();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该支持批量添加数据', () => {
-            buffer.addBatch(['item1', 'item2', 'item3', 'item4', 'item5']);
-            expect(batchProcessor).toHaveBeenCalledTimes(2);
-            expect(batchProcessor).toHaveBeenNthCalledWith(1, ['item1', 'item2', 'item3']);
-            expect(batchProcessor).toHaveBeenNthCalledWith(2, ['item4', 'item5']);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该正确处理处理器异常', () => {
-            const error = new Error('处理失败');
-            batchProcessor.mockImplementationOnce(() => {
-                throw error;
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(() => {
-                buffer.add('item3');
-            }).toThrow('处理失败');
-            // 数据应该重新放回缓冲区
-            expect(buffer.size).toBe(3);
-        });
-    });
-    describe('单个处理模式', () => {
-        let buffer;
-        beforeEach(() => {
-            buffer = new BatchingBuffer({
-                itemProcessor: itemProcessor,
-                bufferSize: 3,
-                flushInterval: 1000
-            });
-        });
-        afterEach(async () => {
-            await buffer.destroy();
-        });
-        it('应该在达到缓冲区大小时触发单个处理', () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(itemProcessor).not.toHaveBeenCalled();
-            buffer.add('item3');
-            expect(itemProcessor).toHaveBeenCalledTimes(3);
-            expect(itemProcessor).toHaveBeenNthCalledWith(1, 'item1');
-            expect(itemProcessor).toHaveBeenNthCalledWith(2, 'item2');
-            expect(itemProcessor).toHaveBeenNthCalledWith(3, 'item3');
-            expect(buffer.size).toBe(0);
-        });
-        it('应该在时间间隔到达时触发单个处理', async () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(itemProcessor).not.toHaveBeenCalled();
-            vi.advanceTimersByTime(1000);
-            await vi.runAllTimersAsync();
-            expect(itemProcessor).toHaveBeenCalledTimes(2);
-            expect(itemProcessor).toHaveBeenNthCalledWith(1, 'item1');
-            expect(itemProcessor).toHaveBeenNthCalledWith(2, 'item2');
-            expect(buffer.size).toBe(0);
-        });
-        it('应该正确处理单个处理器异常', () => {
-            const error = new Error('单个处理失败');
-            itemProcessor.mockImplementationOnce(() => {
-                throw error;
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(() => {
-                buffer.add('item3');
-            }).toThrow('单个处理失败');
-            // 数据应该重新放回缓冲区
-            expect(buffer.size).toBe(3);
-        });
-    });
-    describe('缓冲区状态', () => {
-        let buffer;
-        beforeEach(() => {
-            buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 2000
-            });
-        });
-        afterEach(async () => {
-            await buffer.destroy();
-        });
-        it('应该正确报告缓冲区大小', () => {
-            expect(buffer.size).toBe(0);
-            expect(buffer.isEmpty).toBe(true);
-            buffer.add(1);
-            expect(buffer.size).toBe(1);
-            expect(buffer.isEmpty).toBe(false);
-            buffer.add(2);
-            buffer.add(3);
-            expect(buffer.size).toBe(3);
-            expect(buffer.isEmpty).toBe(false);
-        });
-        it('应该正确报告距离上次刷新的时间', async () => {
-            const startTime = Date.now();
-            buffer.add(1);
-            vi.advanceTimersByTime(500);
-            expect(buffer.timeSinceLastFlush).toBeGreaterThanOrEqual(500);
-            await buffer.flush();
-            expect(buffer.timeSinceLastFlush).toBeLessThan(100);
-        });
-    });
-    describe('销毁功能', () => {
-        let buffer;
-        beforeEach(() => {
-            buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 1000
-            });
-        });
-        it('应该在销毁时处理剩余数据', async () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            await buffer.destroy();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            expect(buffer.destroyed).toBe(true);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该在销毁时丢弃剩余数据（如果指定）', async () => {
-            buffer.add('item1');
-            buffer.add('item2');
-            await buffer.destroy(false);
-            expect(batchProcessor).not.toHaveBeenCalled();
-            expect(buffer.destroyed).toBe(true);
-            expect(buffer.size).toBe(0);
-        });
-        it('应该在销毁后拒绝添加新数据', async () => {
-            await buffer.destroy();
-            expect(() => {
-                buffer.add('item1');
-            }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
-            expect(() => {
-                buffer.addBatch(['item1', 'item2']);
-            }).toThrow('BatchingBuffer 已被销毁，不能添加新数据');
-        });
-        it('应该支持重复销毁', async () => {
-            await buffer.destroy();
-            await buffer.destroy();
-            expect(buffer.destroyed).toBe(true);
-        });
-    });
-    describe('自动刷新配置', () => {
-        it('应该在 autoFlush=false 时不自动启动定时器', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 5,
-                flushInterval: 1000,
-                autoFlush: false
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            vi.advanceTimersByTime(2000);
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).not.toHaveBeenCalled();
-            expect(buffer.size).toBe(2);
-            await buffer.destroy();
-        });
-        it('应该在 autoFlush=false 时仍支持基于大小的触发', async () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 2,
-                flushInterval: 1000,
-                autoFlush: false
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            await buffer.destroy();
-        });
-    });
-    describe('复杂数据类型', () => {
-        let buffer;
-        beforeEach(() => {
-            buffer = new BatchingBuffer({
-                batchProcessor: batchProcessor,
-                bufferSize: 2,
-                flushInterval: 1000
-            });
-        });
-        afterEach(async () => {
-            await buffer.destroy();
-        });
-        it('应该正确处理复杂对象', async () => {
-            const data1 = { id: 1, name: 'test1' };
-            const data2 = { id: 2, name: 'test2' };
-            buffer.add(data1);
-            buffer.add(data2);
-            await vi.runAllTimersAsync();
-            expect(batchProcessor).toHaveBeenCalledTimes(1);
-            expect(batchProcessor).toHaveBeenCalledWith([data1, data2]);
-        });
-    });
-    describe('异步处理器', () => {
-        let asyncBatchProcessor;
-        let asyncItemProcessor;
-        beforeEach(() => {
-            asyncBatchProcessor = vi.fn().mockImplementation(async (items) => {
-                await new Promise(resolve => setTimeout(resolve, 100));
-                return `处理了 ${items.length} 个项目`;
-            });
-            asyncItemProcessor = vi.fn().mockImplementation(async (item) => {
-                await new Promise(resolve => setTimeout(resolve, 50));
-                return `处理了项目: ${item}`;
-            });
-        });
-        it('应该正确处理异步批量处理器', () => {
-            const buffer = new BatchingBuffer({
-                batchProcessor: asyncBatchProcessor,
-                bufferSize: 2,
-                flushInterval: 1000
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(asyncBatchProcessor).toHaveBeenCalledTimes(1);
-            expect(asyncBatchProcessor).toHaveBeenCalledWith(['item1', 'item2']);
-            buffer.destroy();
-        });
-        it('应该正确处理异步单个处理器', () => {
-            const buffer = new BatchingBuffer({
-                itemProcessor: asyncItemProcessor,
-                bufferSize: 2,
-                flushInterval: 1000
-            });
-            buffer.add('item1');
-            buffer.add('item2');
-            expect(asyncItemProcessor).toHaveBeenCalledTimes(2);
-            expect(asyncItemProcessor).toHaveBeenNthCalledWith(1, 'item1');
-            expect(asyncItemProcessor).toHaveBeenNthCalledWith(2, 'item2');
-            buffer.destroy();
-        });
-    });
-});

package/output/batching-buffer/index.d.ts

@@ -1,3 +0,0 @@
-export { BatchingBuffer } from './batching-buffer.js';
-export type { BatchingBufferOptions } from './batching-buffer.js';
-//# sourceMappingURL=index.d.ts.map

package/output/batching-buffer/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/batching-buffer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA"}

package/output/batching-buffer/index.js

@@ -1 +0,0 @@
-export { BatchingBuffer } from './batching-buffer.js';

package/output/catch/catch.d.ts

@@ -1,46 +0,0 @@
-type CatchType<F extends () => unknown> = F extends () => PromiseLike<infer R> ? R : F extends () => infer R ? R : never;
-/**
- * 成功结果类型
- * 只包含 value 字段，error 字段为 undefined
- */
-export interface CatchSuccess<T> {
-    value: T;
-}
-/**
- * 失败结果类型
- * error 字段类型永远为 unknown（或用户自定义），这样最安全，防止误用。
- * 推荐在 error 分支内用 instanceof/typeof 等类型守卫自行收窄类型。
- */
-export interface CatchFailure<E> {
-    error: E;
-    context: unknown;
-}
-/**
- * 捕获结果联合类型，使用判别联合类型以支持类型守卫
- *
- * 设计说明：
- * - 通过 isError 方法进行类型守卫，推荐始终用 result.isError() 判断是否为错误分支。
- * - isError 方法为 function 写法（而非箭头函数），以支持类型谓词，且 this 不会被转移。
- * - 不建议直接用 error !== undefined 判断错误分支，该方式依赖 error 的值，推荐统一用 isError()。
- */
-export type CatchResult<T, E = unknown> = (CatchSuccess<T> | CatchFailure<E>) & {
-    /**
-     * 类型守卫方法，判断当前对象是否为 CatchFailure。
-     * function 写法，返回类型谓词，保证类型收窄。
-     * 推荐用法：if (result.isError()) { ... }
-     */
-    isError: (this: unknown) => this is CatchFailure<E>;
-};
-/**
- * 通用错误捕获函数，支持 PromiseLike 和函数执行
- * 返回 { value, error } 的对象格式，便于类型判断
- *
- * 设计说明：
- * - 支持同步/异步/thenable 场景
- * - 推荐通过 isError() 进行类型守卫
- * - error 字段类型为 unknown，需用户自行收窄
- */
-export declare function catchIt<T, E = unknown>(input: PromiseLike<T>): Promise<CatchResult<T, E>>;
-export declare function catchIt<F extends () => unknown, E = unknown>(input: F): Promise<CatchResult<CatchType<F>, E>>;
-export {};
-//# sourceMappingURL=catch.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"catch.d.ts","sourceRoot":"","sources":["../../source/catch/catch.ts"],"names":[],"mappings":"AAMA,KAAK,SAAS,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,SAAS,MAAM,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAExH;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;CACT;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,CAAA;IACR,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG;IAC9E;;;;OAIG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,CAAA;CACpD,CAAA;AA0BD;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;AAChG,wBAAsB,OAAO,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/output/catch/catch.js

@@ -1,48 +0,0 @@
-// 辅助函数：检查是否为 PromiseLike
-function isPromiseLike(value) {
-    return value != null && typeof value === 'object' && 'then' in value && typeof value.then === 'function';
-}
-/**
- * 构造成功结果对象
- * isError 始终返回 false
- */
-function createSuccess(value) {
-    return {
-        value,
-        error: undefined,
-        isError() { return false; }
-    };
-}
-/**
- * 构造失败结果对象
- * isError 始终返回 true
- */
-function createFailure(error) {
-    return {
-        error,
-        value: undefined,
-        isError() { return true; }
-    };
-}
-export async function catchIt(input) {
-    try {
-        if (isPromiseLike(input)) {
-            const result = await Promise.resolve(input);
-            return createSuccess(result);
-        }
-        else if (typeof input === 'function') {
-            const result = input();
-            if (isPromiseLike(result)) {
-                return catchIt(result);
-            }
-            else {
-                return createSuccess(result);
-            }
-        }
-    }
-    catch (error) {
-        return createFailure(error);
-    }
-    // 理论上不会到达这里，兜底类型安全
-    return createFailure(new Error('Unexpected input type'));
-}

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

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

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

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

package/output/catch/catch.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { catchIt } from './catch.js';
-describe('catchIt', () => {
-    it('同步函数返回值应为 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(() => 123);
-        expect(result.value).toBe(123);
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('异步函数返回值应为 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(async () => 456);
-        expect(result.value).toBe(456);
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('同步抛出异常时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('fail');
-        const result = await catchIt(() => { throw error; });
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-    it('异步抛出异常时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('fail-async');
-        const result = await catchIt(() => Promise.reject(error));
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-    it('PromiseLike resolve 时应返回 value，error 为 undefined，isError 为 false', async () => {
-        const result = await catchIt(Promise.resolve('ok'));
-        expect(result.value).toBe('ok');
-        expect(result.error).toBeUndefined();
-        expect(result.isError()).toBe(false);
-    });
-    it('PromiseLike reject 时应返回 error，value 为 undefined，isError 为 true', async () => {
-        const error = new Error('promise-fail');
-        const result = await catchIt(Promise.reject(error));
-        expect(result.value).toBeUndefined();
-        expect(result.error).toBe(error);
-        expect(result.isError()).toBe(true);
-    });
-});

package/output/catch/index.d.ts

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

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

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

package/output/catch/index.js

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

package/output/color/color.d.ts

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

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

@@ -1,56 +0,0 @@
-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);
-        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

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

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

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