@smallwei/avue 3.8.4 → 3.8.6

package/lib/packages/element-plus/crud/dialog/dialog-form2.js

@@ -0,0 +1,259 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var src_core_create = require('../../../../src/core/create.js');
+var src_core_locale = require('../../../../src/core/locale.js');
+var packages_elementPlus_crud_config = require('../config.js');
+var src_utils_util = require('../../../../src/utils/util.js');
+
+var script = src_core_create.default({
+  name: "crud",
+  mixins: [src_core_locale.default],
+  emits: ["update:modelValue", "change"],
+  inject: ["crud"],
+  data() {
+    return {
+      loading: false,
+      disabled: false,
+      config: packages_elementPlus_crud_config.default,
+      boxType: "",
+      fullscreen: false,
+      boxVisible: false,
+    };
+  },
+  props: {
+    modelValue: {
+      type: Object,
+      default: () => {
+        return {};
+      },
+    },
+  },
+  computed: {
+    isView() {
+      return this.boxType === "view";
+    },
+    isAdd() {
+      return this.boxType === "add";
+    },
+    isEdit() {
+      return this.boxType === "edit";
+    },
+    width() {
+      let dialogWidth = this.crud.tableOption.dialogWidth + "";
+      let defaultWidth = this.crud.isMobile ? "100%" : packages_elementPlus_crud_config.default.dialogWidth;
+      let result = this.validData(dialogWidth, defaultWidth);
+      return this.setPx(result);
+    },
+    dialogType() {
+      return this.isDrawer ? "elDrawer" : "elDialog";
+    },
+    dialogTop() {
+      return !this.isDrawer && !this.fullscreen
+        ? this.crud.tableOption.dialogTop
+        : "0";
+    },
+    isDrawer() {
+      return this.crud.tableOption.dialogType === "drawer";
+    },
+    params() {
+      let result = this.isDrawer
+        ? {
+            size: this.fullscreen ? "100%" : this.width,
+            direction: this.crud.tableOption.dialogDirection,
+          }
+        : {
+            width: this.width,
+            fullscreen: this.fullscreen,
+          };
+      return Object.assign(result, this.$uploadFun({}, this.crud));
+    },
+    option() {
+      let option = this.deepClone(this.crud.tableOption);
+      option.boxType = this.boxType;
+      option.column = this.deepClone(this.crud.propOption);
+      option.column.forEach((ele) => {
+        delete ele.render;
+        if (ele.renderForm) ele.render = ele.renderForm;
+      });
+      option.menuBtn = false;
+      if (this.isAdd) {
+        option.submitBtn = option.saveBtn;
+        option.submitText = this.crud.menuIcon("saveBtn");
+        option.submitIcon = this.crud.getBtnIcon("saveBtn");
+      } else if (this.isEdit) {
+        option.submitBtn = option.updateBtn;
+        option.submitText = this.crud.menuIcon("updateBtn");
+        option.submitIcon = this.crud.getBtnIcon("updateBtn");
+      } else if (this.isView) {
+        option.detail = true;
+      }
+      option.mockIcon = this.crud.getBtnIcon("mockBtn");
+      option.mockText = this.crud.menuIcon("mockBtn");
+
+      option.emptyBtn = option.cancelBtn;
+      option.emptyIcon = this.crud.getBtnIcon("cancelBtn");
+      option.emptyText = this.crud.menuIcon("cancelBtn");
+      //不分组的表单不加载字典
+      if (!this.crud.isGroup) {
+        option.dicFlag = false;
+        option.dicData = this.crud.DIC;
+      }
+      if (!this.validatenull(option.dicFlag)) {
+        option.column.forEach((ele) => {
+          ele.boxType = this.boxType;
+          ele.dicFlag = ele.dicFlag || option.dicFlag;
+        });
+      }
+      return option;
+    },
+    dialogTitle() {
+      const key = `${this.boxType}`;
+      if (!this.validatenull(this.boxType)) {
+        return (
+          this.crud.tableOption[key + "Title"] || this.t(`crud.${key}Title`)
+        );
+      }
+    },
+    dialogMenuPosition() {
+      return this.crud.tableOption.dialogMenuPosition || "right";
+    },
+  },
+  methods: {
+    menuParams() {
+      return {
+        disabled: this.disabled,
+        size: this.crud.size,
+        type: this.boxType,
+      };
+    },
+    submit() {
+      this.$refs.tableForm.submit();
+    },
+    reset() {
+      this.$refs.tableForm.resetForm(false);
+    },
+    getSlotName(item) {
+      return item.replace("-form", "");
+    },
+    handleChange() {
+      this.crud.setVal();
+    },
+    handleTabClick(tab, event) {
+      this.crud.$emit("tab-click", tab, event);
+    },
+    handleFullScreen() {
+      if (this.fullscreen) {
+        this.fullscreen = false;
+      } else {
+        this.fullscreen = true;
+      }
+    },
+    handleError(error) {
+      this.crud.$emit("error", error);
+    },
+    handleSubmit(form, hide) {
+      if (this.isAdd) {
+        this.rowSave(hide);
+      } else if (this.isEdit) {
+        this.rowUpdate(hide);
+      }
+    },
+    initFun() {
+      ["clearValidate", "validate", "resetForm", "validateField"].forEach(
+        (ele) => {
+          this.crud[ele] = this.$refs.tableForm[ele];
+        }
+      );
+    },
+    // 保存
+    rowSave(hide) {
+      this.crud.$emit(
+        "row-save",
+        src_utils_util.filterParams(this.crud.tableForm, ["$"]),
+        this.closeDialog,
+        hide
+      );
+    },
+    // 更新
+    rowUpdate(hide) {
+      this.crud.$emit(
+        "row-update",
+        src_utils_util.filterParams(this.crud.tableForm, ["$"]),
+        this.crud.tableIndex,
+        this.closeDialog,
+        hide
+      );
+    },
+    closeDialog(row, index) {
+      row = this.deepClone(row);
+      const callback = () => {
+        if (this.isEdit) {
+          let { parentList, index } = this.crud.findData(row[this.crud.rowKey]);
+          if (parentList) {
+            const oldRow = parentList.splice(index, 1)[0];
+            row[this.crud.childrenKey] = oldRow[this.crud.childrenKey];
+            parentList.splice(index, 0, row);
+          }
+        } else if (this.isAdd) {
+          let { item } = this.crud.findData(row[this.crud.rowParentKey]);
+          if (item) {
+            if (!item[this.crud.childrenKey]) {
+              item[this.crud.childrenKey] = [];
+            }
+            if (this.crud.tableOption.lazy) {
+              item[this.crud.hasChildrenKey] = true;
+            }
+            item[this.crud.childrenKey].push(row);
+          } else {
+            this.crud.list.push(row);
+          }
+        }
+      };
+      if (row) callback();
+      this.hide();
+    },
+    // 隐藏表单
+    hide(done) {
+      const callback = () => {
+        done && done();
+        this.crud.tableIndex = -1;
+        this.crud.tableForm = {};
+        this.crud.setVal();
+        this.boxVisible = false;
+      };
+      if (typeof this.crud.beforeClose === "function") {
+        this.crud.beforeClose(callback, this.boxType);
+      } else {
+        callback();
+      }
+    },
+    // 显示表单
+    show(type) {
+      this.boxType = type;
+      const callback = (fn) => {
+        this.fullscreen = this.crud.tableOption.dialogFullscreen;
+        this.boxVisible = true;
+        this.loading = false;
+        this.$nextTick(() => {
+          this.initFun();
+          fn && fn();
+        });
+      };
+      const loading = () => {
+        callback(() => {
+          this.loading = true;
+        });
+      };
+      if (typeof this.crud.beforeOpen === "function") {
+        this.crud.beforeOpen(callback, this.boxType, loading);
+      } else {
+        callback();
+      }
+    },
+  },
+});
+
+exports.default = script;

