@lark-apaas/client-toolkit 0.1.0-alpha.log.2 → 0.1.0-alpha.safe.1

package/lib/components/ui/skeleton.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { clsxWithTw } from "../../utils/utils.js";
+const Skeleton = /*#__PURE__*/ forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx("div", {
+        ref: ref,
+        className: clsxWithTw('animate-pulse rounded-md bg-accent', className),
+        ...props
+    }));
+Skeleton.displayName = 'Skeleton';
+export { Skeleton };

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

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/lib/components/ui/tooltip.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { Arrow, Content, Portal, Provider, Root, Trigger } from "@radix-ui/react-tooltip";
+import { clsxWithTw } from "../../utils/utils.js";
+const TooltipProvider = Provider;
+const Tooltip = Root;
+const TooltipTrigger = Trigger;
+const TooltipContent = /*#__PURE__*/ forwardRef(({ className, sideOffset = 4, children, ...props }, ref)=>/*#__PURE__*/ jsx(Portal, {
+        children: /*#__PURE__*/ jsxs(Content, {
+            ref: ref,
+            sideOffset: sideOffset,
+            className: clsxWithTw('z-50 w-fit rounded-md bg-popover px-3 py-1.5 text-xs text-popover-foreground shadow-lg ring-1 ring-border data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 animate-in fade-in-0 zoom-in-95', className),
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ jsx(Arrow, {
+                    className: "fill-[rgb(31,35,41)] stroke-[rgb(31,35,41)]"
+                })
+            ]
+        })
+    }));
+TooltipContent.displayName = Content.displayName;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/lib/hooks/useAppInfo.js

@@ -4,7 +4,18 @@ const useAppInfo = ()=>{
     const [appInfo, setAppInfo] = useState({});
     useEffect(()=>{
         const handleMetaInfoChanged = async ()=>{
-            setAppInfo(await getAppInfo());
+            const info = await getAppInfo();
+            if (info.name) document.title = info.name;
+            if (info.avatar) {
+                let link = document.querySelector("link[rel~='icon']");
+                if (!link) {
+                    link = document.createElement('link');
+                    link.rel = 'icon';
+                    document.head.appendChild(link);
+                }
+                link.href = info.avatar;
+            }
+            setAppInfo(info);
         };
         handleMetaInfoChanged();
         window.addEventListener('MiaoDaMetaInfoChanged', handleMetaInfoChanged);

package/lib/integrations/getAppInfo.js

@@ -1,13 +1,15 @@
 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;
     }
     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: (process.env.CLIENT_BASE_PATH || '') + '/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/override.css

@@ -1,19 +1,3 @@
-.miao-top-nav {
-  & .ant-menu-overflow.ant-menu-horizontal > .ant-menu-item:after, & .ant-menu-overflow > .ant-menu.ant-menu-horizontal > .ant-menu-item:after, & .ant-menu-overflow.ant-menu-horizontal > .ant-menu-submenu:after, & .ant-menu-overflow > .ant-menu.ant-menu-horizontal > .ant-menu-submenu:after {
-    bottom: 1px !important;
-  }
-}
-
-.miao-nav {
-  & .ant-drawer-content-wrapper {
-    width: inherit !important;
-  }
-
-  &.ant-btn-color-default.ant-btn-variant-link:not(:disabled):not(.ant-btn-disabled):hover {
-    color: inherit;
-  }
-}
-
 .ant-btn .ant-btn-icon {
   align-items: center;
   display: inline-flex;