@truenewx/tnxvue3 3.0.3 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truenewx/tnxvue3",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "description": "互联网技术解决方案：Vue3扩展支持",
   "private": false,
   "publishConfig": {

package/src/bootstrap-vue/button/Button.vue

@@ -1,18 +1,29 @@
 <template>
-    <BButton>
-        <i :class="icon" v-if="icon"></i>
-        <span><slot></slot></span>
+    <BButton class="tnxbsv-button" :variant="type || 'outline-secondary'" :loading="loading" :disabled="loading">
+        <i class="me-1" :class="icon" v-if="icon"></i>
+        <div>
+            <slot></slot>
+        </div>
+        <template #loading>
+            <Loading class="me-1" theme="inherit"/>
+            <div>
+                <slot></slot>
+            </div>
+        </template>
     </BButton>
 </template>
 
 <script>
 import {BButton} from 'bootstrap-vue-next';
+import Loading from '../loading/Loading.vue';
 
 export default {
     name: 'TnxbsvButton',
-    components: {BButton},
+    components: {BButton, Loading},
     props: {
+        type: String,
         icon: String,
+        loading: Boolean,
     },
     data() {
         return {};
@@ -22,5 +33,8 @@ export default {
 </script>
 
 <style>
-
+.tnxbsv-button {
+    display: flex;
+    align-items: center;
+}
 </style>

package/src/bootstrap-vue/dialog/Dialog.vue

@@ -0,0 +1,158 @@
+<template>
+    <BModal
+        dialog-class="tnxbsv-dialog"
+        header-class="tnxbsv-dialog-header"
+        title-class="tnxbsv-dialog-title"
+        body-class="tnxbsv-dialog-body"
+        :footer-class="buttons?.length ? 'tnxbsv-dialog-footer' : 'd-none'"
+        :data-v-id="id"
+        v-model="visible"
+        scrollable
+        no-close-on-backdrop
+        no-close-on-esc
+        :teleport-to="container"
+        @hidden="onHidden"
+    >
+        <template #title>
+            <div v-html="title" v-if="title"></div>
+        </template>
+        <div ref="content" v-html="content" v-if="typeof content === 'string'"></div>
+        <component ref="content" :is="content" v-bind="contentProps" v-else></component>
+        <template #footer>
+            <TnxbsvButton v-for="(button, index) in buttons" :key="index"
+                :type="button.type"
+                :loading="buttonLoadings[index]"
+                @click="btnClick(index)"
+            >
+                {{ button.caption || button.text }}
+            </TnxbsvButton>
+        </template>
+    </BModal>
+</template>
+
+<script>
+import {BModal} from 'bootstrap-vue-next';
+import TnxbsvButton from '../button/Button.vue'
+
+export default {
+    name: 'TnxbsvDialog',
+    components: {BModal, TnxbsvButton,},
+    props: {
+        id: {
+            type: [String, Number],
+            default: () => window.tnx.util.string.uuid32(),
+        },
+        modelValue: {
+            type: Boolean,
+            default: false,
+        },
+        container: String,
+        title: String,
+        content: [String, Object],
+        contentProps: {
+            type: Object,
+            default: () => ({}),
+        },
+        buttons: Array,
+        theme: String,
+        width: {
+            type: [Number, String],
+            default: 512,
+        },
+    },
+    emits: ['update:modelValue', 'close'],
+    data() {
+        return {
+            visible: this.modelValue,
+            buttonLoadings: [],
+            heightChangeObserver: null,
+        };
+    },
+    watch: {
+        modelValue(newValue, oldValue) {
+            this.visible = this.modelValue;
+            if (newValue && !oldValue) { // 从隐藏到显示
+                this.$nextTick(() => {
+                    this.locate(true);
+                });
+            }
+        },
+        visible() {
+            this.$emit('update:modelValue', this.visible);
+        },
+    },
+    mounted() {
+        window.tnx.app.eventBus.once('tnx.error', options => {
+            this.buttonLoadings = [];
+        });
+        this.$nextTick(() => {
+            if (this.visible) {
+                this.locate(true);
+            }
+        });
+    },
+    beforeUnmount() {
+        window.tnx.app.eventBus.off('tnx.error');
+    },
+    methods: {
+        locate(observe) {
+            const $ = window.tnx.libs.$;
+            let $dialog = $(`${this.container} .tnxbsv-dialog`);
+            if ($dialog.length) {
+                let top = window.tnx.util.dom.getTopVerticallyCenteredOnPage($dialog[0]);
+                let width = typeof this.width === 'number' ? this.width + 'px' : this.width;
+                $dialog.css({
+                    'margin-top': top + 'px',
+                    'width': width,
+                });
+
+                if (observe) {
+                    this.heightChangeObserver = window.tnx.util.dom.observeHeightChange($dialog[0], this.locate);
+                }
+            }
+        },
+        btnClick(index) {
+            const button = this.buttons[index];
+            if (button && typeof button.click === 'function') {
+                let result = button.click.call(this.$refs.content, this.close);
+                if (result === 'loading') {
+                    this.buttonLoadings[index] = true;
+                    return;
+                }
+                if (result === false) {
+                    return;
+                }
+            }
+            this.close();
+        },
+        open() {
+            this.visible = true;
+        },
+        close() {
+            this.visible = false;
+        },
+        onHidden() {
+            this.$emit('close');
+        },
+    }
+}
+</script>
+
+<style>
+.tnxbsv-dialog {
+    height: fit-content;
+}
+
+.tnxbsv-dialog .modal-header {
+    padding: 0.75rem 1rem;
+}
+
+.tnxbsv-dialog .modal-header .tnxbsv-dialog-title {
+    font-size: 1.1rem;
+}
+
+.tnxbsv-dialog .modal-header .btn-close {
+    --bs-btn-close-opacity: 0.25;
+    --bs-btn-close-hover-opacity: 0.5;
+}
+</style>

package/src/bootstrap-vue/form/Form.vue

@@ -0,0 +1,296 @@
+<template>
+    <BForm :id="id" class="tnxbsv-form">
+        <slot></slot>
+    </BForm>
+</template>
+
+<script>
+import {BForm} from 'bootstrap-vue-next';
+
+export default {
+    name: 'TnxbsvForm',
+    components: {BForm},
+    props: {
+        id: {
+            type: String,
+            default: () => 'tnxbsv-form-' + new Date().getTime(),
+        },
+        model: {
+            type: Object,
+            default: () => ({}),
+        },
+        inline: Boolean,
+        rules: {
+            type: Object, // key: 字段名，value: 验证规则数组
+            default: () => ({}),
+        },
+        disabled: Boolean,
+    },
+    data() {
+        return {
+            fieldEventListeners: {},
+        };
+    },
+    watch: {
+        rules() {
+            this.initRules();
+        },
+        disabled() {
+            this.updateElementsDisabled();
+        },
+    },
+    mounted() {
+        window.addEventListener('resize', this.updateLabelWidth);
+        this.$nextTick(() => {
+            setTimeout(() => {
+                this.initRules();
+                this.updateLabelWidth();
+                this.updateElementsDisabled();
+            });
+        });
+    },
+    beforeUnmount() {
+        window.removeEventListener('resize', this.updateLabelWidth);
+        this.clearEventListeners();
+    },
+    methods: {
+        getFieldGroupElements() {
+            let elements = {};
+            let groups = this.$el.querySelectorAll('.b-form-group[prop]');
+            groups.forEach(label => {
+                let fieldName = label.getAttribute('prop');
+                if (fieldName) {
+                    elements[fieldName] = label;
+                }
+            });
+            return elements;
+        },
+        getFieldRules(fieldName) {
+            let fieldRules = this.rules[fieldName] || [];
+            if (!Array.isArray(fieldRules)) {
+                fieldRules = [fieldRules];
+            }
+            return fieldRules;
+        },
+        addFieldEventListener(fieldName, element, eventType, handler) {
+            if (!this.fieldEventListeners[fieldName]) {
+                this.fieldEventListeners[fieldName] = {};
+            }
+            if (!this.fieldEventListeners[fieldName][eventType]) {
+                this.fieldEventListeners[fieldName][eventType] = [];
+            }
+            element.addEventListener(eventType, handler);
+            this.fieldEventListeners[fieldName][eventType].push(handler);
+        },
+        clearEventListeners() {
+            for (let fieldName in this.fieldEventListeners) {
+                let listeners = this.fieldEventListeners[fieldName];
+                for (let eventType in listeners) {
+                    let handlers = listeners[eventType];
+                    let fieldElement = this.getFieldElement(fieldName);
+                    if (fieldElement) {
+                        handlers.forEach(handler => {
+                            fieldElement.removeEventListener(eventType, handler);
+                        });
+                    }
+                }
+            }
+            this.fieldEventListeners = {}; // 清空映射表
+        },
+        initRules() {
+            this.clearEventListeners();
+
+            let fieldGroupElements = this.getFieldGroupElements();
+            for (let fieldName in fieldGroupElements) {
+                let fieldGroupElement = fieldGroupElements[fieldName];
+                if (fieldGroupElement) {
+                    let fieldRules = this.getFieldRules(fieldName);
+                    if (fieldRules.some(rule => rule.required)) {
+                        let label = fieldGroupElement.querySelector('.form-label');
+                        if (label) {
+                            label.classList.add('is-required');
+                        }
+                    }
+                    let existsChangeValidator = fieldRules.some(fieldRule => fieldRule.trigger === 'change');
+                    let existsBlurValidator = fieldRules.some(fieldRule => fieldRule.trigger !== 'change');
+                    if (existsChangeValidator || existsBlurValidator) {
+                        let fieldElement = fieldGroupElement.querySelector('input, select, textarea');
+                        if (fieldElement) {
+                            if (existsChangeValidator) {
+                                this.addFieldEventListener(fieldName, fieldElement, 'change', () => {
+                                    this.validateField(fieldName, 'change');
+                                });
+                            }
+                            if (existsBlurValidator) {
+                                this.addFieldEventListener(fieldName, fieldElement, 'blur', () => {
+                                    this.validateField(fieldName, 'blur');
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        updateLabelWidth() {
+            let maxWidth = 0;
+            let fieldGroupElements = this.getFieldGroupElements();
+            for (let fieldName in fieldGroupElements) {
+                let fieldGroupElement = fieldGroupElements[fieldName];
+                if (fieldGroupElement) {
+                    let label = fieldGroupElement.querySelector('.form-label');
+                    if (label) {
+                        let width = label.offsetWidth;
+                        if (width > maxWidth) {
+                            maxWidth = width;
+                        }
+                    }
+                }
+            }
+            if (maxWidth) {
+                this.$el.style.setProperty('--label-width', `${maxWidth}px`);
+            }
+        },
+        validate() {
+            this.clearValidate(); // 清除之前的反馈信息
+            this.$el.classList.remove('was-validated'); // 移除已验证样式
+
+            return new Promise((resolve, reject) => {
+                let errors = {};
+                let fieldGroupElements = this.getFieldGroupElements();
+                for (let fieldName in fieldGroupElements) {
+                    let fieldErrorMessages = this.validateField(fieldName);
+                    if (fieldErrorMessages.length) {
+                        errors[fieldName] = fieldErrorMessages;
+                    }
+                }
+                if (Object.keys(errors).length) {
+                    this.$el.classList.add('was-validated'); // 添加已验证样式
+                    reject(errors);
+                }
+                resolve();
+            });
+        },
+        getFieldElement(fieldName) {
+            let groupElement = this.$el.querySelector(`.b-form-group[prop="${fieldName}"]`);
+            if (groupElement) {
+                return groupElement.querySelector('input, textarea, select');
+            }
+            return undefined;
+        },
+        validateField(fieldName, trigger) {
+            const fieldValue = this.model[fieldName];
+            const fieldRules = this.getFieldRules(fieldName);
+            const fieldErrorMessages = [];
+
+            fieldRules.forEach(fieldRule => {
+                if (typeof fieldRule.validator === 'function' && (!trigger || trigger === fieldRule.trigger)) {
+                    fieldRule.validator(fieldRule, fieldValue, (error) => {
+                        if (error) {
+                            fieldErrorMessages.push(error.message);
+                        }
+                    });
+                }
+                // 没有validator()方法，则不进行校验
+            });
+
+            if (fieldErrorMessages.length) {
+                this.setFieldInvalidFeedback(fieldName, fieldErrorMessages);
+            } else {
+                // 清除错误状态
+                this.removeFieldInvalidFeedback(fieldName);
+            }
+            return fieldErrorMessages;
+        },
+        setFieldInvalidFeedback(fieldName, messages) {
+            let fieldElement = this.getFieldElement(fieldName);
+            if (fieldElement) {
+                // 查找已有的 .invalid-feedback 元素
+                let feedbackDiv = fieldElement.nextElementSibling;
+                // 如果下一个兄弟元素不是 .invalid-feedback，则创建一个新的
+                if (!feedbackDiv || !feedbackDiv.classList.contains('invalid-feedback')) {
+                    feedbackDiv = document.createElement('div');
+                    feedbackDiv.className = 'invalid-feedback';
+                    fieldElement.parentNode.insertBefore(feedbackDiv, fieldElement.nextSibling);
+                }
+                // 更新 .invalid-feedback 的内容
+                feedbackDiv.textContent = messages.join('; ');
+                // 设置输入框为无效状态
+                fieldElement.classList.add('is-invalid');
+            }
+        },
+        removeFieldInvalidFeedback(fieldName) {
+            let fieldElement = this.getFieldElement(fieldName);
+            if (fieldElement) {
+                // 查找已有的 .invalid-feedback 元素
+                let feedbackDiv = fieldElement.nextElementSibling;
+                // 如果存在 .invalid-feedback 元素，则移除它
+                if (feedbackDiv && feedbackDiv.classList.contains('invalid-feedback')) {
+                    feedbackDiv.remove();
+                }
+                // 移除无效状态
+                fieldElement.classList.remove('is-invalid');
+            }
+        },
+        clearValidate() {
+            this.$el.classList.remove('was-validated'); // 移除已验证样式
+
+            const invalidElements = this.$el.querySelectorAll('.is-invalid');
+            invalidElements.forEach(el => el.classList.remove('is-invalid'));
+
+            const invalidFeedbackElements = this.$el.querySelectorAll('.invalid-feedback');
+            invalidFeedbackElements.forEach(el => el.remove());
+        },
+        scrollToField(fieldName) {
+            let fieldElement = this.getFieldElement(fieldName);
+            if (fieldElement) {
+                fieldElement.scrollIntoView({behavior: 'smooth', block: 'center'});
+            }
+        },
+        updateElementsDisabled() {
+            let elements = this.$el.querySelectorAll('input, textarea, select, button');
+            elements.forEach(element => {
+                element.disabled = this.disabled;
+            });
+        },
+    }
+}
+</script>
+
+<style>
+.tnxbsv-form .b-form-group {
+    display: flex;
+}
+
+.tnxbsv-form .b-form-group:not(:last-child) {
+    margin-bottom: 1rem;
+}
+
+.tnxbsv-form .b-form-group .form-label {
+    white-space: nowrap;
+    min-width: var(--label-width);
+    text-align: right;
+    margin-right: 0.75rem;
+    margin-bottom: 0;
+}
+
+.tnxbsv-form .b-form-group .form-label.is-required::before {
+    content: '*';
+    color: var(--bs-danger);
+    margin-right: 0.25rem;
+}
+
+.tnxbsv-form .b-form-group .invalid-feedback {
+}
+
+@media (max-width: var(--bs-breakpoint-md)) {
+    .tnxbsv-form .b-form-group {
+        flex-direction: column;
+    }
+
+    .tnxbsv-form .b-form-group .form-label {
+        text-align: left;
+        margin-bottom: 0.5rem;
+        min-width: auto;
+    }
+}
+</style>

package/src/bootstrap-vue/form/FormGroup.vue

@@ -0,0 +1,42 @@
+<template>
+    <div class="tnxbsv-form-group b-form-group" :prop="prop">
+        <div class="tnxbsv-form-group__label-wrapper">
+            <slot name="label">
+                <label class="form-label">{{ label }}</label>
+            </slot>
+        </div>
+        <div class="tnxbsv-form-group__content-wrapper">
+            <slot></slot>
+        </div>
+    </div>
+</template>
+
+<script>
+export default {
+    name: 'TnxbsvFormGroup',
+    props: {
+        label: String,
+        prop: String,
+    },
+    data() {
+        return {
+            model: {},
+        };
+    },
+    methods: {}
+}
+</script>
+
+<style>
+.tnxbsv-form-group {
+    display: flex;
+}
+
+.tnxbsv-form-group__label-wrapper {
+    padding-top: 0.375rem;
+}
+
+.tnxbsv-form-group__content-wrapper {
+    flex-grow: 1;
+}
+</style>

package/src/bootstrap-vue/loading/Loading.vue

@@ -27,11 +27,14 @@ export default {
     },
     computed: {
         extraClass() {
-            let extraClass = 'text-' + this.theme;
+            let extraClass = '';
+            if (this.theme && this.theme !== 'inherit') {
+                extraClass += ' text-' + this.theme;
+            }
             if (this.small) {
                 extraClass += ' spinner-border-sm';
             }
-            return extraClass;
+            return extraClass.trim();
         },
     },
     methods: {}

package/src/bootstrap-vue/submit-form/SubmitForm.vue

@@ -0,0 +1,176 @@
+<template>
+    <TnxbsvForm ref="form" :model="model" :rules="validationRules" :disabled="disabled">
+        <slot></slot>
+        <TnxbsvFormGroup v-if="submit !== undefined && submit !== null">
+            <div class="flex-v-center">
+                <TnxbsvButton :type="theme || 'primary'" :size="size" @click="toSubmit" v-if="submit !== false">
+                    {{ _submitText }}
+                </TnxbsvButton>
+                <TnxbsvButton class="ms-2" :size="size" @click="toCancel" v-if="cancel !== false">
+                    {{ cancelText }}
+                </TnxbsvButton>
+            </div>
+        </TnxbsvFormGroup>
+    </TnxbsvForm>
+</template>
+
+<script>
+import TnxbsvForm from '../form/Form.vue';
+import TnxbsvFormGroup from '../form/FormGroup.vue';
+import TnxbsvButton from '../button/Button.vue';
+
+export default {
+    name: 'TnxbsvSubmitForm',
+    components: {TnxbsvForm, TnxbsvFormGroup, TnxbsvButton},
+    props: {
+        model: Object,
+        rules: [String, Object], // 加载字段校验规则的URL地址，或规则集对象
+        rulesApp: { // 加载字段校验规则的应用名称
+            type: String,
+            default: () => window.tnx.componentDefaultApp, // 设置为方法以延时加载，确保更改的值生效
+        },
+        rulesLoaded: Function, // 规则集加载后的附加处理函数，仅在rules为字符串类型的URL地址时有效
+        submit: {
+            type: [Function, Boolean],
+            default: null,
+        },
+        submitText: String,
+        theme: String,
+        cancel: {
+            type: [String, Function, Boolean],
+            default: true
+        },
+        cancelText: {
+            type: String,
+            default: '取消'
+        },
+        errorFocus: {
+            type: Boolean,
+            default: false,
+        },
+        size: String,
+    },
+    emits: ['rules-loaded', 'meta'],
+    data() {
+        return {
+            validationRules: {},
+            disabled: false,
+            fieldNames: [],
+        };
+    },
+    computed: {
+        _submitText() {
+            if (this.submitText) {
+                return this.submitText;
+            }
+            return this.cancel === false ? '保存' : '提交';
+        }
+    },
+    watch: {
+        rules() {
+            this.initRules();
+        },
+    },
+    mounted() {
+        this.initRules();
+    },
+    methods: {
+        initRules() {
+            if (this.rules) {
+                if (typeof this.rules === 'string') {
+                    window.tnx.app.rpc.getMeta(this.rules, meta => {
+                        if (this.rulesLoaded) {
+                            this.rulesLoaded(meta.$rules);
+                        } else {
+                            this.$emit('rules-loaded', meta.$rules);
+                        }
+                        this.validationRules = meta.$rules;
+                        delete meta.$rules;
+                        this.$emit('meta', meta);
+                        this.fieldNames = Object.keys(meta);
+                    }, this.rulesApp);
+                } else {
+                    this.validationRules = {};
+                    Object.keys(this.rules).forEach(fieldName => {
+                        let fieldRules = this.rules[fieldName] || [];
+                        if (!Array.isArray(fieldRules)) {
+                            fieldRules = [fieldRules];
+                        }
+                        if (fieldRules.length) {
+                            this.validationRules[fieldName] = fieldRules.filter((rule, index) => {
+                                let valid = rule !== undefined && rule !== null;
+                                if (!valid) {
+                                    console.error(`invalid rules[${index}] for field "${fieldName}": `, rule);
+                                }
+                                return valid;
+                            });
+                        }
+                    });
+                }
+            } else {
+                this.validationRules = {};
+            }
+        },
+        validate(callback, errorFocus) {
+            this.$refs.form.validate().then(() => {
+                if (typeof callback === 'function') {
+                    callback(true);
+                }
+            }).catch(errors => {
+                if (this.errorFocus && errorFocus !== false) {
+                    this.$nextTick(() => {
+                        this.focusError.call(this, errors);
+                    });
+                }
+                if (typeof callback === 'function') {
+                    callback(false);
+                }
+            });
+        },
+        focusError(errors) {
+            let fieldNames = Object.keys(errors);
+            let fieldName = fieldNames[0];
+            if (fieldName) {
+                let fieldElement = this.$refs.form.getFieldElement(fieldName);
+                if (fieldElement) {
+                    fieldElement.focus();
+                    return;
+                }
+                // 没有找到错误字段输入框，则滚动到错误栏目处
+                this.$refs.form.scrollToField(fieldName);
+            }
+        },
+        disable(disabled) {
+            this.disabled = disabled !== false;
+        },
+        toSubmit(callback, disabled) {
+            this.validate(success => {
+                if (success) {
+                    if (typeof callback !== 'function') {
+                        callback = this.submit;
+                    }
+                    if (typeof callback === 'function') {
+                        if (disabled !== false) {
+                            this.disable();
+                        }
+                        callback(this);
+                    }
+                }
+            });
+        },
+        toCancel() {
+            if (typeof this.cancel === 'function') {
+                this.cancel();
+            } else if (typeof this.cancel === 'string') {
+                this.$router.back(this.cancel);
+            } else if (this.cancel !== false) {
+                this.$router.back();
+            }
+        },
+    }
+}
+</script>
+
+<style>
+
+</style>

package/src/bootstrap-vue/tnxbsv.css

@@ -29,3 +29,8 @@
 .badge.text-bg-light {
     border-color: var(--bs-border-color);
 }
+
+.accordion-button,
+.accordion-body {
+    padding: 1rem;
+}

package/src/bootstrap-vue/tnxbsv.js

@@ -1,4 +1,5 @@
 // tnxbsv.js
+import tnxjq from '@truenewx/tnxcore/src/tnxjq';
 import tnxvue from '../tnxvue.js';
 import * as BootstrapVue from 'bootstrap-vue-next';
 import 'bootstrap/dist/css/bootstrap.css';
@@ -6,30 +7,56 @@ import 'bootstrap-vue-next/dist/bootstrap-vue-next.css';
 import './tnxbsv.css';
 
 import Button from './button/Button.vue';
+import Dialog from './dialog/Dialog.vue';
 import EnumSelect from './enum-select/EnumSelect.vue';
+import Form from './form/Form.vue';
+import FormGroup from './form/FormGroup.vue';
 import Loading from './loading/Loading.vue';
 import Paged from './paged/Paged.vue';
 import QueryTable from './query-table/QueryTable.vue';
 import Select from './select/Select.vue';
+import SubmitForm from './submit-form/SubmitForm.vue';
 
 export const build = tnxvue.build;
 
 export default build('tnxbsv', () => {
     const components = Object.assign({}, tnxvue.components, {
-        Button, EnumSelect, Loading, Paged, QueryTable, Select,
+        Button, Dialog, EnumSelect, Form, FormGroup, Loading, Paged, QueryTable, Select, SubmitForm,
     });
 
-    const tnxbsv = Object.assign({}, tnxvue, {
+    const tnxbsv = Object.assign({}, tnxjq, tnxvue, {
+        libs: Object.assign({}, tnxjq.libs, tnxvue.libs, {BootstrapVue}),
         components,
         componentDefaultApp: undefined, // 组件的默认app，从服务端获取数据的组件以此为远程请求的默认app
         _dialogs: [], // 对话框堆栈
         dialog(content, title, buttons, options, contentProps) {
-
+            let id = new Date().getTime();
+            let containerId = 'dialog-container-' + id;
+            let componentDefinition = Object.assign({}, Dialog,);
+            let dialogVm = window.tnx.createVueInstance(componentDefinition, null, {
+                modelValue: true,
+                id: id,
+                container: '#' + containerId,
+                title,
+                content,
+                contentProps,
+                buttons,
+            });
+            const dialogContainer = document.createElement('div');
+            dialogContainer.className = 'tnxbsv-dialog-container';
+            dialogContainer.id = containerId;
+            document.body.appendChild(dialogContainer);
+            let dialog = dialogVm.mount(dialogContainer);
+            dialog.onHidden = this.util.function.after(dialog.onHidden, () => {
+                dialogVm.unmount();
+                this._dialogs.remove(dialog);
+                document.body.removeChild(dialogContainer);
+            });
+            this._dialogs.push(dialog);
+            return dialogVm;
         },
     });
 
-    tnxbsv.libs.BootstrapVue = BootstrapVue;
-
     tnxbsv.install = tnxbsv.util.function.around(tnxbsv.install, function (install, vm) {
         install.call(tnxbsv, vm);
         vm.use(BootstrapVue.createBootstrap());

package/src/element-plus/dialog/Dialog.vue

@@ -1,6 +1,6 @@
 <template>
-    <el-dialog :data-v-id="id"
-        class="tnxel-dialog"
+    <el-dialog class="tnxel-dialog"
+        :data-v-id="id"
         v-model="visible"
         destroy-on-close
         append-to-body
@@ -34,8 +34,6 @@
 import $ from 'cash-dom';
 import DialogContent from './DialogContent.vue';
 
-const util = window.tnx.util;
-
 export default {
     name: 'TnxelDialog',
     components: {
@@ -168,7 +166,7 @@ export default {
                 });
 
                 if (observe) {
-                    this.heightChangeObserver = util.dom.observeHeightChange($dialog[0], this.locate);
+                    this.heightChangeObserver = window.tnx.util.dom.observeHeightChange($dialog[0], this.locate);
                 }
             }
         },
@@ -190,7 +188,7 @@ export default {
             const vm = this;
             this.beforeClose(function () {
                 if (typeof callback === 'function') {
-                    vm.options.onClosed = util.function.around(vm.options.onClosed, function (onClosed) {
+                    vm.options.onClosed = window.tnx.util.function.around(vm.options.onClosed, function (onClosed) {
                         if (onClosed) {
                             onClosed();
                         }

package/src/tnxvue.js

@@ -2,8 +2,8 @@
 /**
  * 基于Vue 3的扩展支持
  */
-import tnxcore from '@truenewx/tnxcore';
-// import tnxcore from '../../core/src/tnxcore';
+// import tnxcore from '@truenewx/tnxcore';
+import tnxcore from '../../core/src/tnxcore';
 import validator from './tnxvue-validator';
 import createRouter from './tnxvue-router';
 import Text from './text/Text.vue';
@@ -96,7 +96,6 @@ export default build('tnxvue', () => {
             } else if (window.tnx.router.instance) {
                 vm.config.globalProperties.$router = window.tnx.router.instance;
             }
-            // vm.config.unwrapInjectedRef = true;
             window.tnx.app.eventBus = window.tnx.app.eventBus || mitt();
             window.tnx.app.eventBus.once = function (name, handler) {
                 this.all.set(name, [handler]);