@lark-apaas/client-toolkit 0.1.0-alpha.log.10 → 0.1.0-alpha.log.15

package/lib/components/AppContainer/LogInterceptor.js

@@ -1,4 +1,4 @@
-import { batchLogInfo, initBatchLogger } from "../../logger/batch-logger.js";
+import { batchLogInfo, destroyBatchLogger, initBatchLogger } from "../../logger/batch-logger.js";
 import { postMessage } from "../../utils/postMessage.js";
 const PROXY_CONSOLE_METHOD = [
     'log',
@@ -10,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 = [];
@@ -26,17 +40,22 @@ 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);
-            batchLogInfo(method, JSON.stringify(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/api-proxy/core.d.ts

@@ -0,0 +1,155 @@
+/**
+ * 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;
+    /** 请求是否成功 (2xx 状态码) */
+    success: boolean;
+    /** 响应头（序列化为普通对象，可通过 postMessage 传递） */
+    headers?: Record<string, string>;
+}
+/**
+ * API 错误类
+ */
+export declare class ApiError extends Error {
+    status?: number;
+    statusText?: string;
+    response?: Response;
+    config?: RequestConfig;
+    code?: string;
+    /** 业务错误响应数据 */
+    responseData?: any;
+    constructor(message: string, config?: RequestConfig, response?: Response, code?: string, responseData?: any);
+    /**
+     * 序列化为可传递的 JSON 对象（用于 postMessage 等场景）
+     * 移除不可序列化的对象（如 Response、Request 等）
+     */
+    toJSON(): object;
+}
+/**
+ * 通用接口测试 API 代理类
+ *
+ * 特性:
+ * - 支持所有 RESTful 请求方法 (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS)
+ * - 完善的错误处理和边界检查
+ * - 超时控制和请求取消
+ * - 支持多种响应类型
+ * - 所有响应数据可序列化（可通过 postMessage 传递）
+ */
+declare class ApiProxy {
+    /** 默认配置 */
+    private defaultConfig;
+    /** 活跃的请求控制器 Map */
+    private activeRequests;
+    /**
+     * 构造函数
+     * @param baseConfig 基础配置
+     */
+    constructor(baseConfig?: Partial<RequestConfig>);
+    /**
+     * 验证 URL 格式
+     */
+    private validateUrl;
+    /**
+     * 构建完整 URL (包含查询参数)
+     */
+    private buildUrl;
+    /**
+     * 序列化请求体
+     */
+    private serializeData;
+    /**
+     * 解析响应数据
+     */
+    private parseResponse;
+    /**
+     * 将 Headers 对象序列化为普通对象（可通过 postMessage 传递）
+     */
+    private serializeHeaders;
+    /**
+     * 生成请求唯一键
+     */
+    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

@@ -0,0 +1,270 @@
+class ApiError extends Error {
+    status;
+    statusText;
+    response;
+    config;
+    code;
+    responseData;
+    constructor(message, config, response, code, responseData){
+        super(message);
+        this.name = 'ApiError';
+        this.config = config;
+        this.response = response;
+        this.status = response?.status;
+        this.statusText = response?.statusText;
+        this.code = code;
+        this.responseData = responseData;
+        Object.setPrototypeOf(this, ApiError.prototype);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            status: this.status,
+            statusText: this.statusText,
+            responseData: this.responseData,
+            config: this.config ? {
+                url: this.config.url,
+                method: this.config.method,
+                headers: this.config.headers,
+                params: this.config.params,
+                timeout: this.config.timeout,
+                responseType: this.config.responseType
+            } : void 0
+        };
+    }
+}
+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, no-cache'
+        }
+    };
+    activeRequests = new Map();
+    constructor(baseConfig){
+        if (baseConfig) this.defaultConfig = {
+            ...this.defaultConfig,
+            ...baseConfig
+        };
+    }
+    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');
+        }
+    }
+    serializeHeaders(headers) {
+        const serialized = {};
+        headers.forEach((value, key)=>{
+            serialized[key] = value;
+        });
+        return serialized;
+    }
+    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 requestKey = this.generateRequestKey(mergedConfig);
+        return await this.executeRequest(mergedConfig, requestKey);
+    }
+    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);
+            let data;
+            try {
+                data = 204 === response.status || 304 === response.status ? null : await this.parseResponse(response, config.responseType || 'json');
+            } catch (parseError) {
+                console.error('Failed to parse response:', parseError);
+                data = null;
+            }
+            const apiResponse = {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                success: response.ok,
+                headers: this.serializeHeaders(response.headers)
+            };
+            return apiResponse;
+        } catch (error) {
+            if (timeoutId) clearTimeout(timeoutId);
+            this.activeRequests.delete(requestKey);
+            if (error instanceof ApiError) throw error;
+            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(error instanceof Error ? error.message : 'Unknown error', config, void 0, '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

@@ -0,0 +1,29 @@
+/**
+ * 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

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

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

@@ -1,4 +1,5 @@
 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 = [
         {
@@ -27,6 +28,15 @@ async function getSourceMap() {
 }
 const childApi = {
     getRoutes,
-    getSourceMap
+    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
+    }
 };
 export { childApi };

package/lib/components/ErrorRender/index.js

@@ -1,7 +1,7 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect } from "react";
 import { useLocation } from "react-router-dom";
-import { Button } from "antd";
+import { Button } from "../ui/button.js";
 import { postMessage } from "../../utils/postMessage.js";
 import { copyToClipboard } from "../../utils/copyToClipboard.js";
 const RenderError = (props)=>{
@@ -68,12 +68,12 @@ const RenderError = (props)=>{
                             className: "flex space-x-4",
                             children: [
                                 /*#__PURE__*/ jsx(Button, {
-                                    className: "bg-white text-gray-600 font-[400] border rounded-[6px] shadow-xs hover:bg-gray-100 active:bg-gray-200 focus:outline-hidden h-[32px] border-[#D0D3D6]",
+                                    className: "bg-white cursor-pointer text-gray-600 font-[400] border rounded-[6px] shadow-xs hover:bg-gray-100 active:bg-gray-200 focus:outline-hidden h-[32px] border-[#D0D3D6]",
                                     onClick: onClickCopy,
                                     children: "复制错误信息"
                                 }),
                                 /*#__PURE__*/ jsx(Button, {
-                                    className: "h-[32px] text-sm font-medium text-white bg-blue-600 border border-transparent rounded-[6px] shadow-xs hover:bg-blue-600 active:bg-blue-700 focus:outline-hidden ",
+                                    className: "cursor-pointer h-[32px] text-sm font-medium text-white bg-blue-600 border border-transparent rounded-[6px] shadow-xs hover:bg-blue-600 active:bg-blue-700 focus:outline-hidden ",
                                     onClick: onClickRepair,
                                     children: "告诉妙搭修复"
                                 })

package/lib/components/User/UserDisplay.d.ts

@@ -5,5 +5,6 @@ export interface UserDisplayProps {
     size?: 'small' | 'medium' | 'large';
     className?: string;
     style?: React.CSSProperties;
+    showLabel?: boolean;
 }
 export declare const UserDisplay: React.FC<UserDisplayProps>;

package/lib/components/User/UserDisplay.js

@@ -5,7 +5,7 @@ import { clsxWithTw } from "../../utils/utils.js";
 import { UserProfile } from "./UserProfile/index.js";
 import { UserWithAvatar } from "./UserWithAvatar.js";
 import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover.js";
-const UserDisplay = ({ users, size, className, style })=>{
+const UserDisplay = ({ users, size, className, style, showLabel = true })=>{
     const normalizedUsers = useMemo(()=>Array.isArray(users) ? users : [
             users
         ].filter(Boolean), [
@@ -96,6 +96,7 @@ const UserDisplay = ({ users, size, className, style })=>{
                             children: /*#__PURE__*/ jsx(UserWithAvatar, {
                                 data: user,
                                 size: size,
+                                showLabel: showLabel,
                                 className: "cursor-pointer hover:bg-[rgba(31,35,41,0.15)] active:bg-[rgba(31,35,41,0.2)]"
                             })
                         })

package/lib/components/User/UserWithAvatar.d.ts

@@ -1,3 +1,3 @@
 import * as React from 'react';
 import type { UserWithAvatarProps } from './type';
-export declare function UserWithAvatar({ data, size, mode, className, }: UserWithAvatarProps): React.JSX.Element;
+export declare function UserWithAvatar({ data, size, mode, className, showLabel, }: UserWithAvatarProps): React.JSX.Element;

package/lib/components/User/UserWithAvatar.js

@@ -23,7 +23,7 @@ const textVariantMap = {
     medium: 'text-[14px] leading-[20px]',
     large: 'text-[16px] leading-[24px]'
 };
-function UserWithAvatar({ data, size = 'medium', mode = 'tag', className }) {
+function UserWithAvatar({ data, size = 'medium', mode = 'tag', className, showLabel = true }) {
     const { avatar, name } = data;
     const displayName = name?.trim() || '无效人员';
     const formatSize = [
@@ -48,7 +48,7 @@ function UserWithAvatar({ data, size = 'medium', mode = 'tag', className }) {
                     })
                 ]
             }),
-            /*#__PURE__*/ jsx(OverflowTooltipText, {
+            showLabel && /*#__PURE__*/ jsx(OverflowTooltipText, {
                 text: displayName,
                 className: clsxWithTw('text-card-foreground', textVariantMap[formatSize])
             })

package/lib/components/User/type.d.ts

@@ -10,4 +10,8 @@ export interface UserWithAvatarProps {
      */
     mode?: 'tag' | 'plain';
     className?: string;
+    /**
+     * @default true
+     */
+    showLabel?: boolean;
 }

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

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const badgeVariants: (props?: {
-    variant?: "default" | "secondary" | "destructive" | "outline";
+    variant?: "default" | "destructive" | "outline" | "secondary";
 } & import("class-variance-authority/dist/types").ClassProp) => string;
 declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
     asChild?: boolean;

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

@@ -1,7 +1,7 @@
 import * as React from "react";
 import { type VariantProps } from "class-variance-authority";
 declare const buttonVariants: (props?: {
-    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost";
+    variant?: "default" | "link" | "destructive" | "outline" | "secondary" | "ghost";
     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> & {

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,7 +1,7 @@
 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;
         appInfo = {
@@ -9,15 +9,7 @@ async function getAppInfo() {
             avatar: info?.app_avatar || ''
         };
         if (appInfo.name) appInfo.name = appInfo.name.trim();
-        if (appInfo.avatar) {
-            let link = document.querySelector("link[rel~='icon']");
-            if (!link) {
-                link = document.createElement('link');
-                link.rel = 'icon';
-                document.head.appendChild(link);
-            }
-            link.href = appInfo.avatar;
-        }
+        if ('undefined' != typeof window) window._appInfo = appInfo;
     }
     return appInfo ?? {};
 }

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

@@ -74,4 +74,5 @@ 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

@@ -13,7 +13,7 @@ class BatchLogger {
             userId,
             tenantId,
             appId,
-            endpoint: '/dev/logs/collect-batch',
+            endpoint: (process.env.CLIENT_BASE_PATH || '') + '/dev/logs/collect-batch',
             sizeThreshold: 20,
             flushInterval: 1000,
             maxRetries: 3,
@@ -125,7 +125,10 @@ function batchLogInfo(level, message, source) {
     if (!defaultBatchLogger) return;
     defaultBatchLogger.batchLog(level, message, source);
 }
-if ('undefined' != typeof window) window.addEventListener('beforeunload', ()=>{
-    defaultBatchLogger = null;
-});
-export { BatchLogger, batchLogInfo, getBatchLogger, initBatchLogger };
+function destroyBatchLogger() {
+    if (defaultBatchLogger) {
+        defaultBatchLogger.destroy();
+        defaultBatchLogger = null;
+    }
+}
+export { BatchLogger, batchLogInfo, destroyBatchLogger, getBatchLogger, initBatchLogger };

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

@@ -48,4 +48,13 @@ 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/lib/utils/getAppId.js

@@ -2,10 +2,11 @@ function getAppId(path) {
     if (window.MIAODA_APP_ID) return window.MIAODA_APP_ID;
     let prefix;
     prefix = path.includes('/ai/feida/runtime/') ? '/ai/feida/runtime/' : path.includes('/spark/r/') ? '/spark/r/' : '/ai/miaoda/';
-    if (!path.startsWith(prefix)) return null;
+    const windowAppId = window.appId || null;
+    if (!path.startsWith(prefix)) return windowAppId;
     const remainder = path.substring(prefix.length);
     const nextSlashIndex = remainder.indexOf('/');
-    if (-1 === nextSlashIndex) return remainder;
-    return remainder.substring(0, nextSlashIndex);
+    if (-1 === nextSlashIndex) return remainder || windowAppId;
+    return remainder.substring(0, nextSlashIndex) || windowAppId;
 }
 export { getAppId };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/client-toolkit",
-  "version": "0.1.0-alpha.log.10",
+  "version": "0.1.0-alpha.log.15",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [