@fecp/mobile 1.1.23 → 1.1.24

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/export/export-panel.js

@@ -0,0 +1,478 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+require("../../../ui/index.js");
+const index = require("../../../../../../../../../_virtual/index.js");
+const utils = require("../../../ui/src/utils.js");
+const log = require("../../../ui/src/log.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getI18n, getIcon } = index_esm.VxeUI;
+const TableExportPanelComponent = vue.defineComponent({
+  name: "VxeTableExportPanel",
+  props: {
+    defaultOptions: Object,
+    storeData: Object
+  },
+  setup(props) {
+    const VxeUIModalComponent = index_esm.VxeUI.getComponent("VxeModal");
+    const VxeUIButtonComponent = index_esm.VxeUI.getComponent("VxeButton");
+    const VxeUISelectComponent = index_esm.VxeUI.getComponent("VxeSelect");
+    const VxeUIInputComponent = index_esm.VxeUI.getComponent("VxeInput");
+    const VxeUICheckboxComponent = index_esm.VxeUI.getComponent("VxeCheckbox");
+    const $xeTable = vue.inject("$xeTable", {});
+    const { computeExportOpts, computePrintOpts } = $xeTable.getComputeMaps();
+    const reactData = vue.reactive({
+      isAll: false,
+      isIndeterminate: false,
+      loading: false
+    });
+    const xButtonConfirm = vue.ref();
+    const xInputFilename = vue.ref();
+    const xInputSheetname = vue.ref();
+    const computeCheckedAll = vue.computed(() => {
+      const { storeData } = props;
+      return storeData.columns.every((column) => column.checked);
+    });
+    const computeShowSheet = vue.computed(() => {
+      const { defaultOptions } = props;
+      return ["html", "xml", "xlsx", "pdf"].indexOf(defaultOptions.type) > -1;
+    });
+    const computeSupportMerge = vue.computed(() => {
+      const { storeData, defaultOptions } = props;
+      return !defaultOptions.original && defaultOptions.mode === "current" && (storeData.isPrint || ["html", "xlsx"].indexOf(defaultOptions.type) > -1);
+    });
+    const computeSupportStyle = vue.computed(() => {
+      const { defaultOptions } = props;
+      return !defaultOptions.original && ["xlsx"].indexOf(defaultOptions.type) > -1;
+    });
+    const handleOptionCheck = (column) => {
+      const { storeData } = props;
+      const matchObj = index.default.findTree(storeData.columns, (item) => item === column);
+      if (matchObj && matchObj.parent) {
+        const { parent } = matchObj;
+        if (parent.children && parent.children.length) {
+          parent.checked = parent.children.every((column2) => column2.checked);
+          parent.halfChecked = !parent.checked && parent.children.some((column2) => column2.checked || column2.halfChecked);
+          handleOptionCheck(parent);
+        }
+      }
+    };
+    const checkStatus = () => {
+      const { storeData } = props;
+      const columns = storeData.columns;
+      reactData.isAll = columns.every((column) => column.disabled || column.checked);
+      reactData.isIndeterminate = !reactData.isAll && columns.some((column) => !column.disabled && (column.checked || column.halfChecked));
+    };
+    const changeOption = (column) => {
+      const isChecked = !column.checked;
+      index.default.eachTree([column], (item) => {
+        item.checked = isChecked;
+        item.halfChecked = false;
+      });
+      handleOptionCheck(column);
+      checkStatus();
+    };
+    const allColumnEvent = () => {
+      const { storeData } = props;
+      const isAll = !reactData.isAll;
+      index.default.eachTree(storeData.columns, (column) => {
+        if (!column.disabled) {
+          column.checked = isAll;
+          column.halfChecked = false;
+        }
+      });
+      reactData.isAll = isAll;
+      checkStatus();
+    };
+    const showEvent = () => {
+      vue.nextTick(() => {
+        const filenameInp = xInputFilename.value;
+        const sheetnameInp = xInputSheetname.value;
+        const confirmBtn = xButtonConfirm.value;
+        const targetElem = filenameInp || sheetnameInp || confirmBtn;
+        if (targetElem) {
+          targetElem.focus();
+        }
+      });
+      checkStatus();
+    };
+    const getExportOption = () => {
+      const { storeData, defaultOptions } = props;
+      const { hasMerge, columns } = storeData;
+      const checkedAll = computeCheckedAll.value;
+      const supportMerge = computeSupportMerge.value;
+      const expColumns = index.default.searchTree(columns, (column) => column.checked, { children: "children", mapChildren: "childNodes", original: true });
+      return Object.assign({}, defaultOptions, {
+        columns: expColumns,
+        isMerge: hasMerge && supportMerge && checkedAll ? defaultOptions.isMerge : false
+      });
+    };
+    const printEvent = () => {
+      const { storeData } = props;
+      const printOpts = computePrintOpts.value;
+      storeData.visible = false;
+      $xeTable.print(Object.assign({}, printOpts, getExportOption()));
+    };
+    const exportEvent = () => {
+      const { storeData } = props;
+      const exportOpts = computeExportOpts.value;
+      reactData.loading = true;
+      $xeTable.exportData(Object.assign({}, exportOpts, getExportOption())).then(() => {
+        reactData.loading = false;
+        storeData.visible = false;
+      }).catch(() => {
+        reactData.loading = false;
+      });
+    };
+    const cancelEvent = () => {
+      const { storeData } = props;
+      storeData.visible = false;
+    };
+    const confirmEvent = () => {
+      const { storeData } = props;
+      if (storeData.isPrint) {
+        printEvent();
+      } else {
+        exportEvent();
+      }
+    };
+    const renderVN = () => {
+      const $xeGrid = $xeTable.xeGrid;
+      const { defaultOptions, storeData } = props;
+      const { isAll: isAllChecked, isIndeterminate: isAllIndeterminate } = reactData;
+      const { hasTree, hasMerge, isPrint, hasColgroup, columns } = storeData;
+      const { isHeader } = defaultOptions;
+      const cols = [];
+      const checkedAll = computeCheckedAll.value;
+      const showSheet = computeShowSheet.value;
+      const supportMerge = computeSupportMerge.value;
+      const supportStyle = computeSupportStyle.value;
+      const slots = defaultOptions.slots || {};
+      const topSlot = slots.top;
+      const bottomSlot = slots.bottom;
+      const defaultSlot = slots.default;
+      const footerSlot = slots.footer;
+      const parameterSlot = slots.parameter;
+      index.default.eachTree(columns, (column) => {
+        const colTitle = utils.formatText(column.getTitle(), 1);
+        const isColGroup = column.children && column.children.length;
+        const isChecked = column.checked;
+        const indeterminate = column.halfChecked;
+        const isHtml = column.type === "html";
+        cols.push(vue.h("li", {
+          key: column.id,
+          class: ["vxe-table-export--panel-column-option", `level--${column.level}`, {
+            "is--group": isColGroup,
+            "is--checked": isChecked,
+            "is--indeterminate": indeterminate,
+            "is--disabled": column.disabled
+          }],
+          title: isHtml ? "" : colTitle,
+          onClick: () => {
+            if (!column.disabled) {
+              changeOption(column);
+            }
+          }
+        }, [
+          vue.h("span", {
+            class: ["vxe-checkbox--icon", indeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+          }),
+          isHtml ? vue.h("span", {
+            key: "1",
+            class: "vxe-checkbox--label",
+            innerHTML: colTitle
+          }) : vue.h("span", {
+            key: "0",
+            class: "vxe-checkbox--label"
+          }, colTitle)
+        ]));
+      });
+      return VxeUIModalComponent ? vue.h(VxeUIModalComponent, {
+        id: "VXE_EXPORT_MODAL",
+        modelValue: storeData.visible,
+        title: getI18n(isPrint ? "vxe.export.printTitle" : "vxe.export.expTitle"),
+        className: "vxe-table-export-popup-wrapper",
+        width: 660,
+        minWidth: 500,
+        minHeight: 400,
+        mask: true,
+        lockView: true,
+        showFooter: true,
+        escClosable: true,
+        maskClosable: true,
+        showMaximize: true,
+        resize: true,
+        loading: reactData.loading,
+        "onUpdate:modelValue"(value) {
+          storeData.visible = value;
+        },
+        onShow: showEvent
+      }, {
+        default: () => {
+          const params = {
+            $table: $xeTable,
+            $grid: $xeGrid,
+            options: defaultOptions,
+            columns,
+            params: defaultOptions.params
+          };
+          const hasEmptyData = defaultOptions.mode === "empty";
+          return vue.h("div", {
+            class: "vxe-table-export--panel"
+          }, [
+            topSlot ? vue.h("div", {
+              class: "vxe-table-export--panel-top"
+            }, $xeTable.callSlot(topSlot, params)) : vue.createCommentVNode(),
+            vue.h("div", {
+              class: "vxe-table-export--panel-body"
+            }, defaultSlot ? $xeTable.callSlot(defaultSlot, params) : [
+              vue.h("table", {
+                class: "vxe-table-export--panel-table",
+                cellspacing: 0,
+                cellpadding: 0,
+                border: 0
+              }, [
+                vue.h("tbody", [
+                  [
+                    isPrint ? vue.createCommentVNode() : vue.h("tr", [
+                      vue.h("td", getI18n("vxe.export.expName")),
+                      vue.h("td", [
+                        VxeUIInputComponent ? vue.h(VxeUIInputComponent, {
+                          ref: xInputFilename,
+                          modelValue: defaultOptions.filename,
+                          type: "text",
+                          clearable: true,
+                          placeholder: getI18n("vxe.export.expNamePlaceholder"),
+                          "onUpdate:modelValue"(value) {
+                            defaultOptions.filename = value;
+                          }
+                        }) : vue.createCommentVNode()
+                      ])
+                    ]),
+                    isPrint ? vue.createCommentVNode() : vue.h("tr", [
+                      vue.h("td", getI18n("vxe.export.expType")),
+                      vue.h("td", [
+                        VxeUISelectComponent ? vue.h(VxeUISelectComponent, {
+                          modelValue: defaultOptions.type,
+                          options: storeData.typeList,
+                          "onUpdate:modelValue"(value) {
+                            defaultOptions.type = value;
+                          }
+                        }) : vue.createCommentVNode()
+                      ])
+                    ]),
+                    isPrint || showSheet ? vue.h("tr", [
+                      vue.h("td", getI18n("vxe.export.expSheetName")),
+                      vue.h("td", [
+                        VxeUIInputComponent ? vue.h(VxeUIInputComponent, {
+                          ref: xInputSheetname,
+                          modelValue: defaultOptions.sheetName,
+                          type: "text",
+                          clearable: true,
+                          placeholder: getI18n("vxe.export.expSheetNamePlaceholder"),
+                          "onUpdate:modelValue"(value) {
+                            defaultOptions.sheetName = value;
+                          }
+                        }) : vue.createCommentVNode()
+                      ])
+                    ]) : vue.createCommentVNode(),
+                    vue.h("tr", [
+                      vue.h("td", getI18n("vxe.export.expMode")),
+                      vue.h("td", [
+                        VxeUISelectComponent ? vue.h(VxeUISelectComponent, {
+                          modelValue: defaultOptions.mode,
+                          options: storeData.modeList.map((item) => {
+                            return {
+                              value: item.value,
+                              label: getI18n(item.label)
+                            };
+                          }),
+                          "onUpdate:modelValue"(value) {
+                            defaultOptions.mode = value;
+                          }
+                        }) : vue.createCommentVNode()
+                      ])
+                    ]),
+                    vue.h("tr", [
+                      vue.h("td", [getI18n("vxe.export.expColumn")]),
+                      vue.h("td", [
+                        vue.h("div", {
+                          class: "vxe-table-export--panel-column"
+                        }, [
+                          vue.h("ul", {
+                            class: "vxe-table-export--panel-column-header"
+                          }, [
+                            vue.h("li", {
+                              class: ["vxe-table-export--panel-column-option", {
+                                "is--checked": isAllChecked,
+                                "is--indeterminate": isAllIndeterminate
+                              }],
+                              title: getI18n("vxe.table.allTitle"),
+                              onClick: allColumnEvent
+                            }, [
+                              vue.h("span", {
+                                class: ["vxe-checkbox--icon", isAllIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isAllChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+                              }),
+                              vue.h("span", {
+                                class: "vxe-checkbox--label"
+                              }, getI18n("vxe.export.expCurrentColumn"))
+                            ])
+                          ]),
+                          vue.h("ul", {
+                            class: "vxe-table-export--panel-column-body"
+                          }, cols)
+                        ])
+                      ])
+                    ]),
+                    vue.h("tr", [
+                      vue.h("td", getI18n("vxe.export.expOpts")),
+                      parameterSlot ? vue.h("td", [
+                        vue.h("div", {
+                          class: "vxe-table-export--panel-option-row"
+                        }, $xeTable.callSlot(parameterSlot, params))
+                      ]) : vue.h("td", [
+                        vue.h("div", {
+                          class: "vxe-table-export--panel-option-row"
+                        }, [
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: hasEmptyData || isHeader,
+                            disabled: hasEmptyData,
+                            title: getI18n("vxe.export.expHeaderTitle"),
+                            content: getI18n("vxe.export.expOptHeader"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isHeader = value;
+                            }
+                          }) : vue.createCommentVNode(),
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: isHeader ? defaultOptions.isTitle : false,
+                            disabled: !isHeader,
+                            title: getI18n("vxe.export.expTitleTitle"),
+                            content: getI18n("vxe.export.expOptTitle"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isTitle = value;
+                            }
+                          }) : vue.createCommentVNode(),
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: isHeader && hasColgroup && supportMerge ? defaultOptions.isColgroup : false,
+                            title: getI18n("vxe.export.expColgroupTitle"),
+                            disabled: !isHeader || !hasColgroup || !supportMerge,
+                            content: getI18n("vxe.export.expOptColgroup"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isColgroup = value;
+                            }
+                          }) : vue.createCommentVNode()
+                        ]),
+                        vue.h("div", {
+                          class: "vxe-table-export--panel-option-row"
+                        }, [
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: hasEmptyData ? false : defaultOptions.original,
+                            disabled: hasEmptyData,
+                            title: getI18n("vxe.export.expOriginalTitle"),
+                            content: getI18n("vxe.export.expOptOriginal"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.original = value;
+                            }
+                          }) : vue.createCommentVNode(),
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: hasMerge && supportMerge && checkedAll ? defaultOptions.isMerge : false,
+                            title: getI18n("vxe.export.expMergeTitle"),
+                            disabled: hasEmptyData || !hasMerge || !supportMerge || !checkedAll,
+                            content: getI18n("vxe.export.expOptMerge"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isMerge = value;
+                            }
+                          }) : vue.createCommentVNode(),
+                          isPrint || !VxeUICheckboxComponent ? vue.createCommentVNode() : vue.h(VxeUICheckboxComponent, {
+                            modelValue: supportStyle ? defaultOptions.useStyle : false,
+                            disabled: !supportStyle,
+                            title: getI18n("vxe.export.expUseStyleTitle"),
+                            content: getI18n("vxe.export.expOptUseStyle"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.useStyle = value;
+                            }
+                          }),
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: hasTree ? defaultOptions.isAllExpand : false,
+                            disabled: hasEmptyData || !hasTree,
+                            title: getI18n("vxe.export.expAllExpandTitle"),
+                            content: getI18n("vxe.export.expOptAllExpand"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isAllExpand = value;
+                            }
+                          }) : vue.createCommentVNode()
+                        ]),
+                        vue.h("div", {
+                          class: "vxe-table-export--panel-option-row"
+                        }, [
+                          VxeUICheckboxComponent ? vue.h(VxeUICheckboxComponent, {
+                            modelValue: defaultOptions.isFooter,
+                            disabled: !storeData.hasFooter,
+                            title: getI18n("vxe.export.expFooterTitle"),
+                            content: getI18n("vxe.export.expOptFooter"),
+                            "onUpdate:modelValue"(value) {
+                              defaultOptions.isFooter = value;
+                            }
+                          }) : vue.createCommentVNode()
+                        ])
+                      ])
+                    ])
+                  ]
+                ])
+              ])
+            ]),
+            bottomSlot ? vue.h("div", {
+              class: "vxe-table-export--panel-bottom"
+            }, $xeTable.callSlot(bottomSlot, params)) : vue.createCommentVNode()
+          ]);
+        },
+        footer() {
+          const params = {
+            $table: $xeTable,
+            $grid: $xeGrid,
+            options: defaultOptions,
+            columns,
+            params: defaultOptions.params
+          };
+          return vue.h("div", {
+            class: "vxe-table-export--panel-footer"
+          }, footerSlot ? $xeTable.callSlot(footerSlot, params) : [
+            vue.h("div", {
+              class: "vxe-table-export--panel-btns"
+            }, [
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                content: getI18n("vxe.export.expCancel"),
+                onClick: cancelEvent
+              }) : vue.createCommentVNode(),
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                ref: xButtonConfirm,
+                status: "primary",
+                content: getI18n(isPrint ? "vxe.export.expPrint" : "vxe.export.expConfirm"),
+                onClick: confirmEvent
+              }) : vue.createCommentVNode()
+            ])
+          ]);
+        }
+      }) : vue.createCommentVNode();
+    };
+    vue.nextTick(() => {
+      if (!VxeUIModalComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-modal"]);
+      }
+      if (!VxeUIButtonComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-button"]);
+      }
+      if (!VxeUISelectComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-select"]);
+      }
+      if (!VxeUIInputComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-input"]);
+      }
+      if (!VxeUICheckboxComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-checkbox"]);
+      }
+    });
+    return renderVN;
+  }
+});
+exports.default = TableExportPanelComponent;