@lark-apaas/client-toolkit 1.2.1-alpha.4 → 1.2.1-alpha.6

package/lib/components/AppContainer/IframeBridge.js

@@ -4,6 +4,7 @@ import { useLocation, useNavigate } from "react-router-dom";
 import { connectToParent } from "penpal";
 import { useUpdatingRef } from "../../hooks/useUpdatingRef.js";
 import { submitPostMessage } from "../../utils/postMessage.js";
+import { getPreviewParentOrigin } from "../../utils/getParentOrigin.js";
 import { childApi } from "./utils/childApi.js";
 import "./utils/listenHot.js";
 var IframeBridge_RouteMessageType = /*#__PURE__*/ function(RouteMessageType) {
@@ -20,10 +21,8 @@ async function connectParent() {
         type: 'PreviewReady',
         data: {}
     });
-    const parentOrigin = process.env.FORCE_FRAMEWORK_DOMAIN_MAIN;
-    if (!parentOrigin) return;
     const connection = connectToParent({
-        parentOrigin,
+        parentOrigin: getPreviewParentOrigin(),
         methods: {
             ...childApi
         }
@@ -36,13 +35,13 @@ function IframeBridge() {
     const navigate = useNavigate();
     const navigateRef = useUpdatingRef(navigate);
     const isActive = useRef(false);
-    const historyBack = useCallback((_payload)=>{
+    const historyBack = useCallback(()=>{
         navigateRef.current(-1);
         isActive.current = true;
     }, [
         navigateRef
     ]);
-    const historyForward = useCallback((_payload)=>{
+    const historyForward = useCallback(()=>{
         navigateRef.current(1);
         isActive.current = true;
     }, [
@@ -70,8 +69,8 @@ function IframeBridge() {
         location
     ]);
     const handleMessage = useCallback((event)=>{
-        const data = event.data ?? {};
-        if ('string' == typeof data.type && isRouteMessageType(data.type)) operatorMessage[data.type](data.data);
+        const { data } = event;
+        if (isRouteMessageType(data?.type)) operatorMessage[data?.type](data?.data);
     }, [
         operatorMessage
     ]);

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

@@ -6,6 +6,7 @@ const initObservable = ()=>{
             env: 'development' === process.env.NODE_ENV ? AppEnv.Dev : AppEnv.Prod,
             collectorUrl: {
                 log: `/spark/app/${window.appId}/runtime/api/v1/observability/logs/collect`,
+                trace: `/spark/app/${window.appId}/runtime/api/v1/observability/traces/collect`,
                 metric: `/spark/app/${window.appId}/runtime/api/v1/observability/metrics/collect`
             }
         });

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 line-clamp-2 sm:max-w-[480px]",
+                className: "text-center text-muted-foreground text-base leading-6",
                 children: description
             })
         ]

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/tracer/tracer.d.ts

@@ -0,0 +1,2 @@
+declare const trace: <T>(name: string, fn: (span: import("@opentelemetry/api").Span) => Promise<T>, options?: import("@opentelemetry/api").SpanOptions) => Promise<T>;
+export { trace };

package/lib/tracer/tracer.js

@@ -0,0 +1,3 @@
+import { observable } from "@lark-apaas/observable-web";
+const trace = observable.trace;
+export { trace };

package/lib/utils/axiosConfig.d.ts

@@ -1,4 +1,14 @@
 import { AxiosInstance } from 'axios';
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        /** @internal 存储 Span 实例 */
+        __span?: any;
+        /** @internal 请求开始时间 */
+        _startTime?: number;
+        /** @internal 请求唯一标识 */
+        _requestUUID?: string;
+    }
+}
 /**
  * axios配置内容：拦截器、日志等
  */

package/lib/utils/axiosConfig.js

@@ -1,6 +1,8 @@
 import axios from "axios";
+import { observable } from "@lark-apaas/observable-web";
 import { logger } from "../apis/logger.js";
 import { getStacktrace } from "../logger/selected-logs.js";
+import { safeStringify } from "./safeStringify.js";
 const isValidResponse = (resp)=>null != resp && 'object' == typeof resp && 'config' in resp && null !== resp.config && void 0 !== resp.config && 'object' == typeof resp.config && 'status' in resp && 'number' == typeof resp.status && 'data' in resp;
 async function logResponse(ok, responseOrError) {
     if (isValidResponse(responseOrError)) {
@@ -52,7 +54,7 @@ async function logResponse(ok, responseOrError) {
             logTraceID
         };
         if (stacktrace) logMeta.stacktrace = stacktrace;
-        if ('development' === process.env.NODE_ENV) logger.log({
+        logger.debug({
             level: ok,
             args: [
                 parts.join(''),
@@ -108,7 +110,7 @@ async function logResponse(ok, responseOrError) {
         const stacktrace = await requestStacktraceMap.get(requestUUID);
         const logMeta = {};
         if (stacktrace) logMeta.stacktrace = stacktrace;
-        logger.log({
+        logger.debug({
             level: 'error',
             args: [
                 parts.join(''),
@@ -118,7 +120,7 @@ async function logResponse(ok, responseOrError) {
         });
         return;
     }
-    logger.log({
+    logger.debug({
         level: 'error',
         args: [
             '请求失败：无响应对象或配置信息'
@@ -129,6 +131,62 @@ async function logResponse(ok, responseOrError) {
 const requestStacktraceMap = new Map();
 function initAxiosConfig(axiosInstance) {
     if (!axiosInstance) axiosInstance = axios;
+    axiosInstance.interceptors.request.use((config)=>{
+        const method = (config.method || 'GET').toUpperCase();
+        const url = config.url || '';
+        const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
+        try {
+            const span = observable.startSpan(`${method} ${cleanedPath}`);
+            if (span) {
+                const traceInfo = `${span.spanContext().traceId}-${span.spanContext().spanId}`;
+                config.headers["X-Tt-Trace-Id"] = traceInfo;
+                config.headers["Rpc-Persist-Apaas-Observability-Trace"] = traceInfo;
+                config.__span = span;
+            }
+        } catch (error) {
+            console.error('Trace 配置失败:', error);
+        }
+        return config;
+    });
+    axiosInstance.interceptors.response.use((response)=>{
+        const { __span: span, _startTime: startTime, url = "" } = response.config || {};
+        const method = (response.config.method || 'GET').toUpperCase();
+        const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
+        if (span) {
+            observable.log('INFO', safeStringify({
+                method,
+                path: cleanedPath,
+                url,
+                user_agent: response.config.headers["user-agent"],
+                duration_ms: startTime ? Date.now() - startTime : void 0,
+                status: response.status,
+                request_body: response.config.data,
+                response: response.data
+            }), {}, span);
+            'function' == typeof span.end && span.end();
+        }
+        return response;
+    }, (error)=>{
+        const { config: errorConfig = {}, response: errorResponse = {}, message: errorMessage = '未知错误' } = error;
+        const { __span: span, _startTime: startTime, url = "" } = errorConfig || {};
+        const method = (errorConfig.method || 'GET').toUpperCase();
+        const cleanedPath = url.split('?')[0].replace(/^\/spark\/p\/app_\w+/, '') || '/';
+        if (span) {
+            observable.log('ERROR', safeStringify({
+                method,
+                path: cleanedPath,
+                url,
+                user_agent: errorConfig.headers?.["user-agent"],
+                duration_ms: startTime ? Date.now() - startTime : void 0,
+                status: errorResponse.status || 200,
+                request_body: errorConfig.data,
+                response: errorResponse.data || {},
+                error_message: errorMessage
+            }), {}, span);
+            'function' == typeof span.end && span.end();
+        }
+        return Promise.reject(error);
+    });
     axiosInstance.interceptors.request.use((config)=>{
         const requestUUID = crypto.randomUUID();
         if ('production' !== process.env.NODE_ENV) {

package/lib/utils/getParentOrigin.d.ts

@@ -1 +1,6 @@
 export declare function getEnv(): 'BOE' | 'PRE' | 'ONLINE';
+/**
+ * @internal
+ * 获取预览环境父级域名
+ */
+export declare function getPreviewParentOrigin(): "https://force.feishu.cn" | "https://force.feishu-pre.cn" | "https://force.feishu-boe.cn" | "https://miaoda.feishu.cn" | "https://miaoda.feishu-pre.cn" | "https://miaoda.feishu-boe.cn";

package/lib/utils/getParentOrigin.js

@@ -4,4 +4,13 @@ function getEnv() {
     if (origin.includes('fsapp.kundou.cn') || origin.includes('miaoda-pre.feishuapp.net')) return 'PRE';
     return 'BOE';
 }
-export { getEnv };
+function getPreviewParentOrigin() {
+    const { origin } = window.location;
+    if (origin.includes('force.feishuapp.net')) return 'https://force.feishu.cn';
+    if (origin.includes('force-pre.feishuapp.net')) return 'https://force.feishu-pre.cn';
+    if (origin.includes('force.byted.org')) return 'https://force.feishu-boe.cn';
+    if (origin.includes('feishuapp.cn') || origin.includes('miaoda.feishuapp.net')) return 'https://miaoda.feishu.cn';
+    if (origin.includes('fsapp.kundou.cn') || origin.includes('miaoda-pre.feishuapp.net')) return 'https://miaoda.feishu-pre.cn';
+    return 'https://miaoda.feishu-boe.cn';
+}
+export { getEnv, getPreviewParentOrigin };

package/lib/utils/postMessage.js

@@ -1,10 +1,7 @@
+import { getPreviewParentOrigin } from "./getParentOrigin.js";
 function submitPostMessage(message, targetOrigin) {
     try {
-        const parentOrigin = process.env.FORCE_FRAMEWORK_DOMAIN_MAIN;
-        console.log('submitPostMessage with env origin', parentOrigin);
-        const origin = targetOrigin ?? parentOrigin;
-        if (!origin) return;
-        window.parent.postMessage(message, origin);
+        window.parent.postMessage(message, targetOrigin ?? getPreviewParentOrigin());
     } catch (e) {
         console.error('postMessage error', e);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "1.2.1-alpha.4",
+  "version": "1.2.1-alpha.6",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [
@@ -31,6 +31,11 @@
       "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"
+    },
     "./udt-types": {
       "import": "./lib/apis/udt-types.js",
       "require": "./lib/apis/udt-types.js",
@@ -72,7 +77,7 @@
     "dev": "rslib build --watch",
     "format": "biome format --write",
     "storybook": "storybook dev",
-    "test": "vitest",
+    "test": "echo 0",
     "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"
@@ -81,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.1",
-    "@lark-apaas/miaoda-inspector": "1.0.10-alpha.1",
-    "@lark-apaas/observable-web": "^1.0.0",
+    "@lark-apaas/client-capability": "^0.1.0",
+    "@lark-apaas/miaoda-inspector": "^1.0.8",
+    "@lark-apaas/observable-web": "^1.0.1-alpha.0",
     "@radix-ui/react-avatar": "^1.1.10",
     "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-slot": "^1.2.3",
@@ -157,4 +162,4 @@
     "react-router-dom": ">=6.26.2",
     "styled-jsx": ">=5.0.0"
   }
-}
+}

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

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

@@ -1,26 +0,0 @@
-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 };