@lark-apaas/client-toolkit 1.2.1-alpha.7 → 1.2.1-alpha.9

package/lib/apis/components/UniversalLink.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface UniversalLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+    /** 链接目标：内部路由、hash 锚点或外部 URL */
+    to: string;
+}
+/**
+ * 统一的链接组件，用于替换原生 <a> 标签
+ * - 内部路由（/dashboard）→ react-router Link
+ * - Hash 锚点（#section）→ <a>
+ * - 外链（https://...）→ <a target="_blank">
+ */
+export declare const UniversalLink: React.ForwardRefExoticComponent<UniversalLinkProps & React.RefAttributes<HTMLAnchorElement>>;

package/lib/apis/components/UniversalLink.js

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import react from "react";
+import { Link } from "react-router-dom";
+function isInternalRoute(to) {
+    return !to.startsWith('#') && !to.startsWith('http://') && !to.startsWith('https://') && !to.startsWith('//');
+}
+function isExternalLink(to) {
+    return to.startsWith('http://') || to.startsWith('https://') || to.startsWith('//');
+}
+const UniversalLink_UniversalLink = /*#__PURE__*/ react.forwardRef(function({ to, ...props }, ref) {
+    if (isInternalRoute(to)) return /*#__PURE__*/ jsx(Link, {
+        to: to,
+        ref: ref,
+        ...props
+    });
+    return /*#__PURE__*/ jsx("a", {
+        href: to,
+        ref: ref,
+        ...props,
+        ...isExternalLink(to) && {
+            target: props.target ?? '_blank',
+            rel: props.rel ?? 'noopener noreferrer'
+        }
+    });
+});
+export { UniversalLink_UniversalLink as UniversalLink };

package/lib/apis/trace.d.ts

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

package/lib/apis/trace.js

@@ -0,0 +1 @@
+export * from "../trace/index.js";

package/lib/components/PagePlaceholder/index.js

@@ -15,7 +15,7 @@ const PagePlaceholder = ({ title = '页面待开发', description = '页面暂
                 children: title
             }),
             /*#__PURE__*/ jsx("div", {
-                className: "text-center text-muted-foreground text-base leading-6",
+                className: "text-center text-muted-foreground text-base leading-6 line-clamp-2 sm:max-w-[480px]",
                 children: description
             })
         ]

package/lib/utils/axiosConfig.js

@@ -140,7 +140,6 @@ function initAxiosConfig(axiosInstance) {
             if (span) {
                 const traceInfo = `${span.spanContext().traceId}-${span.spanContext().spanId}`;
                 config.headers["X-Tt-TraceInfo"] = traceInfo;
-                config.headers["Rpc-Persist-Apaas-Observability-Trace"] = traceInfo;
                 config.__span = span;
             }
         } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "1.2.1-alpha.7",
+  "version": "1.2.1-alpha.9",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [
@@ -31,10 +31,10 @@
       "require": "./lib/apis/logger.js",
       "types": "./lib/apis/logger.d.ts"
     },
-    "./tracer": {
-      "import": "./lib/apis/tracer.js",
-      "require": "./lib/apis/tracer.js",
-      "types": "./lib/apis/tracer.d.ts"
+    "./trace": {
+      "import": "./lib/apis/trace.js",
+      "require": "./lib/apis/trace.js",
+      "types": "./lib/apis/trace.d.ts"
     },
     "./udt-types": {
       "import": "./lib/apis/udt-types.js",
@@ -77,7 +77,7 @@
     "dev": "rslib build --watch",
     "format": "biome format --write",
     "storybook": "storybook dev",
-    "test": "echo 0",
+    "test": "vitest",
     "lint": "eslint src --ext .js,.jsx,.ts,.tsx",
     "lint:fix": "eslint src --ext .js,.jsx,.ts,.tsx --fix",
     "prepublishOnly": "npm run build && node scripts/replace-workspace-alias.js"
@@ -86,9 +86,9 @@
     "@ant-design/colors": "^7.2.1",
     "@ant-design/cssinjs": "^1.24.0",
     "@data-loom/js": "^0.4.3",
-    "@lark-apaas/client-capability": "^0.1.0",
+    "@lark-apaas/client-capability": "^0.1.1",
     "@lark-apaas/miaoda-inspector": "^1.0.8",
-    "@lark-apaas/observable-web": "^1.0.1-alpha.0",
+    "@lark-apaas/observable-web": "1.0.1-alpha.1",
     "@radix-ui/react-avatar": "^1.1.10",
     "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-slot": "^1.2.3",

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

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

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

@@ -1,367 +0,0 @@
-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();
-        });
-    });
-});