@taicode/common-base 3.7.4 → 3.7.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TaicodeLabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-base",
-  "version": "3.7.4",
+  "version": "3.7.7",
   "author": "Alain",
   "license": "ISC",
   "description": "",
@@ -20,17 +20,16 @@
       "default": "./output/*/index.js"
     }
   },
-  "scripts": {
-    "test": "vitest run",
-    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build",
-    "dev": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --watch"
-  },
   "files": [
     "output"
   ],
   "devDependencies": {
     "vitest": "^3.2.4",
     "mobx": "^6.15.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json",
+    "dev": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --watch"
   }
-}
+}

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

@@ -1,133 +0,0 @@
-/**
- * 批处理缓冲区配置选项
- */
-export interface BatchingBufferOptions<T> {
-    /**
-     * 批处理模式：批量处理器
-     */
-    batchProcessor?: (items: T[]) => Promise<void> | void;
-    /**
-     * 单个处理模式：单个处理器
-     */
-    itemProcessor?: (item: T) => Promise<void> | void;
-    /**
-     * 缓冲区大小限制，达到此数量时触发处理
-     * @default 100
-     */
-    bufferSize?: number;
-    /**
-     * 时间间隔（毫秒），距离上次处理超过此时间时触发处理
-     * @default 5000
-     */
-    flushInterval?: number;
-    /**
-     * 是否在添加项目时立即启动定时器
-     * @default true
-     */
-    autoFlush?: boolean;
-}
-/**
- * 批处理缓冲区
- *
- * 提供数据暂存和批量/单个处理功能的管理对象。
- * 当缓冲区达到指定数量或距离上次处理达到一定时间时，
- * 自动调用处理方法进行数据消费。
- *
- * @example
- * ```typescript
- * // 批量处理模式
- * const buffer = new BatchingBuffer({
- *   batchProcessor: async (items) => {
- *     console.log('批量处理:', items)
- *     await saveToDatabase(items)
- *   },
- *   bufferSize: 10,
- *   flushInterval: 5000
- * })
- *
- * // 单个处理模式
- * const buffer = new BatchingBuffer({
- *   itemProcessor: async (item) => {
- *     console.log('单个处理:', item)
- *     await saveToDatabase([item])
- *   },
- *   bufferSize: 1,
- *   flushInterval: 1000
- * })
- *
- * // 添加数据
- * buffer.add('data1')
- * buffer.add('data2')
- *
- * // 手动刷新
- * await buffer.flush()
- *
- * // 销毁
- * buffer.destroy()
- * ```
- */
-export declare class BatchingBuffer<T> {
-    private buffer;
-    private timer;
-    private isDestroyed;
-    private lastFlushTime;
-    private readonly batchProcessor?;
-    private readonly itemProcessor?;
-    private readonly bufferSize;
-    private readonly flushInterval;
-    private readonly autoFlush;
-    constructor(options: BatchingBufferOptions<T>);
-    /**
-     * 添加数据到缓冲区
-     * @param item 要添加的数据项
-     */
-    add(item: T): void;
-    /**
-     * 批量添加数据到缓冲区
-     * @param items 要添加的数据项数组
-     */
-    addBatch(items: T[]): void;
-    /**
-     * 手动刷新缓冲区，处理所有待处理的数据
-     * @returns Promise，在处理完成后 resolve
-     */
-    flush(): Promise<void>;
-    /**
-     * 获取当前缓冲区中的数据数量
-     */
-    get size(): number;
-    /**
-     * 检查缓冲区是否为空
-     */
-    get isEmpty(): boolean;
-    /**
-     * 检查是否已被销毁
-     */
-    get destroyed(): boolean;
-    /**
-     * 获取距离上次刷新的时间（毫秒）
-     */
-    get timeSinceLastFlush(): number;
-    /**
-     * 销毁缓冲区，清理定时器并处理剩余数据
-     * @param flushRemaining 是否处理剩余数据，默认为 true
-     */
-    destroy(flushRemaining?: boolean): Promise<void>;
-    /**
-     * 重置定时器
-     */
-    private resetTimer;
-    /**
-     * 清除定时器
-     */
-    private clearTimer;
-    /**
-     * 同步处理缓冲区（用于基于大小的触发）
-     */
-    private processBufferSync;
-    /**
-     * 异步处理缓冲区（用于手动刷新和销毁）
-     */
-    private processBufferAsync;
-}
-//# sourceMappingURL=batching-buffer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"batching-buffer.d.ts","sourceRoot":"","sources":["../../source/batching-buffer/batching-buffer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACtC;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAEjD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,cAAc,CAAC,CAAC;IAC3B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAsC;IACtE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAmC;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;IACtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC;IA0B7C;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAmBlB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAyB1B;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;OAEG;IACH,IAAI,kBAAkB,IAAI,MAAM,CAE/B;IAED;;;OAGG;IACG,OAAO,CAAC,cAAc,GAAE,OAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB5D;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAiDzB;;OAEG;YACW,kBAAkB;CA2BjC"}

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

