@lark-apaas/client-toolkit 1.0.5 → 1.0.6

package/lib/components/AppContainer/LogInterceptor.js

@@ -1,3 +1,4 @@
+import { batchLogInfo, destroyBatchLogger, initBatchLogger } from "../../logger/batch-logger.js";
 import { postMessage } from "../../utils/postMessage.js";
 const PROXY_CONSOLE_METHOD = [
     'log',
@@ -9,6 +10,20 @@ const LOG_FILTER_PREFIX = [
     '[Dataloom]',
     '[MiaoDa]'
 ];
+function formatArg(arg) {
+    if (null === arg) return 'null';
+    if (void 0 === arg) return 'undefined';
+    if ('object' == typeof arg) {
+        if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack}`;
+        try {
+            return JSON.stringify(arg, this.getCircularReplacer(), 2);
+        } catch (e) {
+            return Object.prototype.toString.call(arg);
+        }
+    }
+    if ('function' == typeof arg) return arg.toString();
+    return String(arg);
+}
 const initHandleError = ()=>{
     window.onerror = (message, source, lineno, colno, error)=>{
         const errorList = [];
@@ -24,16 +39,23 @@ const initHandleError = ()=>{
     };
 };
 const initLogInterceptor = ()=>{
+    initBatchLogger(console);
+    window.addEventListener('beforeunload', ()=>{
+        destroyBatchLogger();
+    });
     PROXY_CONSOLE_METHOD.forEach((method)=>{
         const originalMethod = window.console[method];
         window.console[method] = (...args)=>{
             originalMethod(...args);
             const log = args[0];
-            if ('string' == typeof log && LOG_FILTER_PREFIX.some((prefix)=>log.startsWith(prefix))) postMessage({
-                type: 'Console',
-                method,
-                data: args
-            });
+            if ('string' == typeof log && LOG_FILTER_PREFIX.some((prefix)=>log.startsWith(prefix))) {
+                batchLogInfo(method, args.map(formatArg).join(' '));
+                postMessage({
+                    type: 'Console',
+                    method,
+                    data: args
+                });
+            }
         };
     });
 };

package/lib/components/AppContainer/index.js

@@ -10,11 +10,13 @@ import { ThemeProvider, findValueByPixel, generateTailwindRadiusToken, themeColo
 import { registerDayjsPlugins } from "./dayjsPlugins.js";
 import "../../index.css";
 import { initAxiosConfig } from "../../utils/axiosConfig.js";
+import { useAppInfo } from "../../hooks/index.js";
 registerDayjsPlugins();
 initAxiosConfig();
 const isMiaodaPreview = window.IS_MIAODA_PREVIEW;
 const App = (props)=>{
     const { themeMeta = {} } = props;
+    useAppInfo();
     const { rem } = findValueByPixel(themeMetaOptions.themeRadius, themeMeta.borderRadius) || {
         rem: '0.625'
     };

package/lib/components/AppContainer/utils/childApi.js

@@ -1,5 +1,4 @@
 import { normalizeBasePath } from "../../../utils/utils.js";
-import { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put } from "./api-panel.js";
 async function getRoutes() {
     let routes = [
         {
@@ -28,15 +27,6 @@ async function getSourceMap() {
 }
 const childApi = {
     getRoutes,
-    getSourceMap,
-    apiProxy: {
-        api_get: api_get,
-        api_post: api_post,
-        api_put: api_put,
-        api_delete: api_delete,
-        api_patch: api_patch,
-        api_head: api_head,
-        api_options: api_options
-    }
+    getSourceMap
 };
 export { childApi };

package/lib/components/ui/button.d.ts

@@ -2,7 +2,7 @@ import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: {
     variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost";
-    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg";
+    size?: "default" | "icon" | "sm" | "lg" | "icon-sm" | "icon-lg";
 } & import("class-variance-authority/dist/types").ClassProp) => string;
 declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
     asChild?: boolean;

package/lib/integrations/getAppInfo.js

@@ -1,13 +1,25 @@
 import { getInitialInfo } from "../utils/getInitialInfo.js";
 import { isSparkRuntime } from "../utils/utils.js";
 async function getAppInfo() {
-    let appInfo = window._appInfo;
+    let appInfo = 'undefined' != typeof window ? window._appInfo : void 0;
     if (!appInfo && isSparkRuntime()) {
-        const info = (await getInitialInfo()).app_info;
+        const info = (await getInitialInfo())?.app_info;
         appInfo = {
             name: info?.app_name || '',
             avatar: info?.app_avatar || ''
         };
+        if (appInfo.name) appInfo.name = appInfo.name.trim();
+        if ('undefined' != typeof window) window._appInfo = appInfo;
+        if ('undefined' != typeof document && document.head) {
+            if (appInfo.name) document.title = appInfo.name;
+            let link = document.querySelector("link[rel~='icon']");
+            if (!link) {
+                link = document.createElement('link');
+                link.rel = 'icon';
+                document.head.appendChild(link);
+            }
+            link.href = appInfo.avatar;
+        }
     }
     return appInfo ?? {};
 }

package/lib/logger/__tests__/batch-logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/logger/__tests__/batch-logger.test.js

@@ -0,0 +1,367 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { BatchLogger, batchLogInfo, initBatchLogger } from "../batch-logger.js";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
+vi.mock('node-fetch', ()=>({
+        default: vi.fn()
+    }));
+const mockConsole = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    log: vi.fn()
+};
+describe('BatchLogger', ()=>{
+    let batchLogger;
+    let mockFetch;
+    beforeEach(()=>{
+        vi.clearAllMocks();
+        mockFetch = vi.fn();
+        __webpack_require__.g.fetch = mockFetch;
+        const mockResponse = new Response(JSON.stringify({
+            success: true
+        }), {
+            status: 200,
+            statusText: 'OK',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        mockFetch.mockResolvedValue(mockResponse);
+        if ('undefined' == typeof window) __webpack_require__.g.window = void 0;
+    });
+    afterEach(async ()=>{
+        if (batchLogger) await batchLogger.destroy();
+    });
+    afterAll(()=>{
+        vi.restoreAllMocks();
+    });
+    describe('Basic Functionality', ()=>{
+        it('should create a BatchLogger instance', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            expect(batchLogger).toBeInstanceOf(BatchLogger);
+        });
+        it('should add logs to queue', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            batchLogger.batchLog('info', 'Test message', 'test-source');
+            expect(batchLogger.getQueueSize()).toBe(1);
+        });
+        it('should respect batch size limit', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                sizeThreshold: 3,
+                flushInterval: 10000
+            });
+            for(let i = 0; i < 5; i++)batchLogger.batchLog('info', `Message ${i}`);
+            await new Promise((resolve)=>setTimeout(resolve, 200));
+            expect(mockFetch).toHaveBeenCalled();
+            expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(batchLogger.getQueueSize()).toBeLessThanOrEqual(2);
+        });
+    });
+    describe('Log Preservation', ()=>{
+        it('should preserve all logs without merging', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            for(let i = 0; i < 5; i++)batchLogger.batchLog('error', 'Same error message');
+            expect(batchLogger.getQueueSize()).toBe(5);
+        });
+        it('should handle different log levels independently', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            batchLogger.batchLog('info', 'Test message');
+            batchLogger.batchLog('info', 'Test message');
+            batchLogger.batchLog('warn', 'Test message');
+            batchLogger.batchLog('warn', 'Test message');
+            expect(batchLogger.getQueueSize()).toBe(4);
+        });
+        it('should handle large volumes of logs efficiently', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                sizeThreshold: 1000,
+                flushInterval: 10000
+            });
+            for(let i = 0; i < 200; i++)batchLogger.batchLog('info', `Message ${i}`);
+            expect(batchLogger.getQueueSize()).toBe(200);
+        });
+    });
+    describe('Retry Mechanism', ()=>{
+        it('should retry failed requests', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                maxRetries: 2,
+                retryDelay: 100,
+                flushInterval: 10000
+            });
+            const successResponse = new Response(JSON.stringify({
+                success: true
+            }), {
+                status: 200,
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            mockFetch.mockRejectedValueOnce(new Error('Network error')).mockRejectedValueOnce(new Error('Network error')).mockResolvedValueOnce(successResponse);
+            batchLogger.batchLog('info', 'Test message');
+            await batchLogger.flush();
+            expect(mockFetch).toHaveBeenCalled();
+            expect(mockFetch.mock.calls.length).toBeGreaterThanOrEqual(3);
+        });
+        it('should handle permanent failures', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                maxRetries: 1,
+                retryDelay: 100,
+                flushInterval: 10000
+            });
+            mockFetch.mockRejectedValue(new Error('Permanent error'));
+            batchLogger.batchLog('info', 'Test message');
+            await batchLogger.flush();
+            expect(mockConsole.warn).toHaveBeenCalled();
+        });
+    });
+    describe('Auto Flush', ()=>{
+        it('should auto flush based on interval', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                flushInterval: 1000,
+                sizeThreshold: 100
+            });
+            for(let i = 0; i < 3; i++)batchLogger.batchLog('info', `Message ${i}`);
+            await new Promise((resolve)=>setTimeout(resolve, 1200));
+            expect(mockFetch).toHaveBeenCalled();
+            expect(batchLogger.getQueueSize()).toBe(0);
+        });
+    });
+    describe('Request Configuration', ()=>{
+        it('should include custom headers', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                endpoint: 'https://api.example.com/logs',
+                headers: {
+                    Authorization: 'Bearer token123',
+                    'X-Custom-Header': 'custom-value'
+                },
+                flushInterval: 1000
+            });
+            batchLogger.batchLog('info', 'Test message');
+            await batchLogger.flush();
+            expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/logs', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer token123',
+                    'X-Custom-Header': 'custom-value'
+                })
+            }));
+        });
+        it('should send correct batch format', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                flushInterval: 10000
+            });
+            batchLogger.batchLog('info', 'Test message', 'test-source');
+            await batchLogger.flush();
+            expect(mockFetch).toHaveBeenCalledWith('/dev/logs/collect-batch', expect.objectContaining({
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }));
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(Array.isArray(callBody)).toBe(true);
+            expect(callBody).toHaveLength(1);
+            expect(callBody[0]).toMatchObject({
+                level: 'info',
+                message: 'Test message',
+                source: 'test-source',
+                user_id: 'user123',
+                tenant_id: 'tenant456',
+                app_id: 'app789'
+            });
+        });
+    });
+    describe('Global Instance Management', ()=>{
+        it('should initialize global batch logger instance', ()=>{
+            initBatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            expect(()=>batchLogInfo('info', 'Test message')).not.toThrow();
+        });
+        it('should handle batchLogInfo when no instance exists', ()=>{
+            expect(()=>batchLogInfo('info', 'Test message')).not.toThrow();
+        });
+    });
+    describe('Configuration Updates', ()=>{
+        it('should update configuration', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                sizeThreshold: 10
+            });
+            batchLogger.updateConfig({
+                sizeThreshold: 20,
+                maxRetries: 5
+            });
+            for(let i = 0; i < 21; i++)batchLogger.batchLog('info', `Message ${i}`);
+            expect(batchLogger.getQueueSize()).toBe(1);
+        });
+    });
+    describe('High Volume Log Processing', ()=>{
+        it('should handle large batch of logs without crashing', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                sizeThreshold: 50,
+                flushInterval: 1000
+            });
+            const largeBatchSize = 1000;
+            const startTime = Date.now();
+            for(let i = 0; i < largeBatchSize; i++)batchLogger.batchLog('info', `High volume log message ${i % 100}`, 'stress-test');
+            const endTime = Date.now();
+            expect(endTime - startTime).toBeLessThan(5000);
+            await new Promise((resolve)=>setTimeout(resolve, 2000));
+            expect(batchLogger.getQueueSize()).toBe(0);
+            expect(mockFetch).toHaveBeenCalled();
+            const callCount = mockFetch.mock.calls.length;
+            expect(callCount).toBeGreaterThan(0);
+            expect(callCount).toBeLessThanOrEqual(25);
+        });
+        it('should control request frequency under high load', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                sizeThreshold: 30,
+                flushInterval: 500
+            });
+            const requestsBefore = mockFetch.mock.calls.length;
+            for(let batch = 0; batch < 5; batch++){
+                for(let i = 0; i < 25; i++)batchLogger.batchLog('error', `Error message ${batch}`, 'high-frequency-test');
+                await new Promise((resolve)=>setTimeout(resolve, 50));
+            }
+            await new Promise((resolve)=>setTimeout(resolve, 1000));
+            const totalRequests = mockFetch.mock.calls.length - requestsBefore;
+            expect(totalRequests).toBeGreaterThan(0);
+            expect(totalRequests).toBeLessThanOrEqual(10);
+        });
+    });
+    describe('Edge Cases', ()=>{
+        it('should handle empty flush', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            await batchLogger.flush();
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        it('should handle concurrent flush calls safely', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                flushInterval: 10000
+            });
+            for(let i = 0; i < 20; i++)batchLogger.batchLog('info', `Message ${i}`);
+            const flushPromises = [];
+            for(let i = 0; i < 10; i++)flushPromises.push(batchLogger.flush());
+            await Promise.all(flushPromises);
+            expect(batchLogger.getQueueSize()).toBe(0);
+            expect(mockFetch.mock.calls.length).toBeGreaterThan(0);
+            expect(mockFetch.mock.calls.length).toBeLessThanOrEqual(3);
+        });
+        it('should ensure no logs remain after destroy', async ()=>{
+            mockFetch.mockResolvedValueOnce(new Response(JSON.stringify({
+                success: true
+            }), {
+                status: 200,
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }));
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789',
+                flushInterval: 10000,
+                sizeThreshold: 1000
+            });
+            for(let i = 0; i < 50; i++){
+                batchLogger.batchLog('info', `Test message info ${i}`);
+                batchLogger.batchLog('warn', `Warning message warn ${i}`);
+            }
+            const queueSize = batchLogger.getQueueSize();
+            expect(queueSize).toBe(100);
+            const fetchCallsBefore = mockFetch.mock.calls.length;
+            await batchLogger.destroy();
+            const queueSizeAfter = batchLogger.getQueueSize();
+            const fetchCallsAfter = mockFetch.mock.calls.length;
+            expect(queueSizeAfter).toBe(0);
+            expect(fetchCallsAfter).toBeGreaterThan(fetchCallsBefore);
+        });
+        it('should handle environment detection without browser APIs', ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            batchLogger.batchLog('info', 'Test message');
+            expect(batchLogger.getQueueSize()).toBe(1);
+        });
+        it('should handle destroy method with pending logs', async ()=>{
+            batchLogger = new BatchLogger(mockConsole, {
+                userId: 'user123',
+                tenantId: 'tenant456',
+                appId: 'app789'
+            });
+            batchLogger.batchLog('info', 'Test message');
+            batchLogger.batchLog('warn', 'Warning message');
+            await batchLogger.destroy();
+            expect(batchLogger.getQueueSize()).toBe(0);
+            expect(mockFetch).toHaveBeenCalled();
+        });
+    });
+});

package/lib/logger/batch-logger.d.ts

@@ -0,0 +1,78 @@
+interface BatchLoggerConfig {
+    /** 用户ID */
+    userId: string;
+    /** 租户ID */
+    tenantId: string;
+    /** 应用ID */
+    appId: string;
+    /** 后端接收日志的接口地址，默认为/dev/logs/collect */
+    endpoint?: string;
+    /** 达到此数量时触发刷新 */
+    sizeThreshold?: number;
+    /** 自动刷新的时间间隔（毫秒） */
+    flushInterval?: number;
+    /** 最大重试次数 */
+    maxRetries?: number;
+    /** 重试延迟（毫秒） */
+    retryDelay?: number;
+    /** 自定义请求头 */
+    headers?: Record<string, string>;
+}
+export declare class BatchLogger {
+    private config;
+    private logQueue;
+    private flushTimer;
+    private isProcessing;
+    private originConsole;
+    constructor(console: Console, config?: BatchLoggerConfig);
+    /**
+     * 批量记录日志（对外暴露的唯一方法）
+     */
+    batchLog(level: string, message: string, source?: string): void;
+    /**
+     * 刷新日志队列，全部发送
+     */
+    flush(): Promise<void>;
+    /**
+     * 发送日志批次到后端
+     */
+    private sendBatch;
+    /**
+     * 执行实际的fetch请求
+     */
+    private execFetch;
+    /**
+     * 启动自动刷新定时器
+     */
+    private startFlushTimer;
+    /**
+     * 设置页面卸载时的处理
+     */
+    private setupBeforeUnloadHandler;
+    /**
+     * 延迟函数
+     */
+    private delay;
+    /**
+     * 生成唯一ID
+     */
+    private generateId;
+    /**
+     * 销毁资源
+     */
+    destroy(): Promise<void>;
+    /**
+     * 获取队列大小
+     */
+    getQueueSize(): number;
+    /**
+     * 更新配置
+     */
+    updateConfig(newConfig: Partial<BatchLoggerConfig>): void;
+}
+export declare function getBatchLogger(): BatchLogger;
+export declare function initBatchLogger(oldConsole: Console, config?: BatchLoggerConfig): void;
+/** 记录日志进行批量同步 */
+export declare function batchLogInfo(level: string, message: string, source?: string): void;
+export declare function destroyBatchLogger(): void;
+export {};

package/lib/logger/batch-logger.js

@@ -0,0 +1,134 @@
+class BatchLogger {
+    config;
+    logQueue = [];
+    flushTimer = null;
+    isProcessing = false;
+    originConsole;
+    constructor(console, config){
+        this.originConsole = {
+            ...console
+        };
+        const { userId = '', tenantId = '', appId = '' } = window || {};
+        this.config = {
+            userId,
+            tenantId,
+            appId,
+            endpoint: '/dev/logs/collect-batch',
+            sizeThreshold: 20,
+            flushInterval: 1000,
+            maxRetries: 3,
+            retryDelay: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            ...config || {}
+        };
+        this.startFlushTimer();
+        this.setupBeforeUnloadHandler();
+    }
+    batchLog(level, message, source) {
+        const logEntry = {
+            id: this.generateId(),
+            level,
+            message,
+            source,
+            timestamp: Date.now()
+        };
+        this.logQueue.push(logEntry);
+        if (this.logQueue.length >= this.config.sizeThreshold) this.flush();
+    }
+    async flush() {
+        if (this.isProcessing || 0 === this.logQueue.length) return;
+        this.isProcessing = true;
+        const logsToSend = this.logQueue.splice(0, this.logQueue.length);
+        try {
+            await this.sendBatch(logsToSend);
+        } catch (error) {
+            this.logQueue.unshift(...logsToSend);
+        } finally{
+            this.isProcessing = false;
+        }
+    }
+    async sendBatch(logs) {
+        const collectLogs = logs.map((log)=>({
+                level: log.level,
+                message: log.message,
+                time: new Date(log.timestamp).toISOString(),
+                source: log.source,
+                user_id: this.config.userId,
+                tenant_id: this.config.tenantId,
+                app_id: this.config.appId
+            }));
+        let retries = 0;
+        while(retries <= this.config.maxRetries)try {
+            await this.execFetch(this.config.endpoint, {
+                method: 'POST',
+                headers: this.config.headers,
+                body: JSON.stringify(collectLogs)
+            });
+            return;
+        } catch (error) {
+            retries++;
+            if (retries > this.config.maxRetries) this.originConsole.error(`Failed to send logs (attempt ${retries}), retrying in ${this.config.retryDelay}ms...`);
+            else this.originConsole.warn(`Failed to send logs (attempt ${retries}), retrying in ${this.config.retryDelay}ms...`);
+            await this.delay(this.config.retryDelay * retries);
+        }
+    }
+    async execFetch(url, options) {
+        return fetch(url, options);
+    }
+    startFlushTimer() {
+        if (this.flushTimer) clearInterval(this.flushTimer);
+        this.flushTimer = setInterval(()=>{
+            if (this.logQueue.length > 0) this.flush();
+        }, this.config.flushInterval);
+    }
+    setupBeforeUnloadHandler() {
+        if ('undefined' != typeof window) window.addEventListener('beforeunload', ()=>{
+            this.flush().finally(()=>{
+                this.destroy();
+            });
+        });
+    }
+    delay(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.logQueue.length > 0) await this.flush();
+    }
+    getQueueSize() {
+        return this.logQueue.length;
+    }
+    updateConfig(newConfig) {
+        this.config = {
+            ...this.config,
+            ...newConfig
+        };
+        this.startFlushTimer();
+    }
+}
+let defaultBatchLogger = null;
+function getBatchLogger() {
+    return defaultBatchLogger;
+}
+function initBatchLogger(oldConsole, config) {
+    defaultBatchLogger = new BatchLogger(oldConsole, config);
+}
+function batchLogInfo(level, message, source) {
+    if (!defaultBatchLogger) return;
+    defaultBatchLogger.batchLog(level, message, source);
+}
+function destroyBatchLogger() {
+    if (defaultBatchLogger) {
+        defaultBatchLogger.destroy();
+        defaultBatchLogger = null;
+    }
+}
+export { BatchLogger, batchLogInfo, destroyBatchLogger, getBatchLogger, initBatchLogger };

package/lib/types/iframe-events.d.ts

@@ -48,13 +48,4 @@ export interface ParentApi {
 export interface ChildApi {
     getRoutes: () => Promise<any[]>;
     getSourceMap: () => Promise<string>;
-    apiProxy: {
-        api_get: (url: string, config?: any) => Promise<any>;
-        api_post: (url: string, data?: any, config?: any) => Promise<any>;
-        api_put: (url: string, data?: any, config?: any) => Promise<any>;
-        api_delete: (url: string, config?: any) => Promise<any>;
-        api_patch: (url: string, data?: any, config?: any) => Promise<any>;
-        api_head: (url: string, config?: any) => Promise<any>;
-        api_options: (url: string, config?: any) => Promise<any>;
-    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [

package/lib/components/AppContainer/api-proxy/core.d.ts

@@ -1,182 +0,0 @@
-/**
- * HTTP 请求方法类型
- */
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-/**
- * 请求配置接口
- */
-export interface RequestConfig {
-    /** 请求 URL */
-    url: string;
-    /** 请求方法 */
-    method?: HttpMethod;
-    /** 请求头 */
-    headers?: Record<string, string>;
-    /** 请求参数(用于 GET 请求的查询参数) */
-    params?: Record<string, any>;
-    /** 请求体数据 */
-    data?: any;
-    /** 超时时间(毫秒) */
-    timeout?: number;
-    /** 响应类型 */
-    responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
-    /** 是否携带凭证 */
-    credentials?: RequestCredentials;
-    /** AbortSignal 用于取消请求 */
-    signal?: AbortSignal;
-}
-/**
- * 响应数据接口
- */
-export interface ApiResponse<T = any> {
-    /** 响应数据 */
-    data: T;
-    /** HTTP 状态码 */
-    status: number;
-    /** 状态文本 */
-    statusText: string;
-}
-/**
- * API 错误类
- */
-export declare class ApiError extends Error {
-    status?: number;
-    statusText?: string;
-    response?: Response;
-    config?: RequestConfig;
-    code?: string;
-    constructor(message: string, config?: RequestConfig, response?: Response, code?: string);
-}
-/**
- * 请求拦截器类型
- */
-export type RequestInterceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
-/**
- * 响应拦截器类型
- */
-export type ResponseInterceptor = <T = any>(response: ApiResponse<T>) => ApiResponse<T> | Promise<ApiResponse<T>>;
-/**
- * 错误拦截器类型
- */
-export type ErrorInterceptor = (error: ApiError) => any;
-/**
- * 通用接口测试 API 代理类
- *
- * 特性:
- * - 支持所有 RESTful 请求方法 (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
- * - 完善的错误处理和边界检查
- * - 请求/响应拦截器
- * - 超时控制和请求取消
- * - 支持多种响应类型
- */
-declare class ApiProxy {
-    /** 默认配置 */
-    private defaultConfig;
-    /** 请求拦截器队列 */
-    private requestInterceptors;
-    /** 响应拦截器队列 */
-    private responseInterceptors;
-    /** 错误拦截器队列 */
-    private errorInterceptors;
-    /** 活跃的请求控制器 Map */
-    private activeRequests;
-    /**
-     * 构造函数
-     * @param baseConfig 基础配置
-     */
-    constructor(baseConfig?: Partial<RequestConfig>);
-    /**
-     * 添加请求拦截器
-     */
-    useRequestInterceptor(interceptor: RequestInterceptor): void;
-    /**
-     * 添加响应拦截器
-     */
-    useResponseInterceptor(interceptor: ResponseInterceptor): void;
-    /**
-     * 添加错误拦截器
-     */
-    useErrorInterceptor(interceptor: ErrorInterceptor): void;
-    /**
-     * 验证 URL 格式
-     */
-    private validateUrl;
-    /**
-     * 构建完整 URL (包含查询参数)
-     */
-    private buildUrl;
-    /**
-     * 序列化请求体
-     */
-    private serializeData;
-    /**
-     * 解析响应数据
-     */
-    private parseResponse;
-    /**
-     * 执行请求拦截器
-     */
-    private runRequestInterceptors;
-    /**
-     * 执行响应拦截器
-     */
-    private runResponseInterceptors;
-    /**
-     * 执行错误拦截器
-     */
-    private runErrorInterceptors;
-    /**
-     * 生成请求唯一键
-     */
-    private generateRequestKey;
-    /**
-     * 核心请求方法
-     */
-    request<T = any>(config: RequestConfig): Promise<ApiResponse<T>>;
-    /**
-     * 执行实际请求
-     */
-    private executeRequest;
-    /**
-     * GET 请求
-     */
-    get<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * POST 请求
-     */
-    post<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * PUT 请求
-     */
-    put<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * DELETE 请求
-     */
-    delete<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * PATCH 请求
-     */
-    patch<T = any>(url: string, data?: any, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * HEAD 请求
-     */
-    head<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * OPTIONS 请求
-     */
-    options<T = any>(url: string, config?: Omit<RequestConfig, 'url' | 'method' | 'data'>): Promise<ApiResponse<T>>;
-    /**
-     * 取消指定的请求
-     */
-    cancelRequest(requestKey: string): void;
-    /**
-     * 取消所有活跃请求
-     */
-    cancelAllRequests(): void;
-    /**
-     * 获取活跃请求数量
-     */
-    getActiveRequestCount(): number;
-}
-declare const apiProxy: ApiProxy;
-export default apiProxy;

package/lib/components/AppContainer/api-proxy/core.js

@@ -1,294 +0,0 @@
-class ApiError extends Error {
-    status;
-    statusText;
-    response;
-    config;
-    code;
-    constructor(message, config, response, code){
-        super(message);
-        this.name = 'ApiError';
-        this.config = config;
-        this.response = response;
-        this.status = response?.status;
-        this.statusText = response?.statusText;
-        this.code = code;
-        Object.setPrototypeOf(this, ApiError.prototype);
-    }
-}
-class ApiProxy {
-    defaultConfig = {
-        timeout: 30000,
-        responseType: 'json',
-        credentials: 'same-origin',
-        headers: {
-            'Content-Type': 'application/json',
-            'X-Suda-Csrf-Token': window.csrfToken || '',
-            'Cache-Control': 'no-store'
-        }
-    };
-    requestInterceptors = [];
-    responseInterceptors = [];
-    errorInterceptors = [];
-    activeRequests = new Map();
-    constructor(baseConfig){
-        if (baseConfig) this.defaultConfig = {
-            ...this.defaultConfig,
-            ...baseConfig
-        };
-    }
-    useRequestInterceptor(interceptor) {
-        if ('function' != typeof interceptor) throw new TypeError('Request interceptor must be a function');
-        this.requestInterceptors.push(interceptor);
-    }
-    useResponseInterceptor(interceptor) {
-        if ('function' != typeof interceptor) throw new TypeError('Response interceptor must be a function');
-        this.responseInterceptors.push(interceptor);
-    }
-    useErrorInterceptor(interceptor) {
-        if ('function' != typeof interceptor) throw new TypeError('Error interceptor must be a function');
-        this.errorInterceptors.push(interceptor);
-    }
-    validateUrl(url) {
-        if (!url || 'string' != typeof url) return false;
-        if (url.startsWith('/') || url.startsWith('./') || url.startsWith('../')) return true;
-        try {
-            new URL(url);
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    buildUrl(url, params) {
-        if (!params || 0 === Object.keys(params).length) return url;
-        try {
-            const urlObj = new URL(url, window.location.origin);
-            Object.entries(params).forEach(([key, value])=>{
-                if (null != value) urlObj.searchParams.append(key, String(value));
-            });
-            return urlObj.toString();
-        } catch (error) {
-            console.error('Failed to build URL:', error);
-            return url;
-        }
-    }
-    serializeData(data, contentType) {
-        if (null == data) return null;
-        if (data instanceof FormData) return data;
-        if (data instanceof Blob || data instanceof File) return data;
-        if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) return data;
-        if (data instanceof URLSearchParams) return data;
-        const type = contentType?.toLowerCase() || '';
-        if (type.includes('application/json')) try {
-            return JSON.stringify(data);
-        } catch (error) {
-            throw new ApiError('Failed to serialize JSON data', void 0, void 0, 'SERIALIZATION_ERROR');
-        }
-        if (type.includes('application/x-www-form-urlencoded')) {
-            if ('object' == typeof data) return new URLSearchParams(data).toString();
-            return String(data);
-        }
-        if ('object' == typeof data) try {
-            return JSON.stringify(data);
-        } catch (error) {
-            throw new ApiError('Failed to serialize data', void 0, void 0, 'SERIALIZATION_ERROR');
-        }
-        return String(data);
-    }
-    async parseResponse(response, responseType) {
-        try {
-            switch(responseType){
-                case 'json':
-                    const text = await response.text();
-                    return text ? JSON.parse(text) : null;
-                case 'text':
-                    return await response.text();
-                case 'blob':
-                    return await response.blob();
-                case 'arrayBuffer':
-                    return await response.arrayBuffer();
-                case 'formData':
-                    return await response.formData();
-                default:
-                    return await response.text();
-            }
-        } catch (error) {
-            throw new ApiError(`Failed to parse response as ${responseType}`, void 0, response, 'PARSE_ERROR');
-        }
-    }
-    async runRequestInterceptors(config) {
-        let modifiedConfig = {
-            ...config
-        };
-        for (const interceptor of this.requestInterceptors)try {
-            modifiedConfig = await interceptor(modifiedConfig);
-        } catch (error) {
-            console.error('Request interceptor error:', error);
-            throw new ApiError('Request interceptor failed', modifiedConfig, void 0, 'INTERCEPTOR_ERROR');
-        }
-        return modifiedConfig;
-    }
-    async runResponseInterceptors(response) {
-        let modifiedResponse = response;
-        for (const interceptor of this.responseInterceptors)try {
-            modifiedResponse = await interceptor(modifiedResponse);
-        } catch (error) {
-            console.error('Response interceptor error:', error);
-        }
-        return modifiedResponse;
-    }
-    async runErrorInterceptors(error) {
-        for (const interceptor of this.errorInterceptors)try {
-            const result = await interceptor(error);
-            if (void 0 !== result) return result;
-        } catch (err) {
-            console.error('Error interceptor failed:', err);
-        }
-        throw error;
-    }
-    generateRequestKey(config) {
-        return `${config.method || 'GET'}_${config.url}_${Date.now()}_${Math.random()}`;
-    }
-    async request(config) {
-        if (!config || 'object' != typeof config) throw new ApiError('Request config is required and must be an object', config, void 0, 'INVALID_CONFIG');
-        if (!config.url) throw new ApiError('Request URL is required', config, void 0, 'MISSING_URL');
-        if (!this.validateUrl(config.url)) throw new ApiError('Invalid URL format', config, void 0, 'INVALID_URL');
-        const mergedConfig = {
-            ...this.defaultConfig,
-            ...config,
-            headers: {
-                ...this.defaultConfig.headers,
-                ...config.headers
-            }
-        };
-        const finalConfig = await this.runRequestInterceptors(mergedConfig);
-        const requestKey = this.generateRequestKey(finalConfig);
-        try {
-            const response = await this.executeRequest(finalConfig, requestKey);
-            return response;
-        } catch (error) {
-            const apiError = error instanceof ApiError ? error : new ApiError(error instanceof Error ? error.message : 'Unknown error', finalConfig, void 0, 'REQUEST_FAILED');
-            return await this.runErrorInterceptors(apiError);
-        }
-    }
-    async executeRequest(config, requestKey) {
-        let abortController;
-        if (config.signal) {
-            abortController = new AbortController();
-            config.signal.addEventListener('abort', ()=>abortController.abort());
-        } else abortController = new AbortController();
-        this.activeRequests.set(requestKey, abortController);
-        let timeoutId = null;
-        if (config.timeout && config.timeout > 0) timeoutId = setTimeout(()=>{
-            abortController.abort();
-        }, config.timeout);
-        try {
-            const fullUrl = this.buildUrl(config.url, config.params);
-            const fetchOptions = {
-                method: config.method || 'GET',
-                headers: config.headers,
-                credentials: config.credentials,
-                signal: abortController.signal
-            };
-            const methodsWithoutBody = [
-                'GET',
-                'HEAD'
-            ];
-            if (config.data && !methodsWithoutBody.includes(config.method || 'GET')) fetchOptions.body = this.serializeData(config.data, config.headers?.['Content-Type']);
-            const response = await fetch(fullUrl, fetchOptions);
-            if (timeoutId) clearTimeout(timeoutId);
-            this.activeRequests.delete(requestKey);
-            if (!response.ok) throw new ApiError(`HTTP Error: ${response.status} ${response.statusText}`, config, response, 'HTTP_ERROR');
-            const data = await this.parseResponse(response, config.responseType || 'json');
-            const apiResponse = {
-                data,
-                status: response.status,
-                statusText: response.statusText
-            };
-            return await this.runResponseInterceptors(apiResponse);
-        } catch (error) {
-            let errorResponse = null, errorResponseString = '';
-            if (error.response && error.config.responseType) errorResponse = await this.parseResponse(error.response, error.config.responseType || 'json');
-            try {
-                errorResponseString = JSON.stringify(errorResponse);
-            } catch (error) {
-                throw new ApiError(error instanceof Error ? error.message : 'Response parse error', config, void 0, 'UNKNOWN_ERROR');
-            }
-            if (timeoutId) clearTimeout(timeoutId);
-            this.activeRequests.delete(requestKey);
-            if (error instanceof Error && 'AbortError' === error.name) throw new ApiError(config.timeout ? 'Request timeout' : 'Request cancelled', config, void 0, 'ABORT_ERROR');
-            if (error instanceof TypeError) throw new ApiError('Network error or CORS issue', config, void 0, 'NETWORK_ERROR');
-            throw new ApiError(errorResponseString, config, errorResponse, 'UNKNOWN_ERROR');
-        }
-    }
-    async get(url, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'GET'
-        });
-    }
-    async post(url, data, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'POST',
-            data
-        });
-    }
-    async put(url, data, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'PUT',
-            data
-        });
-    }
-    async delete(url, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'DELETE'
-        });
-    }
-    async patch(url, data, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'PATCH',
-            data
-        });
-    }
-    async head(url, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'HEAD'
-        });
-    }
-    async options(url, config) {
-        return this.request({
-            ...config,
-            url,
-            method: 'OPTIONS'
-        });
-    }
-    cancelRequest(requestKey) {
-        const controller = this.activeRequests.get(requestKey);
-        if (controller) {
-            controller.abort();
-            this.activeRequests.delete(requestKey);
-        }
-    }
-    cancelAllRequests() {
-        this.activeRequests.forEach((controller)=>{
-            controller.abort();
-        });
-        this.activeRequests.clear();
-    }
-    getActiveRequestCount() {
-        return this.activeRequests.size;
-    }
-}
-const apiProxy = new ApiProxy();
-const core = apiProxy;
-export { ApiError, core as default };

package/lib/components/AppContainer/utils/api-panel.d.ts

@@ -1,29 +0,0 @@
-/**
- * GET 请求
- */
-declare function api_get(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * POST 请求
- */
-declare function api_post(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * PUT 请求
- */
-declare function api_put(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * DELETE 请求
- */
-declare function api_delete(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * PATCH 请求
- */
-declare function api_patch(url: any, data: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * HEAD 请求
- */
-declare function api_head(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-/**
- * OPTIONS 请求
- */
-declare function api_options(url: any, config: any): Promise<import("../api-proxy/core").ApiResponse<any>>;
-export { api_get, api_post, api_put, api_delete, api_patch, api_head, api_options, };

package/lib/components/AppContainer/utils/api-panel.js

@@ -1,66 +0,0 @@
-import { normalizeBasePath } from "../../../utils/utils.js";
-import core from "../api-proxy/core.js";
-async function api_get(url, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.get(`${basePath}${url}`, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_post(url, data, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.post(`${basePath}${url}`, data, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_put(url, data, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.put(`${basePath}${url}`, data, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_delete(url, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core["delete"](`${basePath}${url}`, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_patch(url, data, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.patch(`${basePath}${url}`, data, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_head(url, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.head(`${basePath}${url}`, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-async function api_options(url, config) {
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await core.options(`${basePath}${url}`, config);
-        return res;
-    } catch (error) {
-        throw new Error(JSON.stringify(error));
-    }
-}
-export { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put };