package/lib/packages/element-plus/crud/dialog/dialog-form3.js

@@ -0,0 +1,143 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+var vue = require('vue');
+
+const _hoisted_1 = { class: "el-dialog__title" };
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_icon = vue.resolveComponent("el-icon");
+  const _component_avue_form = vue.resolveComponent("avue-form");
+  const _component_el_button = vue.resolveComponent("el-button");
+  const _directive_loading = vue.resolveDirective("loading");
+
+  return (_ctx.boxVisible)
+    ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.dialogType), vue.mergeProps({
+        key: 0,
+        draggable: _ctx.validData(_ctx.crud.tableOption.dialogDrag, _ctx.config.dialogDrag),
+        class: [
+      'avue-dialog',
+      _ctx.b('dialog'),
+      this.crud.tableOption.dialogCustomClass,
+    ],
+        "append-to-body": _ctx.validData(_ctx.crud.tableOption.dialogAppendToBody, true),
+        top: _ctx.dialogTop,
+        title: _ctx.dialogTitle,
+        "close-on-press-escape": _ctx.crud.tableOption.dialogEscape,
+        "close-on-click-modal": _ctx.validData(_ctx.crud.tableOption.dialogClickModal, false),
+        modal: _ctx.crud.tableOption.dialogModal,
+        "modal-penetrable": _ctx.crud.tableOption.modalPenetrable,
+        "show-close": _ctx.crud.tableOption.dialogCloseBtn,
+        "header-class": _ctx.crud.tableOption.headerClass,
+        "body-class": _ctx.crud.tableOption.bodyClass,
+        "footer-class": _ctx.crud.tableOption.footerClass,
+        modelValue: _ctx.boxVisible,
+        "onUpdate:modelValue": _cache[2] || (_cache[2] = $event => ((_ctx.boxVisible) = $event))
+      }, _ctx.params, { "before-close": _ctx.hide }), {
+        header: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(_ctx.b('dialog__header'))
+          }, [
+            vue.createElementVNode("span", _hoisted_1, vue.toDisplayString(_ctx.dialogTitle), 1 /* TEXT */),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(_ctx.b('dialog__menu'))
+            }, [
+              vue.createVNode(_component_el_icon, {
+                class: "el-dialog__close",
+                onClick: _ctx.handleFullScreen
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.fullscreen ? 'el-icon-copy-document' : 'el-icon-full-screen')))
+                ]),
+                _: 1 /* STABLE */
+              }, 8 /* PROPS */, ["onClick"])
+            ], 2 /* CLASS */)
+          ], 2 /* CLASS */)
+        ]),
+        default: vue.withCtx(() => [
+          vue.withDirectives((vue.openBlock(), vue.createBlock(_component_avue_form, vue.mergeProps({
+            modelValue: _ctx.crud.tableForm,
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((_ctx.crud.tableForm) = $event)),
+            status: _ctx.disabled,
+            "onUpdate:status": _cache[1] || (_cache[1] = $event => ((_ctx.disabled) = $event)),
+            ref: "tableForm",
+            onChange: _ctx.handleChange,
+            onSubmit: _ctx.handleSubmit,
+            onResetChange: _ctx.hide,
+            onTabClick: _ctx.handleTabClick,
+            onError: _ctx.handleError
+          }, _ctx.$uploadFun(null, _ctx.crud), {
+            "element-loading-text": _ctx.crud.tableOption.loadingText,
+            "element-loading-spinner": _ctx.crud.tableOption.loadingSpinner,
+            "element-loading-svg": _ctx.crud.tableOption.loadingSvg,
+            "element-loading-background": _ctx.crud.tableOption.loadingBackground,
+            option: _ctx.option
+          }), vue.createSlots({ _: 2 /* DYNAMIC */ }, [
+            vue.renderList(_ctx.crud.formSlot, (item) => {
+              return {
+                name: _ctx.getSlotName(item),
+                fn: vue.withCtx((scope) => [
+                  vue.renderSlot(_ctx.$slots, item, vue.normalizeProps(vue.guardReactiveProps(Object.assign(scope, { type: _ctx.boxType }))))
+                ])
+              }
+            })
+          ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["modelValue", "status", "onChange", "onSubmit", "onResetChange", "onTabClick", "onError", "element-loading-text", "element-loading-spinner", "element-loading-svg", "element-loading-background", "option"])), [
+            [_directive_loading, _ctx.loading]
+          ]),
+          vue.createElementVNode("span", {
+            class: vue.normalizeClass(["avue-dialog__footer", 'avue-dialog__footer--' + _ctx.dialogMenuPosition])
+          }, [
+            vue.renderSlot(_ctx.$slots, "menu-form-before", vue.normalizeProps(vue.guardReactiveProps(_ctx.menuParams()))),
+            (_ctx.validData(_ctx.option.mockBtn, false) && !_ctx.isView)
+              ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                  key: 0,
+                  type: "primary",
+                  onClick: (_ctx.$refs.tableForm || {}).handleMock,
+                  loading: _ctx.disabled || _ctx.loading,
+                  size: _ctx.crud.size,
+                  icon: _ctx.option.mockIcon
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.option.mockText), 1 /* TEXT */)
+                  ]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["onClick", "loading", "size", "icon"]))
+              : vue.createCommentVNode("v-if", true),
+            (_ctx.validData(_ctx.option.submitBtn, true) && !_ctx.isView)
+              ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                  key: 1,
+                  onClick: _ctx.submit,
+                  loading: _ctx.disabled || _ctx.loading,
+                  size: _ctx.crud.size,
+                  icon: _ctx.option.submitIcon,
+                  type: "primary"
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.option.submitText), 1 /* TEXT */)
+                  ]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["onClick", "loading", "size", "icon"]))
+              : vue.createCommentVNode("v-if", true),
+            (_ctx.validData(_ctx.option.emptyBtn, true) && !_ctx.isView)
+              ? (vue.openBlock(), vue.createBlock(_component_el_button, {
+                  key: 2,
+                  onClick: _ctx.reset,
+                  disabled: _ctx.disabled || _ctx.loading,
+                  size: _ctx.crud.size,
+                  icon: _ctx.option.emptyIcon
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.option.emptyText), 1 /* TEXT */)
+                  ]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["onClick", "disabled", "size", "icon"]))
+              : vue.createCommentVNode("v-if", true),
+            vue.renderSlot(_ctx.$slots, "menu-form", vue.normalizeProps(vue.guardReactiveProps(_ctx.menuParams())))
+          ], 2 /* CLASS */)
+        ]),
+        _: 3 /* FORWARDED */
+      }, 16 /* FULL_PROPS */, ["draggable", "class", "append-to-body", "top", "title", "close-on-press-escape", "close-on-click-modal", "modal", "modal-penetrable", "show-close", "header-class", "body-class", "footer-class", "modelValue", "before-close"]))
+    : vue.createCommentVNode("v-if", true)
+}
+
+exports.render = render;

