@lark-apaas/miaoda-core 0.0.1-alpha.1

package/lib/components/AppContainer/IframeBridge.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import './utils/listenHot';
+import './LogInterceptor';
+export default function IframeBridge(): React.JSX.Element;

package/lib/components/AppContainer/IframeBridge.js

@@ -0,0 +1,92 @@
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useLocation, useNavigate } from "react-router-dom";
+import { connectToParent } from "penpal";
+import { useUpdatingRef } from "../../hooks/useUpdatingRef.js";
+import { postMessage } from "../../utils/postMessage.js";
+import { getPreviewParentOrigin } from "../../utils/getParentOrigin.js";
+import { childApi } from "./utils/childApi.js";
+import "./utils/listenHot.js";
+import "./LogInterceptor.js";
+var IframeBridge_RouteMessageType = /*#__PURE__*/ function(RouteMessageType) {
+    RouteMessageType["RouteChange"] = "RouteChange";
+    RouteMessageType["RouteBack"] = "RouteBack";
+    RouteMessageType["RouteForward"] = "RouteForward";
+    return RouteMessageType;
+}(IframeBridge_RouteMessageType || {});
+function isRouteMessageType(type) {
+    return Object.values(IframeBridge_RouteMessageType).includes(type);
+}
+async function connectParent() {
+    postMessage({
+        type: 'PreviewReady',
+        data: {}
+    });
+    const connection = connectToParent({
+        parentOrigin: getPreviewParentOrigin(),
+        methods: {
+            ...childApi
+        }
+    });
+    await connection.promise;
+}
+'production' !== process.env.NODE_ENV && connectParent();
+function IframeBridge() {
+    const location = useLocation();
+    const navigate = useNavigate();
+    const navigateRef = useUpdatingRef(navigate);
+    const isActive = useRef(false);
+    const historyBack = useCallback(()=>{
+        navigateRef.current(-1);
+        isActive.current = true;
+    }, [
+        navigateRef
+    ]);
+    const historyForward = useCallback(()=>{
+        navigateRef.current(1);
+        isActive.current = true;
+    }, [
+        navigateRef
+    ]);
+    const operatorMessage = useMemo(()=>({
+            ["RouteBack"]: historyBack,
+            ["RouteForward"]: historyForward,
+            ["RouteChange"]: navigateRef.current
+        }), [
+        historyBack,
+        historyForward,
+        navigateRef
+    ]);
+    useEffect(()=>{
+        if (isActive.current) {
+            isActive.current = false;
+            return;
+        }
+        postMessage({
+            type: 'ChildLocationChange',
+            data: location
+        });
+    }, [
+        location
+    ]);
+    const handleMessage = useCallback((event)=>{
+        const { data } = event;
+        if (isRouteMessageType(data?.type)) operatorMessage[data?.type](data?.data);
+    }, [
+        operatorMessage
+    ]);
+    useEffect(()=>{
+        window.addEventListener('message', handleMessage);
+        return ()=>{
+            window.removeEventListener('message', handleMessage);
+        };
+    }, [
+        handleMessage
+    ]);
+    return /*#__PURE__*/ jsx("div", {
+        style: {
+            display: 'none'
+        }
+    });
+}
+export { IframeBridge as default };

package/lib/components/AppContainer/LogInterceptor.d.ts

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

package/lib/components/AppContainer/LogInterceptor.js

@@ -0,0 +1,44 @@
+import { postMessage } from "../../utils/postMessage.js";
+const PROXY_CONSOLE_METHOD = [
+    'log',
+    'info',
+    'warn',
+    'error'
+];
+const LOG_FILTER_PREFIX = [
+    '[Dataloom]',
+    '[MiaoDa]'
+];
+const initHandleError = ()=>{
+    window.onerror = (message, source, lineno, colno, error)=>{
+        const errorList = [];
+        if (error) errorList.push(error);
+        else {
+            if ('string' == typeof message && [
+                'Script error.'
+            ].includes(message)) return;
+            if (message) errorList.push(message);
+            else if (source) errorList.push(source);
+        }
+        console.error('[MiaoDa]', ...errorList);
+    };
+};
+const initLogInterceptor = ()=>{
+    PROXY_CONSOLE_METHOD.forEach((method)=>{
+        const originalMethod = window.console[method];
+        window.console[method] = (...args)=>{
+            originalMethod(...args);
+            const log = args[0];
+            if ('string' == typeof log && LOG_FILTER_PREFIX.some((prefix)=>log.startsWith(prefix))) postMessage({
+                type: 'Console',
+                method,
+                data: args
+            });
+        };
+    });
+};
+function init() {
+    initHandleError();
+    initLogInterceptor();
+}
+'production' !== process.env.NODE_ENV && init();

package/lib/components/AppContainer/PageHoc.d.ts

@@ -0,0 +1,4 @@
+import React, { ReactNode } from 'react';
+export declare function PageHoc(props: {
+    children: ReactNode;
+}): React.JSX.Element;

package/lib/components/AppContainer/PageHoc.js

@@ -0,0 +1,40 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import html2canvas_pro from "html2canvas-pro";
+import { postMessage } from "../../utils/postMessage.js";
+function PageHoc(props) {
+    const { children } = props;
+    useEffect(()=>{
+        if ('production' !== process.env.NODE_ENV) setTimeout(()=>{
+            const viewportWidth = window.innerWidth;
+            const viewportHeight = window.innerHeight;
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const captureWidth = Math.min(viewportWidth, document.documentElement.scrollWidth);
+            const captureHeight = Math.min(viewportHeight, document.documentElement.scrollHeight);
+            html2canvas_pro(document.body, {
+                width: captureWidth,
+                height: captureHeight,
+                scrollX: window.scrollX,
+                scrollY: window.scrollY,
+                useCORS: true,
+                allowTaint: true,
+                backgroundColor: '#ffffff',
+                scale: devicePixelRatio,
+                windowWidth: viewportWidth,
+                windowHeight: viewportHeight
+            }).then((canvas)=>{
+                const base64 = canvas.toDataURL('image/png');
+                postMessage({
+                    type: 'PageScreenshot',
+                    data: base64
+                });
+            }).catch((error)=>{
+                console.error('截图失败:', error);
+            });
+        }, 1000);
+    }, []);
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: children
+    });
+}
+export { PageHoc };

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

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

@@ -0,0 +1,290 @@
+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/dayjsPlugins.d.ts

@@ -0,0 +1 @@
+export declare function registerDayjsPlugins(): void;