@lark-apaas/miaoda-core 0.0.1-alpha.2 → 0.0.5-beta.2

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

@@ -1,5 +1,4 @@
 import { normalizeBasePath } from "../../../utils/utils.js";
-import { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put, getLogJson, getOpenApiJson } from "./api-panel.js";
 async function getRoutes() {
     let routes = [
         {
@@ -16,17 +15,6 @@ async function getRoutes() {
     return routes;
 }
 const childApi = {
-    getRoutes,
-    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,
-        getOpenApiJson: getOpenApiJson,
-        getLogJson: getLogJson
-    }
+    getRoutes
 };
 export { childApi };

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

@@ -47,15 +47,4 @@ export interface ParentApi {
 }
 export interface ChildApi {
     getRoutes: () => Promise<any[]>;
-    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>;
-        getOpenApiJson: () => Promise<any>;
-        getLogJson: () => Promise<any>;
-    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/miaoda-core",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.5-beta.2",
   "types": "./lib/index.d.ts",
   "main": "./lib/index.js",
   "files": [
@@ -70,6 +70,8 @@
     "test": "echo 0",
     "lint": "eslint src --ext .js,.jsx,.ts,.tsx",
     "lint:fix": "eslint src --ext .js,.jsx,.ts,.tsx --fix",
+    "postinstall": "yes | npx shadcn@latest add --all -o -y -c \"$INIT_CWD\"",
+    "setup": "echo 'setup'",
     "prepublishOnly": "npm run build && node scripts/replace-workspace-alias.js"
   },
   "dependencies": {

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

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

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

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

@@ -1,38 +0,0 @@
-/**
- * api panel
- * 获取open-api.json
- */
-declare function getOpenApiJson(): Promise<{}>;
-/**
- * 获取日志json
- */
-declare function getLogJson(): Promise<{}>;
-/**
- * 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 { getOpenApiJson, getLogJson, api_get, api_post, api_put, api_delete, api_patch, api_head, api_options, };

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

@@ -1,84 +0,0 @@
-import { normalizeBasePath } from "../../../utils/utils.js";
-import core from "../api-proxy/core.js";
-async function getOpenApiJson() {
-    let apiJson = {};
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await fetch(`${basePath}/openapi.json`);
-        apiJson = await res.json();
-    } catch (error) {
-        console.warn('get openapi.json error', error);
-    }
-    return apiJson;
-}
-async function getLogJson() {
-    let logJson = {};
-    try {
-        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-        const res = await fetch(`${basePath}/log.json`);
-        logJson = await res.json();
-    } catch (error) {
-        console.warn('get log.json error', error);
-    }
-    return logJson;
-}
-async function api_get(url, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.get({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'GET'
-    });
-}
-async function api_post(url, data, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.post({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'POST',
-        data
-    });
-}
-async function api_put(url, data, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.put({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'PUT',
-        data
-    });
-}
-async function api_delete(url, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core["delete"]({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'DELETE'
-    });
-}
-async function api_patch(url, data, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.patch({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'PATCH',
-        data
-    });
-}
-async function api_head(url, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.head({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'HEAD'
-    });
-}
-async function api_options(url, config) {
-    const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
-    return core.options({
-        ...config,
-        url: `${basePath}${url}`,
-        method: 'OPTIONS'
-    });
-}
-export { api_delete, api_get, api_head, api_options, api_patch, api_post, api_put, getLogJson, getOpenApiJson };