package/lib/packages/element-plus/crud/grid/index.js

@@ -0,0 +1,12 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_vue_vue_type_script_lang = require('./index2.js');
+var index_vue_vue_type_template_id_668ced3a_lang = require('./index3.js');
+
+index_vue_vue_type_script_lang.default.render = index_vue_vue_type_template_id_668ced3a_lang.render;
+index_vue_vue_type_script_lang.default.__file = "packages/element-plus/crud/grid/index.vue";
+
+exports.default = index_vue_vue_type_script_lang.default;

package/lib/packages/element-plus/crud/grid/index2.js

@@ -0,0 +1,184 @@
+/*! Avue.js v3.8.6 | (c) 2017-2026 Smallwei | Released under the MIT License. */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var src_core_create = require('../../../../src/core/create.js');
+var src_core_locale = require('../../../../src/core/locale.js');
+
+var script = src_core_create.default({
+  name: "crud__grid",
+  inject: ["crud"],
+  mixins: [src_core_locale.default],
+  provide() {
+    return {
+      dynamic: this,
+    };
+  },
+  props: {
+    rowStyle: Function,
+    cellStyle: Function,
+    cellClassName: Function,
+    rowClassName: Function,
+    height: [String, Number],
+    data: Array,
+  },
+  data() {
+    return {
+      checkList: [],
+      span: 8,
+      xsSpan: 12,
+      id: "crud-grid",
+      column: [],
+    };
+  },
+  computed: {
+    styleName() {
+      return {
+        height: this.crud.tableHeight + "px",
+      };
+    },
+  },
+  methods: {
+    doLayout() {},
+    //表格筛选逻辑
+    handleFilterMethod(params) {
+      const { value, row, column } = params;
+      if (typeof column.filterMethod === "function") {
+        return column.filterMethod(value, row, column);
+      } else {
+        return row[column.prop] == value;
+      }
+    },
+    //表格筛选字典
+    handleFilters(column) {
+      if (Array.isArray(column.filters))
+        return column.filters.map((ele) => ({
+          text: ele.label,
+          value: ele.value,
+        }));
+      if (column.filters !== true) return undefined;
+      let DIC = this.crud.DIC[column.prop] || [];
+      let list = [];
+      if (!this.validatenull(DIC)) {
+        DIC.forEach((ele) => {
+          const props = column.props || this.crud.tableOption.props || {};
+          list.push({
+            text: ele[props.label || DIC_PROPS.label],
+            value: ele[props.value || DIC_PROPS.value],
+          });
+        });
+      } else {
+        this.crud.cellForm.list.forEach((ele) => {
+          if (!list.map((item) => item.text).includes(ele[column.prop])) {
+            list.push({
+              text: ele[column.prop],
+              value: ele[column.prop],
+            });
+          }
+        });
+      }
+      return list;
+    },
+    getColumnProp(column, type, params) {
+      let obj = column || {};
+      if (type === "filterMethod") return this.handleFilterMethod(params);
+      if (this.crud.isMobile && ["fixed"].includes(type)) return false;
+      let result = obj?.[type];
+      if (type == "width" && result == 0) {
+        return undefined;
+      }
+      if (type == "filters") return this.handleFilters(column);
+      if (type == "hide") return obj?.hide !== true;
+      else return result;
+    },
+    isDisabled(row, index) {
+      return typeof this.crud.tableOption.selectable === "function"
+        ? !this.crud.tableOption.selectable(row, index)
+        : false;
+    },
+    clearSelection() {
+      this.checkList = [];
+      this.checkListChange(this.checkList);
+    },
+    toggleAllSelection() {
+      if (this.checkList.length === this.crud.data.length) {
+        this.checkList = [];
+      } else {
+        this.checkList = this.crud.data.map((ele, index) => index);
+      }
+      this.checkListChange(this.checkList);
+    },
+    toggleRowSelection(data, selected) {
+      let index = this.crud.data.findIndex(
+        (ele) => JSON.stringify(ele) == JSON.stringify(data)
+      );
+      if (selected && index != -1) {
+        this.checkList.push(index);
+      } else {
+        let checkIndex = this.checkList.findIndex((ele) => ele == index);
+        this.checkList.splice(checkIndex, 1);
+      }
+      this.checkListChange(this.checkList);
+    },
+    checkListChange(val) {
+      let result = [];
+      const data = this.crud.data;
+      val.forEach((ele) => {
+        result.push(data[ele]);
+      });
+      this.$emit("selection-change", result);
+    },
+    handleRowDblClick(row, index) {
+      this.$emit("row-dblclick", row, index);
+    },
+    handleRowClick(row, index) {
+      this.$emit("row-click", row, index);
+    },
+    handleCellDblClick(row, column) {
+      this.$emit("cell-dblclick", row, column);
+    },
+    handleCellClick(row, column) {
+      this.$emit("cell-click", row, column);
+    },
+    getGradientColor(row, index) {
+      let styles = {};
+      if (typeof this.crud.tableOption.gridBackground == "function") {
+        styles.background = this.crud.tableOption.gridBackground(row, index);
+      } else if (this.crud.tableOption.gridBackgroundImage) {
+        styles.backgroundImage = `url(${this.crud.tableOption.gridBackgroundImage})`;
+      } else {
+        styles.background =
+          this.crud.tableOption.gridBackground ||
+          "linear-gradient(to bottom, rgba(88, 159, 248, 0.1), white)";
+      }
+      return styles;
+    },
+    getCellStyle(row, index, column, columnIndex) {
+      if (this.cellStyle)
+        return this.cellStyle({ row, rowIndex: index, column, columnIndex });
+    },
+    getRowStyle(row, index) {
+      if (this.rowStyle) return this.rowStyle({ row, rowIndex: index });
+    },
+    getRowClass(row, index) {
+      if (this.rowClassName) return this.rowClassName({ row, rowIndex: index });
+    },
+    getClass(row, index, column) {
+      let list = [];
+      let firstIndex = this.crud.columnOption.findIndex(
+        (item) => item.hide !== true
+      );
+      const columnOption = this.crud.columnOption || [];
+      if (this.cellClassName)
+        list.push(this.cellClassName({ row, rowIndex: index, column }));
+      if (column.prop == (columnOption[firstIndex || 0] || {}).prop)
+        list.push("title");
+      if (column.row) list.push("row");
+      if (column.showOverflowTooltip) list.push("overHidden");
+      return list;
+    },
+  },
+});
+
+exports.default = script;