@studio-kit/utils-browser 1.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@studio-kit/utils-browser",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "./src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@studio-kit/utils-common": "^1.0.0",
+    "axios": "^1.7.9",
+    "nanoid": "^5.1.2"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./*": "./src/*",
+    "./Vue2": "./src/Vue2.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/src/Code.js

@@ -0,0 +1,2 @@
+import Code from '@studio-kit/utils-common/Code.js'
+export default Code

package/src/DOM.js

@@ -0,0 +1,63 @@
+export default class DOM {
+    // 获取坐标在元素中的相对位置
+    static getOffsetPositionInElement({
+        targetElement, // 对应DOM元素
+        absolutePosition, // 相对于屏幕左上角的坐标 { x:..., y:.. }
+    }) {
+        // 获取元素在视口中的位置信息
+        const rect = targetElement.getBoundingClientRect();
+        // 计算坐标相对于元素左上角的位置
+        const x = absolutePosition.x - rect.left;
+        const y = absolutePosition.y - rect.top;
+        let isOutside = false
+        if (x < 0 || y < 0 || x > rect.right || y > rect.bottom) {
+            isOutside = true
+        }
+        return { x, y, isOutside };
+    }
+    static getBoundingClientRect({ targetEl, wrapperEl, needAutoDetectParent }) {
+        if (needAutoDetectParent) {
+            wrapperEl = this.getPositionedParent(element)
+        }
+        const { left, top, right, bottom, width, height } = targetEl.getBoundingClientRect()
+        const wrapperBoundingClientRect = wrapperEl.getBoundingClientRect()
+        return {
+            left: left - wrapperBoundingClientRect.left,
+            top: top - wrapperBoundingClientRect.top,
+            right, bottom,
+            width: targetEl.offsetWidth,
+            height: targetEl.offsetHeight
+        }
+    }
+    static getPositionedParent(element) {
+        const positionedParent = element.offsetParent;
+        if (positionedParent) {
+            return positionedParent
+        }
+        let parent = element.parentElement;
+        while (parent) {
+            const style = window.getComputedStyle(parent);
+            if (style.position !== 'static') {
+                return parent;
+            }
+            parent = parent.parentElement;
+        }
+        return null; // 没有找到则返回 null
+    }
+    static isScrollable(element) {
+        const style = window.getComputedStyle(element);
+        return style.overflow === 'scroll' || style.overflow === 'auto';
+    }
+    static watchSizeChange(element, onChange) {
+        if (window.ResizeObserver)
+            return new ResizeObserver(onChange).observe(element)
+    }
+    static unwatchSizeChange(watcher, element) {
+        if (window.ResizeObserver) {
+            if (watcher instanceof window.ResizeObserver) {
+                if (element) watcher.unobserve(element);
+                else watcher.disconnect();
+            }
+        }
+    }
+}

package/src/Data.js

@@ -0,0 +1,2 @@
+import Data from '@studio-kit/utils-common/Data.js'
+export default Data

package/src/FIO.js

@@ -0,0 +1,79 @@
+export default class FIO {
+    static loadingMap = {};
+    static loadedMap = {};
+    static loadLib(src, key, type) {
+        const {
+            loadingMap,
+            loadedMap
+        } = FIO
+        if (key && window[key]) return Promise.resolve(window['key']);
+        if (loadedMap[src]) return Promise.resolve();
+        if (loadingMap[src]) return loadingMap[src];
+        if (/\.js$/.test(src) || type === 'js')
+            return loadingMap[src] = new Promise((resolve, reject) => {
+                const script = document.createElement('script');
+                script.async = true;
+                script.src = src;
+                script.onerror = function (err) {
+                    const errMsg = `加载js文件错误(src: ${src})(err: ${err.message})`
+                    console.error(errMsg)
+                    reject(new Error(errMsg));
+                };
+                script.onload = function () {
+                    delete loadingMap[src];
+                    loadedMap[src] = true;
+                    resolve(window[key]);
+                };
+                document.head.appendChild(script);
+            });
+        if (/\.css$/.test(src) || type === 'css') {
+            return loadingMap[src] = new Promise((resolve, reject) => {
+                const link = document.createElement('link');
+                link.type = 'text/css';
+                link.rel = 'stylesheet';
+                link.href = src;
+                link.onerror = function (err) {
+                    console.error('加载BMap文件错误', err)
+                    reject(err);
+                };
+                link.onload = function () {
+                    delete loadingMap[src];
+                    loadedMap[src] = true;
+                    resolve(window[key]);
+                };
+                document.head.appendChild(link);
+            });
+        }
+    }
+    static joinPath({ pathParts, os }) {
+        if (!Array.isArray(pathParts) || pathParts.length === 0) {
+            return ''; // 如果没有路径片段，返回空字符串
+        }
+
+        // 拼接路径并移除多余的分隔符
+        let joinedPath = pathParts
+            .map(part => part.replace(/^\/+|\/+$/g, '')) // 去掉每部分路径的开头和结尾的多余斜杠
+            .filter(part => part !== '') // 过滤掉空字符串
+            .join('/'); // 使用正斜杠拼接
+        if (!os) {
+            for (const pathPart of pathParts) {
+                if (pathPart.indexOf('\\') !== -1) {
+                    os = 'windows'
+                }
+            }
+        }
+        // 如果是 Windows 系统，替换为反斜杠
+        if (os === 'windows') {
+            joinedPath = joinedPath.replace(/\//g, '\\');
+        }
+
+        // 确保路径以根路径开始（如果有）
+        if (pathParts[0] && pathParts[0].startsWith('/')) {
+            joinedPath = '/' + joinedPath;
+        } else if (os === 'windows' && pathParts[0] && pathParts[0].match(/^[A-Za-z]:\\/)) {
+            joinedPath = pathParts[0][0] + ':' + joinedPath; // 保留 Windows 驱动器标识
+        }
+
+        return joinedPath;
+    }
+}

package/src/HTTP.js

@@ -0,0 +1,20 @@
+import CommonHTTP from '@studio-kit/utils-common/HTTP.js'
+export default class HTTP extends CommonHTTP {
+    static getUrlQuery() {
+        const result = {}
+        if (location.search) {
+            const parsed = this.parseUrlQuery(location.search);
+            if (parsed) {
+                Object.assign(result, parsed)
+            }
+        }
+        if (location.hash) {
+            const hashQuery = location.hash.substring(location.hash.indexOf('?') + 1)
+            const parsedHash = this.parseUrlQuery(hashQuery);
+            if (parsedHash) {
+                Object.assign(result, parsedHash)
+            }
+        }
+        return result
+    }
+}

package/src/Vue2.js

@@ -0,0 +1,51 @@
+import Vue from 'vue'
+export default class Vue2 {
+    static createComponentDomEl({ componentKey, componentProps, vueContext }) {
+        // // 1. 获取组件定义（假设组件已全局注册）
+        // const componentDef = Vue.options.components[componentKey];
+        // if (!componentDef) {
+        //     throw new Error(`组件 "${componentKey}" 未注册`);
+        // }
+
+        // // 2. 创建组件构造函数
+        // const ComponentConstructor = Vue.extend(componentDef);
+
+        // // 3. 实例化组件并传入 props
+        // const instance = new ComponentConstructor({
+        //     propsData: componentProps
+        // });
+
+        // // 4. 手动挂载（生成 DOM 但不插入文档）
+        // instance.$mount();
+
+        // // 5. 返回组件的根 DOM 元素
+        // return instance.$el;
+        // 获取当前组件实例（通过 this 获取 Vue 组件上下文）
+        const parent = vueContext
+
+        // 1. 优先查找局部注册的组件
+        const componentDef = Vue.options.components[componentKey];
+
+        if (!componentDef) {
+            throw new Error(`组件 "${tagcomponentKeyName}" 未注册`)
+        }
+
+        // 2. 创建带上下文的构造函数
+        const ComponentConstructor = Vue.extend(componentDef)
+        console.log('vueContext', vueContext)
+        // 3. 创建实例并挂载
+        const instance = new ComponentConstructor({
+            parent,
+            propsData: componentProps,
+            // 同步父级的 provide/inject 链
+            inject: vueContext._provided // 保留组件自身的 inject 配置   
+        })
+        instance.$mount()
+        return instance.$el;
+        // // 4. 返回带上下文的 DOM
+        // return {
+        //     dom: instance.$el,
+        //     instance // 建议返回实例用于后续销毁
+        // }
+    }
+}

package/src/Vue3.js

@@ -0,0 +1,42 @@
+import { getCurrentInstance, createVNode, render, h, provide, resolveComponent } from 'vue'
+
+export default class Vue3 {
+    static createComponentDomEl({ component, componentProps, vueContext }) {
+        const parent = vueContext || getCurrentInstance()
+        console.log('getCurrentInstance()', getCurrentInstance())
+        console.log('vueContext', vueContext)
+        // console.log('componentKey', componentKey)
+        // // 1. 查找局部注册的组件
+        // const componentDef = resolveDynamicComponent('el-button');
+        // const componentDef = resolveComponent(component);
+        // if (!componentDef) {
+        //     throw new Error(`组件 "${componentKey}" 未注册`)
+        // }
+
+        // // 2. 创建虚拟节点
+        const wrapperComponent = {
+            setup() {
+                console.log('vueContext.gui', vueContext.gui)
+                provide('gui', vueContext.gui); // 注入数据
+                return () => h(component, componentProps); // 使用数据渲染
+            }
+        };
+        const vnode = createVNode(wrapperComponent)
+
+        // 3. 继承父级上下文
+        // if (parent) {
+        //     vnode.appContext = parent.appContext // 共享全局资源
+        //     // 同步 provide/inject
+        //     if (parent.provides) {
+        //         vnode.appContext.provides = Object.create(parent.provides)
+        //     }
+        // }
+
+        // // 4. 创建容器并渲染
+        // const instance = h(component, componentProps, )
+        const container = document.createElement('div')
+        // render(instance, container)
+        render(vnode, container)
+        return container
+    }
+}

package/src/index.js

@@ -0,0 +1,11 @@
+import vue2Plugin from "./vue2-plugin";
+import {
+    checkIsDev
+} from './methods/env'
+import DOM from "./DOM";
+export * from "@studio-kit/utils-common";
+export {
+    checkIsDev,
+    vue2Plugin,
+    DOM,
+}

package/src/methods/dom.js

@@ -0,0 +1,13 @@
+export function watchSizeChange(element, onChange) {
+    if (window.ResizeObserver)
+        return new ResizeObserver(onChange).observe(element)
+}
+
+export function unwatchSizeChange(watcher, element) {
+    if (window.ResizeObserver) {
+        if (watcher instanceof window.ResizeObserver) {
+            if (element) watcher.unobserve(element);
+            else watcher.disconnect();
+        }
+    }
+}

package/src/methods/env.js

@@ -0,0 +1,12 @@
+export function checkIsDev() {
+    let isDev = process.env.NODE_ENV === "development";
+    if (localStorage.env === "prod") isDev = false;
+    if (localStorage.env === "dev") isDev = true;
+    if (isDev) console.log("当前环境为开发环境"); // eslint-disable-line no-console
+    else console.log("当前环境为线上环境"); // eslint-disable-line no-console
+    if (location.search.indexOf('debug=1') !== -1
+        || location.search.indexOf('dev=1') !== -1) {
+        isDev = true;
+    }
+    return isDev;
+}

package/src/methods/loadLib.js

@@ -0,0 +1,41 @@
+const loadingMap = {};
+const loadedMap = {};
+export default function (src, key, type) {
+    if (key && window[key]) return Promise.resolve(window['key']);
+    if (loadedMap[src]) return Promise.resolve();
+    if (loadingMap[src]) return loadingMap[src];
+    if (/\.js$/.test(src) || type === 'js')
+        return loadingMap[src] = new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.async = true;
+            script.src = src;
+            script.onerror = function (err) {
+                console.error('加载js文件错误', src, err)
+                reject(err);
+            };
+            script.onload = function () {
+                delete loadingMap[src];
+                loadedMap[src] = true;
+                resolve(window[key]);
+            };
+            document.head.appendChild(script);
+        });
+    if (/\.css$/.test(src) || type === 'css') {
+        return loadingMap[src] = new Promise((resolve, reject) => {
+            const link = document.createElement('link');
+            link.type = 'text/css';
+            link.rel = 'stylesheet';
+            link.href = src;
+            link.onerror = function (err) {
+                console.error('加载BMap文件错误', err)
+                reject(err);
+            };
+            link.onload = function () {
+                delete loadingMap[src];
+                loadedMap[src] = true;
+                resolve(window[key]);
+            };
+            document.head.appendChild(link);
+        });
+    }
+}

package/src/methods/message.js

@@ -0,0 +1,5 @@
+export function emitParentIframe({ data, origin = '*' }) {
+    console.log('emitParentIframe', data)
+    if (window.parent) window.parent.postMessage(data, origin);
+    else console.error('对应父级iframe不存在')
+}

package/src/methods/perfomance.js

@@ -0,0 +1,21 @@
+export function debounce(fn, delay, immediate) {
+    let timer
+    let result
+    return function (...args) {
+        if (timer) clearTimeout(timer)
+
+        if (immediate) {
+            // 如果timer存在，说明第二次调用的时候还没到delay时间，因为如果超过delay时间
+            // timer会被赋值为null，所以这个时候我们不应该执行fn，应该重新设置一个定时器
+            // 但如果是一次的时候，因为还没有设过定时器，所以这里timer会是undefined
+            if (timer) {
+                timer = setTimeout(() => timer = null, delay)
+            } else {
+                result = fn.apply(this, args)
+                return result
+            }
+        } else {
+            timer = setTimeout(() => fn.apply(this, args), delay)
+        }
+    }
+}

package/src/methods/toast.js

@@ -0,0 +1,230 @@
+export default function (config = {}, Vue) {
+    const {
+        animationOut = 'fadeInDown',
+        animationIn = 'fadeOutUp',
+        position = 'center',
+        padding = '20px 30px',
+        borderRadius = '5px',
+        deviceType = 'pc'
+    } = config;
+    if (!config.successBgColor) config.successBgColor = 'rgba(0,0,0,.5)';
+    if (!config.errorBgColor) config.errorBgColor = 'rgba(255,0,0,.5)';
+    if (!config.successColor) config.successColor = '#fff';
+    if (!config.errorColor) config.errorColor = '#fff';
+    if (!config.duration) config.duration = 2e3;
+    let loadingToastEl;
+    const maskEl = document.createElement('div');
+    maskEl.className = 'full z-10'
+
+    function removeLoading() {
+        if (loadingToastEl) {
+            if (loadingToastEl.parentElement) loadingToastEl.parentElement.removeChild(loadingToastEl);
+            loadingToastEl.style.display = 'none';
+            loadingToastEl = undefined;
+        }
+        maskEl.style.display = 'none';
+        if (maskEl.parentElement) maskEl.parentElement.removeChild(maskEl);
+    }
+
+    function open(params) {
+        const { duration = config.duration, message, type } = params;
+        const toastEl = document.createElement('div');
+        console.log('toastEl', toastEl)
+        if (maskEl.parentElement)
+            maskEl.parentElement.removeChild(maskEl);
+        // toastEl.className = `${position} animated ${animationIn}`;
+        toastEl.className = `${position}`;
+        toastEl.style.backgroundColor = config[`${type}BgColor`];
+        toastEl.style.color = config[`${type}Color`];
+        toastEl.style.borderRadius = borderRadius;
+        toastEl.style.padding = padding;
+        toastEl.style.fontSize = '16px';
+        toastEl.style.zIndex = '10000';
+        toastEl.innerHTML = message;
+        if (params.isLoading) {
+            document.body.appendChild(maskEl);
+        }
+        document.body.appendChild(toastEl);
+        if (loadingToastEl) {
+            removeLoading();
+        }
+        if (params.isLoading) {
+            loadingToastEl = toastEl;
+            return;
+        }
+        setTimeout(() => {
+            // toastEl.classList.add(animationOut);
+            setTimeout(() => {
+                document.body.removeChild(toastEl);
+            }, 5e2)
+        }, duration);
+    }
+
+    const toast = params => open(params);
+    toast.success = params => {
+        if (deviceType !== 'pc' && Vue && Vue.prototype.$toast) {
+            Vue.prototype.$toast.success(params)
+        } else {
+            if (typeof params === 'string') params = { message: params };
+            if (!params) params = { message: '处理成功' };
+            params.type = 'success'
+            open(params);
+        }
+    }
+    toast.clear = () => {
+        if (Vue && Vue.prototype.$toast) {
+            Vue.prototype.$toast.clear()
+        } else {
+            removeLoading();
+        }
+    }
+    let alertWin;
+    toast.error = params => {
+        // if (params) {
+        //     const message = params.message || params;
+        //     if (Vue && Vue.prototype.$toast) {
+        //         Vue.prototype.$toast.fail(message)
+        //     } else {
+        //         if (typeof params === 'string') params = { message };
+        //         params.type = 'error'
+        //         // open(params);
+        //     }
+        // } else {
+        //     open({
+        //         type: 'error',
+        //         message: '未知错误'
+        //     });
+        //     throw new Error('toast.error未传入params')
+        // }
+        toast.clear();
+        let message = params.message || params
+        if (message && message.replace) {
+            message = message.replace(/error/ig, '')
+        }
+        if (deviceType === 'mobile') {
+            Vue.prototype.$dialog.alert({
+                message,
+            });
+        } else {
+            if (alertWin && alertWin.id) Vue.prototype.$$closePage({ winId: alertWin.id });
+            alertWin = {
+                pageKey: config.alertViewKey || 'vs-alert',
+                title: '错误提示',
+                width: 360,
+                height: 280,
+                hasMask: true,
+                canCloseOnMask: true,
+                props: {
+                    message
+                },
+            }
+            Vue.prototype.$$openPage(alertWin);
+        }
+    }
+    toast.loading = function (msg) {
+        console.log('deviceType', deviceType)
+        if (!msg) msg = '正在处理...';
+        if (deviceType !== 'pc' && Vue && Vue.prototype.$toast) {
+            Vue.prototype.$toast.loading({
+                message: msg,
+                duration: 0
+            })
+        } else {
+            open({
+                isLoading: true,
+                type: 'success',
+                message: msg,
+            })
+        }
+    }
+    toast.confirm = function (config) {
+        const maskEl = createConfirmMask();
+        const confirmEl = createConfirmEl();
+        const close = function () {
+            confirmEl.parentNode.removeChild(confirmEl);
+            maskEl.parentNode.removeChild(maskEl);
+        }
+        const {
+            btns = [
+                {
+                    name: '确定',
+                    onClick(close) {
+                        config.onConfirm(close);
+                    }
+                },
+                {
+                    name: '取消',
+                    onClick(close) {
+                        onCancel(close);
+                    }
+                }
+            ],
+            onCancel = function (close) {
+                close();
+            },
+            title,
+            content = '无警告内容'
+        } = config;
+        const titleEl = createTitleEl(title);
+        const contentEl = createContentEl(content);
+        const btnsEl = createBtnsEl();
+        btns.forEach(btn => {
+            btnsEl.appendChild(createBtnEl(btn, close));
+        });
+        if (titleEl) confirmEl.appendChild(titleEl);
+        confirmEl.appendChild(contentEl);
+        confirmEl.appendChild(btnsEl);
+    }
+
+    function createConfirmMask() {
+        const el = document.createElement('div');
+        el.className = 'mask active full z-10';
+        el.style.zIndex = 10000;
+        document.body.appendChild(el);
+        return el;
+    }
+
+    function createConfirmEl() {
+        const el = document.createElement('div');
+        el.className = 'studio-mobile-dialog center z-10';
+        el.style.zIndex = 10000;
+        document.body.appendChild(el);
+        return el;
+    }
+
+    function createTitleEl(title) {
+        if (title) {
+            const el = document.createElement('div');
+            el.className = 'studio-mobile-dialog-title';
+            el.innerHTML = title;
+            return el;
+        }
+    }
+
+    function createContentEl(title) {
+        const el = document.createElement('div');
+        el.className = 'studio-mobile-dialog-content';
+        el.innerHTML = title;
+        return el;
+    }
+
+    function createBtnsEl() {
+        const el = document.createElement('div');
+        el.className = 'studio-mobile-dialog-btns bottom';
+        return el;
+    }
+
+    function createBtnEl(btn, close) {
+        const el = document.createElement('div');
+        el.className = 'studio-mobile-dialog-btn';
+        el.innerHTML = btn.name || '未命名';
+        el.onclick = el.ontouchstart = function () {
+            btn.onClick(close);
+        }
+        return el;
+    }
+    if (deviceType === 'mobile') {
+        Vue.prototype.$confirm = toast.confirm;
+    }
+    return toast;
+}

package/src/vue2-plugin.js

@@ -0,0 +1,205 @@
+import loadLib from './methods/loadLib'
+import { nanoid } from 'nanoid'
+import axios from 'axios'
+import initToast from './methods/toast'
+import {
+    watchSizeChange,
+    unwatchSizeChange,
+} from './methods/dom'
+
+import {
+    emitParentIframe
+} from './methods/message'
+
+import {
+    debounce
+} from './methods/perfomance'
+
+
+export default function (Vue, config = {}) {
+    Vue.prototype.$util = {
+        load: loadLib,
+        watchSizeChange,
+        unwatchSizeChange,
+        createId: nanoid,
+        emitParentIframe,
+        hasVueCompo,
+        consoleLog,
+        debounce,
+    }
+    const { getUserInfo, clientType, isDev } = config
+    const $api = {
+        runtimeBaseURL: '/studio-server',
+        getUserInfo,
+        axios,
+        userInfo: getUserInfo(),
+        setUserInfo(userInfo) {
+            this.userInfo = userInfo
+        },
+        post(url, data) {
+            return axios.post(url, data)
+        },
+        fields() {
+            return {
+                fields: []
+            }
+        }
+    }
+    const actions = [
+        'list',
+        'item',
+        'save',
+        'add',
+        'edit',
+        'remove',
+    ]
+    actions.forEach(action => {
+        $api[action] = function ({
+            modelKey,
+            databaseKey,
+            filter,
+            data,
+            page,
+            size,
+        }) {
+            return axios({
+                method: 'POST',
+                url: `/api/${action}?${modelKey}`,
+                data: {
+                    modelKey,
+                    dataSourceKey: databaseKey,
+                    filter,
+                    data,
+                    page,
+                    size,
+                },
+                baseURL: $api.runtimeBaseURL
+            })
+        }
+    })
+    Vue.prototype.$api = $api
+    Vue.prototype.$app = {
+        baseUrl: '/studio-server',
+        $compoPrefix: 'studio-',
+        $isDev: isDev,
+    }
+    const $bus = new Vue();
+    Vue.prototype.$bus = $bus
+    Vue.prototype.$$close = close
+    Vue.prototype.$$handleAction = handleAction
+    Vue.prototype.$$openWin =
+        Vue.prototype.$$openPage = function (params) {
+            console.log('params', params)
+            this.$bus.$emit("openStdWin", params)
+        }
+    Vue.prototype.$message = initToast({
+        alertViewKey: 'std-alert'
+    }, Vue)
+
+    function hasVueCompo(compoKey) {
+        console.log('compoKey, Vue.component(compoKey)', compoKey, Vue.component(compoKey))
+        if (compoKey) return Vue.component(compoKey);
+    }
+
+    function close() {
+        this.$util.emitParentIframe({ data: { action: 'close' } })
+        if (clientType === "mobile") {
+            const router = this.$router;
+            return router.back();
+        }
+        const compo = this._self;
+        console.log('compo', compo)
+        findParentCompo(compo, function (parentCompo) {
+            if (parentCompo.$isVsWin || parentCompo.$isChromeView) {
+                if (parentCompo.close) {
+                    parentCompo.close();
+                    return true;
+                }
+            }
+        });
+    }
+}
+
+function consoleLog(...params) {
+    console.log(...params);
+}
+
+function findParentCompo(compo, cb) {
+    if (!compo) return;
+    const { $parent } = compo;
+    if (!$parent) return;
+    const needBreak = cb($parent);
+    if (needBreak) return;
+    findParentCompo($parent, cb);
+}
+
+function handleAction(params) {
+    const {
+        $event,
+        $params,
+        methodMap,
+        formData,
+        evenType,
+        context,
+        pathKey = "",
+        fieldKey = "",
+        fieldName = "",
+    } = params;
+    let { method, action } = params;
+    if (!action) {
+        action = {
+            config: {
+                methodKey: params.methodKey,
+            },
+            type: "callMethod",
+        };
+    }
+    const { config } = action;
+    try {
+        switch (action.type) {
+            case "callMethod": {
+                let { methodKey } = config;
+                if (!method) method = methodMap[methodKey];
+                const { actionConfig } = params;
+                const methodParams = config.methodParams || actionConfig || {}
+                if (!methodParams.formData) methodParams.formData = formData
+                if (method)
+                    method(methodParams, {
+                        $event,
+                        formData,
+                        actionConfig,
+                    });
+                else {
+                    if (methodKey === "runCode") {
+                        const { $set } = Vue.prototype;
+                        const { code } = actionConfig;
+                        if (!code) throw new Error(`未配置运行代码`);
+                        try {
+                            eval(code);
+                        } catch (err) {
+                            let message = "";
+                            if (fieldKey) {
+                                message += `字段"${fieldName || "未命名字段"}（${fieldKey}）"`;
+                            }
+                            if (evenType) {
+                                message += `事件类型"${evenType}"`;
+                            }
+                            throw new Error(
+                                `${message}自定义代码错误: "${err.message}"(code: ${code})`
+                            );
+                        }
+                    } else if (methodKey === "close") close.call(context);
+                    else throw new Error(`对应方法不存在(${methodKey})`);
+                }
+                break;
+            }
+            case "close": {
+                close.call(context);
+                break;
+            }
+        }
+    } catch (err) {
+        console.error(err);
+        $toast.error(err);
+    }
+}