@@ -1,264 +0,0 @@
-/**
- * 批处理缓冲区
- *
- * 提供数据暂存和批量/单个处理功能的管理对象。
- * 当缓冲区达到指定数量或距离上次处理达到一定时间时，
- * 自动调用处理方法进行数据消费。
- *
- * @example
- * ```typescript
- * // 批量处理模式
- * const buffer = new BatchingBuffer({
- *   batchProcessor: async (items) => {
- *     console.log('批量处理:', items)
- *     await saveToDatabase(items)
- *   },
- *   bufferSize: 10,
- *   flushInterval: 5000
- * })
- *
- * // 单个处理模式
- * const buffer = new BatchingBuffer({
- *   itemProcessor: async (item) => {
- *     console.log('单个处理:', item)
- *     await saveToDatabase([item])
- *   },
- *   bufferSize: 1,
- *   flushInterval: 1000
- * })
- *
- * // 添加数据
- * buffer.add('data1')
- * buffer.add('data2')
- *
- * // 手动刷新
- * await buffer.flush()
- *
- * // 销毁
- * buffer.destroy()
- * ```
- */
-export class BatchingBuffer {
-    buffer = [];
-    timer = null;
-    isDestroyed = false;
-    lastFlushTime = Date.now();
-    batchProcessor;
-    itemProcessor;
-    bufferSize;
-    flushInterval;
-    autoFlush;
-    constructor(options) {
-        // 验证处理器配置
-        if (!options.batchProcessor && !options.itemProcessor) {
-            throw new Error('必须提供 batchProcessor 或 itemProcessor 其中之一');
-        }
-        if (options.batchProcessor && options.itemProcessor) {
-            throw new Error('只能选择 batchProcessor 或 itemProcessor 中的一个');
-        }
-        this.batchProcessor = options.batchProcessor;
-        this.itemProcessor = options.itemProcessor;
-        this.bufferSize = options.bufferSize ?? 100;
-        this.flushInterval = options.flushInterval ?? 5000;
-        this.autoFlush = options.autoFlush ?? true;
-        // 验证配置参数
-        if (this.bufferSize <= 0) {
-            throw new Error('bufferSize 必须大于 0');
-        }
-        if (this.flushInterval <= 0) {
-            throw new Error('flushInterval 必须大于 0');
-        }
-    }
-    /**
-     * 添加数据到缓冲区
-     * @param item 要添加的数据项
-     */
-    add(item) {
-        if (this.isDestroyed) {
-            throw new Error('BatchingBuffer 已被销毁，不能添加新数据');
-        }
-        this.buffer.push(item);
-        // 检查是否需要基于大小触发处理
-        if (this.buffer.length >= this.bufferSize) {
-            this.processBufferSync();
-            return;
-        }
-        // 启动或重置定时器
-        if (this.autoFlush) {
-            this.resetTimer();
-        }
-    }
-    /**
-     * 批量添加数据到缓冲区
-     * @param items 要添加的数据项数组
-     */
-    addBatch(items) {
-        if (this.isDestroyed) {
-            throw new Error('BatchingBuffer 已被销毁，不能添加新数据');
-        }
-        let i = 0;
-        while (i < items.length) {
-            // 填充缓冲区直到达到大小限制
-            while (i < items.length && this.buffer.length < this.bufferSize) {
-                this.buffer.push(items[i]);
-                i++;
-            }
-            // 如果缓冲区满了，处理它
-            if (this.buffer.length >= this.bufferSize) {
-                this.processBufferSync();
-            }
-        }
-        // 处理剩余的项目（如果有的话）
-        if (this.buffer.length > 0) {
-            this.processBufferSync();
-        }
-    }
-    /**
-     * 手动刷新缓冲区，处理所有待处理的数据
-     * @returns Promise，在处理完成后 resolve
-     */
-    async flush() {
-        return this.processBufferAsync();
-    }
-    /**
-     * 获取当前缓冲区中的数据数量
-     */
-    get size() {
-        return this.buffer.length;
-    }
-    /**
-     * 检查缓冲区是否为空
-     */
-    get isEmpty() {
-        return this.buffer.length === 0;
-    }
-    /**
-     * 检查是否已被销毁
-     */
-    get destroyed() {
-        return this.isDestroyed;
-    }
-    /**
-     * 获取距离上次刷新的时间（毫秒）
-     */
-    get timeSinceLastFlush() {
-        return Date.now() - this.lastFlushTime;
-    }
-    /**
-     * 销毁缓冲区，清理定时器并处理剩余数据
-     * @param flushRemaining 是否处理剩余数据，默认为 true
-     */
-    async destroy(flushRemaining = true) {
-        if (this.isDestroyed) {
-            return;
-        }
-        this.clearTimer();
-        if (flushRemaining && this.buffer.length > 0) {
-            await this.processBufferAsync();
-        }
-        else {
-            this.buffer = [];
-        }
-        this.isDestroyed = true;
-    }
-    /**
-     * 重置定时器
-     */
-    resetTimer() {
-        this.clearTimer();
-        this.timer = setTimeout(() => {
-            this.processBufferSync();
-        }, this.flushInterval);
-    }
-    /**
-     * 清除定时器
-     */
-    clearTimer() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-    }
-    /**
-     * 同步处理缓冲区（用于基于大小的触发）
-     */
-    processBufferSync() {
-        if (this.buffer.length === 0 || this.isDestroyed) {
-            return;
-        }
-        this.clearTimer();
-        const itemsToProcess = this.buffer.splice(0);
-        try {
-            if (this.batchProcessor) {
-                // 批量处理模式
-                const result = this.batchProcessor(itemsToProcess);
-                // 如果返回 Promise，处理异步
-                if (result && typeof result.then === 'function') {
-                    result.catch(() => {
-                        // 处理失败时，将数据重新放回缓冲区开头
-                        this.buffer.unshift(...itemsToProcess);
-                    });
-                }
-            }
-            else if (this.itemProcessor) {
-                // 单个处理模式 - 同步处理每个项目
-                for (let i = 0; i < itemsToProcess.length; i++) {
-                    const item = itemsToProcess[i];
-                    try {
-                        const result = this.itemProcessor(item);
-                        // 如果返回 Promise，处理异步
-                        if (result && typeof result.then === 'function') {
-                            result.catch(() => {
-                                // 处理失败时，将数据重新放回缓冲区开头
-                                this.buffer.unshift(item);
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // 同步错误处理 - 只把未处理的项目放回缓冲区
-                        this.buffer.unshift(...itemsToProcess.slice(i));
-                        throw error;
-                    }
-                }
-            }
-            this.lastFlushTime = Date.now();
-        }
-        catch (error) {
-            // 批量处理模式的错误处理
-            if (this.batchProcessor) {
-                this.buffer.unshift(...itemsToProcess);
-            }
-            throw error;
-        }
-    }
-    /**
-     * 异步处理缓冲区（用于手动刷新和销毁）
-     */
-    async processBufferAsync() {
-        if (this.buffer.length === 0) {
-            return;
-        }
-        this.clearTimer();
-        const itemsToProcess = this.buffer.splice(0);
-        try {
-            if (this.batchProcessor) {
-                // 批量处理模式
-                await this.batchProcessor(itemsToProcess);
-            }
-            else if (this.itemProcessor) {
-                // 单个处理模式
-                for (const item of itemsToProcess) {
-                    await this.itemProcessor(item);
-                }
-            }
-            this.lastFlushTime = Date.now();
-        }
-        catch (error) {
-            // 处理失败时，将数据重新放回缓冲区开头（如果没有被销毁）
-            if (!this.isDestroyed) {
-                this.buffer.unshift(...itemsToProcess);
-            }
-            throw error;
-        }
-    }
-}

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

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

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

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