@ctzy-web-client/plugin-component-vue 1.0.9 → 1.0.11

package/lib/datatable-settings/datatable-settings.js

@@ -0,0 +1,313 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var ElementPlus = require('element-plus');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var index = require('../drag-list/index.js');
+var rxjs = require('rxjs');
+var db = require('../utils/db.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({ name: "BwaDataTableSetting" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    dataTable: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const attrs = vue.useAttrs();
+    const ns = webBaseClientVue.useNamespace("datatable-settings");
+    const value = vue.ref(false);
+    const appName = webBaseClientVue.useValue("AppName");
+    const userService = webBaseClientVue.useService("UserService");
+    const userID = vue.computed(() => {
+      var _a, _b;
+      return ((_b = (_a = vue.unref(userService)) == null ? void 0 : _a.userInfo) == null ? void 0 : _b.id) || "";
+    });
+    const isShowResetColumn = vue.computed(
+      () => !props.dataTable.isDefaultColumnSort()
+    );
+    const key = vue.computed(
+      () => `${vue.unref(appName)}_${props.dataTable.name}_settings`
+    );
+    const search = vue.ref("");
+    const columns = vue.computed(
+      () => props.dataTable.getColumns().filter((column) => column.settings.visible).filter((column) => column.settings.visible)
+    );
+    const initColumns = async () => {
+      var _a, _b, _c;
+      let persistentColumnInfos = [];
+      const result = await db.dataModelDB.tableHeaderSettings.where("[app+tableName+userID]").equals([vue.unref(appName), props.dataTable.name, vue.unref(userID)]).toArray();
+      if (result.length) {
+        persistentColumnInfos = (_b = (_a = result[0]) == null ? void 0 : _a.columnInfo) != null ? _b : [];
+      }
+      if (persistentColumnInfos.some((item) => typeof item === "string")) {
+        persistentColumnInfos = persistentColumnInfos.map((columnInfo) => {
+          return typeof columnInfo === "object" ? columnInfo : { name: columnInfo, visible: true };
+        });
+      }
+      const _dataTable = props.dataTable;
+      let dataTableColumns = _dataTable.getColumns().slice().filter((item) => item.settings.visible);
+      persistentColumnInfos = persistentColumnInfos.filter(
+        (item) => dataTableColumns.findIndex((column) => column.name === item.name) !== -1
+      );
+      if (!persistentColumnInfos) {
+        return dataTableColumns;
+      }
+      let sortedColumns = persistentColumnInfos.map(
+        (columnInfo) => dataTableColumns.find((column) => column.name === columnInfo.name)
+      ).filter(Boolean);
+      dataTableColumns = sortedColumns.concat(
+        dataTableColumns.filter(
+          (column) => !sortedColumns.find((col) => column.name === col.name)
+        )
+      );
+      for (const column of dataTableColumns) {
+        const persistentItem = persistentColumnInfos.find(
+          (item) => item.name === column.name
+        );
+        column.visible = (_c = persistentItem == null ? void 0 : persistentItem.visible) != null ? _c : column.visible;
+      }
+      props.dataTable.setDisplayColumns(
+        dataTableColumns.filter((column) => column.visible)
+      );
+      return dataTableColumns;
+    };
+    const resetColumns = () => {
+      const _dataTable = props.dataTable;
+      _dataTable.resetColumnSort();
+    };
+    const allSearchedColumns = vue.computed(() => {
+      const _search = vue.unref(search);
+      return vue.unref(columns).filter((column) => column.title.indexOf(_search) > -1);
+    });
+    const hiddenSearchedColumns = vue.computed(
+      () => vue.unref(allSearchedColumns).filter((item) => !item.visible)
+    );
+    const displaySearchedColumns = vue.computed(() => {
+      const _search = vue.unref(search);
+      return props.dataTable.getDisplayColumns().filter((column) => column.settings.visible).filter((column) => column.title.indexOf(_search) > -1);
+    });
+    const handleSortChange = (sort) => {
+      const _columns = vue.unref(columns);
+      const displayColumns = sort.map(
+        (attrName) => {
+          var _a;
+          return (_a = _columns.find((column) => column.attrName === attrName)) != null ? _a : null;
+        }
+      ).filter(Boolean);
+      props.dataTable.setDisplayColumns(displayColumns);
+    };
+    const scope = vue.getCurrentScope();
+    const handleInitCompleted = async () => {
+      const dataTableColumns = await initColumns();
+      const subscription = props.dataTable.getDisplayColumnsSubject().pipe(
+        rxjs.map((displayColumns) => {
+          const hiddenColumns = dataTableColumns.filter(
+            (column) => !displayColumns.find(
+              (displayColumn) => displayColumn.attrName === column.attrName
+            )
+          );
+          return [...displayColumns, ...hiddenColumns].map((column) => ({
+            name: column.name,
+            visible: column.visible
+          }));
+        })
+      ).subscribe({
+        next: (columnInfo) => {
+          db.dataModelDB.tableHeaderSettings.put({
+            app: vue.unref(appName),
+            tableName: props.dataTable.name,
+            userID: vue.unref(userID),
+            columnInfo
+          });
+        }
+      });
+      scope.run(() => {
+        vue.onScopeDispose(() => {
+          subscription.unsubscribe();
+        });
+      });
+    };
+    if (!props.dataTable.inited) {
+      webBaseClientVue.useEventDispatcher(props.dataTable, "init-completed", handleInitCompleted);
+    } else {
+      handleInitCompleted();
+    }
+    return (_ctx, _cache) => {
+      const _component_RefreshRight = vue.resolveComponent("RefreshRight");
+      const _component_Close = vue.resolveComponent("Close");
+      return vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTooltip), vue.mergeProps({
+        visible: value.value,
+        "onUpdate:visible": _cache[2] || (_cache[2] = ($event) => value.value = $event)
+      }, vue.unref(attrs), {
+        effect: "light",
+        "show-arrow": false,
+        trigger: "click",
+        "popper-class": vue.unref(ns).b(),
+        "gpu-acceleration": false,
+        placement: "bottom",
+        "append-to": ".bwa-application"
+      }), {
+        content: vue.withCtx(() => [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ns).e("content"))
+          }, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(vue.unref(ns).e("header"))
+            }, [
+              vue.createTextVNode(" \u8868\u5934\u8BBE\u7F6E "),
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(vue.unref(ns).e("tools"))
+              }, [
+                vue.unref(isShowResetColumn) ? (vue.openBlock(), vue.createElementBlock("span", {
+                  key: 0,
+                  class: vue.normalizeClass([vue.unref(ns).e("tools-item"), vue.unref(ns).e("refresh")]),
+                  onClick: resetColumns
+                }, [
+                  vue.createVNode(vue.unref(ElementPlus.ElTooltip), {
+                    content: "\u6062\u590D\u9ED8\u8BA4",
+                    "append-to": ".bwa-application"
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(ElementPlus.ElIcon), null, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(_component_RefreshRight)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ], 2)) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass([vue.unref(ns).e("tools-item"), vue.unref(ns).e("close")]),
+                  onClick: _cache[0] || (_cache[0] = ($event) => value.value = false)
+                }, [
+                  vue.createVNode(vue.unref(ElementPlus.ElTooltip), {
+                    content: "\u5173\u95ED",
+                    "append-to": ".bwa-application"
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(ElementPlus.ElIcon), null, {
+                        default: vue.withCtx(() => [
+                          vue.createVNode(_component_Close)
+                        ]),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  })
+                ], 2)
+              ], 2)
+            ], 2),
+            vue.createCommentVNode(` <div :class="ns.e('search')">\r
+          <ElInput\r
+            v-model="search"\r
+            :clearable="true"\r
+            prefix-icon="Search"\r
+            placeholder="\u8BF7\u8F93\u5165\u5173\u952E\u8BCD\u641C\u7D22"\r
+          />\r
+        </div> `),
+            vue.createVNode(vue.unref(ElementPlus.ElScrollbar), { "max-height": "500px" }, {
+              default: vue.withCtx(() => [
+                vue.createElementVNode("div", {
+                  class: vue.normalizeClass(vue.unref(ns).e("main"))
+                }, [
+                  vue.unref(displaySearchedColumns).length ? (vue.openBlock(), vue.createElementBlock("div", {
+                    key: 0,
+                    class: vue.normalizeClass(vue.unref(ns).b("section"))
+                  }, [
+                    vue.createElementVNode("div", {
+                      class: vue.normalizeClass(vue.unref(ns).be("section", "header"))
+                    }, "\u663E\u793A\u5B57\u6BB5", 2),
+                    vue.createVNode(vue.unref(index.BwaDraglist), {
+                      data: vue.unref(displaySearchedColumns),
+                      labelAttr: "title",
+                      idAttr: "attrName",
+                      onSortChange: handleSortChange
+                    }, {
+                      default: vue.withCtx(({ item }) => [
+                        vue.createElementVNode("div", {
+                          class: vue.normalizeClass(vue.unref(ns).be("section", "content"))
+                        }, [
+                          vue.createElementVNode("div", {
+                            class: vue.normalizeClass(vue.unref(ns).e("field-item"))
+                          }, [
+                            vue.createElementVNode("span", null, vue.toDisplayString(item.title), 1),
+                            vue.createVNode(vue.unref(ElementPlus.ElSwitch), {
+                              modelValue: item.visible,
+                              "onUpdate:modelValue": ($event) => item.visible = $event,
+                              size: "small",
+                              disabled: item.settings.disabled,
+                              onMousedown: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+                              }, ["stop"]))
+                            }, null, 8, ["modelValue", "onUpdate:modelValue", "disabled"])
+                          ], 2)
+                        ], 2)
+                      ]),
+                      _: 1
+                    }, 8, ["data"]),
+                    vue.createCommentVNode(` <div\r
+                v-show="!displaySearchedColumns.length"\r
+                :class="ns.be('section', 'empty')"\r
+              >\r
+                \u6682\u65E0\u5B57\u6BB5\r
+              </div> `)
+                  ], 2)) : vue.createCommentVNode("v-if", true),
+                  vue.unref(hiddenSearchedColumns).length ? (vue.openBlock(), vue.createElementBlock("div", {
+                    key: 1,
+                    class: vue.normalizeClass(vue.unref(ns).b("section"))
+                  }, [
+                    vue.createElementVNode("div", {
+                      class: vue.normalizeClass(vue.unref(ns).be("section", "header"))
+                    }, "\u672A\u663E\u793A\u5B57\u6BB5", 2),
+                    vue.createElementVNode("div", {
+                      class: vue.normalizeClass(vue.unref(ns).be("section", "content"))
+                    }, [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(hiddenSearchedColumns), (column) => {
+                        return vue.openBlock(), vue.createElementBlock("div", {
+                          key: column.attrName,
+                          class: vue.normalizeClass(vue.unref(ns).e("field-item"))
+                        }, [
+                          vue.createElementVNode("span", null, vue.toDisplayString(column.title), 1),
+                          vue.createVNode(vue.unref(ElementPlus.ElSwitch), {
+                            modelValue: column.visible,
+                            "onUpdate:modelValue": ($event) => column.visible = $event,
+                            size: "small",
+                            disabled: column.settings.disabled
+                          }, null, 8, ["modelValue", "onUpdate:modelValue", "disabled"])
+                        ], 2);
+                      }), 128))
+                    ], 2),
+                    vue.createCommentVNode(` <div\r
+                v-show="!hiddenSearchedColumns.length"\r
+                :class="ns.be('section', 'empty')"\r
+              >\r
+                \u6682\u65E0\u5B57\u6BB5\r
+              </div> `)
+                  ], 2)) : vue.createCommentVNode("v-if", true)
+                ], 2)
+              ]),
+              _: 1
+            })
+          ], 2)
+        ]),
+        default: vue.withCtx(() => [
+          vue.createElementVNode("span", null, [
+            vue.renderSlot(_ctx.$slots, "default")
+          ])
+        ]),
+        _: 3
+      }, 16, ["visible", "popper-class"]);
+    };
+  }
+});
+var DataTableSettings = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "datatable-settings.vue"]]);
+
+exports["default"] = DataTableSettings;

package/lib/datatable-settings/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var datatableSettings = require('./datatable-settings.js');
+
+const BwaDataTableSetting = install.withInstall(datatableSettings["default"]);
+
+exports.BwaDataTableSetting = BwaDataTableSetting;
+exports["default"] = BwaDataTableSetting;

package/lib/date-range/date-picker.js

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('element-plus/es/components/date-picker/src/constants');
+var ElPanelDatePicker = require('element-plus/es/components/date-picker/src/date-picker-com/panel-date-pick');
+var utils = require('element-plus/es/components/time-picker/src/utils');
+var index = require('element-plus/es/hooks/index');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ElPanelDatePicker__default = /*#__PURE__*/_interopDefaultLegacy(ElPanelDatePicker);
+
+const __default__ = vue.defineComponent({ name: "BwaDatePicker" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    modelValue: {
+      type: [String, Date, Array]
+    },
+    visible: {
+      type: Boolean
+    },
+    format: {
+      type: String,
+      default: "YYYY-MM-DD"
+    },
+    shortcuts: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["update:modelValue", "update:visible"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ns = webBaseClientVue.useNamespace("datepicker");
+    const { lang } = index.useLocale();
+    const visible = vue.ref(false);
+    vue.watch(visible, () => {
+      emit("update:visible", visible.value);
+    });
+    vue.provide("EP_PICKER_BASE", {
+      props
+    });
+    vue.provide(constants.ROOT_PICKER_INJECTION_KEY, {
+      slots: {},
+      pickerNs: null
+    });
+    const parsedValue = vue.computed(() => {
+      return utils.parseDate(props.modelValue, props.format, lang);
+    });
+    const emitInput = (input) => {
+      if (utils.valueEquals(props.modelValue, input)) {
+        return;
+      }
+      let formatted;
+      if (Array.isArray(input)) {
+        formatted = input.map((item) => utils.formatter(item, props.format, lang.value));
+      } else {
+        formatted = utils.formatter(input, props.format, lang.value);
+      }
+      emit("update:modelValue", formatted);
+    };
+    const onPick = (date) => {
+      let result;
+      if (Array.isArray(date)) {
+        result = date.map((_) => _.toDate());
+      } else {
+        result = date ? date.toDate() : date;
+      }
+      emitInput(result);
+      visible.value = false;
+    };
+    const onClear = () => {
+      emit("update:modelValue", "");
+      visible.value = false;
+    };
+    return (_ctx, _cache) => {
+      const _component_ElButton = vue.resolveComponent("ElButton");
+      const _component_ElTooltip = vue.resolveComponent("ElTooltip");
+      return vue.openBlock(), vue.createBlock(_component_ElTooltip, {
+        trigger: "click",
+        pure: "",
+        teleported: "",
+        effect: "light",
+        role: "dialog",
+        transition: `el-zoom-in-top`,
+        "fallback-placements": ["bottom", "top", "right", "left"],
+        "gpu-acceleration": false,
+        "show-arrow": false,
+        "stop-popper-mouse-event": false,
+        visible: visible.value,
+        "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => visible.value = $event),
+        "hide-after": 0,
+        "popper-class": vue.unref(ns).b(),
+        persistent: "",
+        "append-to": ".bwa-application"
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default", { visible: visible.value })
+        ]),
+        content: vue.withCtx(() => [
+          vue.createVNode(vue.unref(ElPanelDatePicker__default["default"]), {
+            type: "date",
+            "parsed-value": vue.unref(parsedValue),
+            onPick,
+            teleported: false
+          }, {
+            sidebar: vue.withCtx(() => [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(ns).e("sidebar"))
+              }, [
+                vue.createVNode(_component_ElButton, {
+                  size: "small",
+                  onClick: onClear
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode("\u6E05\u7A7A")
+                  ]),
+                  _: 1
+                })
+              ], 2)
+            ]),
+            _: 1
+          }, 8, ["parsed-value"])
+        ]),
+        _: 3
+      }, 8, ["visible", "popper-class"]);
+    };
+  }
+});
+var datePicker = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "date-picker.vue"]]);
+
+exports["default"] = datePicker;

package/lib/date-range/date-range.js

@@ -0,0 +1,185 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var ElementPlus = require('element-plus');
+var PanelDateRange = require('element-plus/es/components/date-picker/src/props/panel-date-range.vue');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var PanelDateRange__default = /*#__PURE__*/_interopDefaultLegacy(PanelDateRange);
+
+const __default__ = vue.defineComponent({ name: "BwaDateRange" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    ...ElementPlus.timePickerDefaultProps,
+    modelValue: {
+      type: null,
+      required: true
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ns = webBaseClientVue.useNamespace("daterange");
+    const pickerVisivle = vue.ref(false);
+    const filterPanelItem = vue.inject(webBaseClientVue.filterPanelItemKey);
+    const column = vue.computed(() => {
+      var _a;
+      return (_a = filterPanelItem == null ? void 0 : filterPanelItem.column) != null ? _a : null;
+    });
+    const slots = vue.useSlots();
+    const locale = webBaseClientVue.useGlobalConfig("locale", "ZH");
+    const lang = vue.computed(() => vue.unref(locale).name);
+    vue.provide(ElementPlus.ROOT_PICKER_INJECTION_KEY, {
+      slots,
+      pickerNs: ElementPlus.useNamespace("picker-panel")
+    });
+    vue.provide("EP_PICKER_BASE", {
+      props
+    });
+    vue.watch(
+      vue.computed(() => props.modelValue),
+      () => {
+        if (!props.modelValue || Array.isArray(props.modelValue) || typeof props.modelValue !== "object") {
+          emit("update:modelValue", { start: "", end: "" });
+        }
+      },
+      { immediate: true }
+    );
+    const formatShowTime = (date) => {
+      return date ? ElementPlus.dayjs(date).format("YYYY-MM-DD") : "";
+    };
+    const startTime = vue.computed(() => {
+      var _a;
+      if (!((_a = props.modelValue) == null ? void 0 : _a.start)) {
+        return "";
+      }
+      return ElementPlus.dayjs(props.modelValue.start).set("hour", 0).set("minute", 0).set("second", 0).format("YYYY-MM-DD HH:mm:ss");
+    });
+    const endTime = vue.computed(() => {
+      var _a;
+      if (!((_a = props.modelValue) == null ? void 0 : _a.end)) {
+        return "";
+      }
+      return ElementPlus.dayjs(props.modelValue.end).set("hour", 23).set("minute", 59).set("second", 59).format("YYYY-MM-DD HH:mm:ss");
+    });
+    const formatStartTime = vue.computed(() => formatShowTime(vue.unref(startTime)));
+    const formatEndTime = vue.computed(() => formatShowTime(vue.unref(endTime)));
+    const dateRangeValue = vue.computed(() => [vue.unref(startTime), vue.unref(endTime)]);
+    const valueIsEmpty = vue.computed(() => {
+      const value = vue.unref(dateRangeValue);
+      return !value || Array.isArray(value) && !value.filter(Boolean).length;
+    });
+    const parsedValue = vue.computed(() => {
+      const { valueFormat } = props;
+      const value = vue.unref(dateRangeValue);
+      if (!vue.unref(valueIsEmpty)) {
+        return value.map((d) => ElementPlus.parseDate(d, valueFormat, vue.unref(lang)));
+      }
+      return [];
+    });
+    const emitInput = (input) => {
+      if (!ElementPlus.valueEquals(vue.unref(dateRangeValue), input)) {
+        const formatted = input.map(
+          (item) => ElementPlus.formatter(item, props.valueFormat, vue.unref(lang))
+        );
+        emit("update:modelValue", {
+          start: formatted[0] ? ElementPlus.dayjs(formatted[0]).set("hour", 0).set("minute", 0).set("second", 0).format("YYYY-MM-DD HH:mm:ss") : "",
+          end: formatted[1] ? ElementPlus.dayjs(formatted[1]).set("hour", 23).set("minute", 59).set("second", 59).format("YYYY-MM-DD HH:mm:ss") : ""
+        });
+      }
+    };
+    const onPick = (date, visible = false) => {
+      pickerVisivle.value = visible;
+      emitInput(date.map((item) => item.toDate()));
+    };
+    return (_ctx, _cache) => {
+      const _component_CaretBottom = vue.resolveComponent("CaretBottom");
+      const _component_ElIcon = vue.resolveComponent("ElIcon");
+      const _component_ElTooltip = vue.resolveComponent("ElTooltip");
+      return vue.openBlock(), vue.createBlock(_component_ElTooltip, {
+        visible: pickerVisivle.value,
+        "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => pickerVisivle.value = $event),
+        pure: "",
+        teleported: "",
+        effect: "light",
+        role: "dialog",
+        transition: `el-zoom-in-top`,
+        "fallback-placements": ["bottom", "top", "right", "left"],
+        "gpu-acceleration": false,
+        "show-arrow": false,
+        "stop-popper-mouse-event": false,
+        "hide-after": 0,
+        persistent: "",
+        trigger: "click",
+        "append-to": ".bwa-application"
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "pct-default", {
+            formatStartTime: vue.unref(formatStartTime),
+            formatEndTime: vue.unref(formatEndTime)
+          }, () => [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is("active", pickerVisivle.value)])
+            }, [
+              vue.renderSlot(_ctx.$slots, "label", {}, () => [
+                vue.unref(column) ? (vue.openBlock(), vue.createElementBlock("span", {
+                  key: 0,
+                  class: vue.normalizeClass(vue.unref(ns).e("label"))
+                }, vue.toDisplayString(vue.unref(column).title), 3)) : vue.createCommentVNode("v-if", true)
+              ]),
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass([vue.unref(ns).e("time"), vue.unref(ns).is("empty", !vue.unref(formatStartTime))])
+              }, [
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass(vue.unref(ns).e("content"))
+                }, vue.toDisplayString(vue.unref(formatStartTime) ? vue.unref(formatStartTime) : "\u5F00\u59CB\u65E5\u671F"), 3),
+                vue.createVNode(_component_ElIcon, {
+                  class: vue.normalizeClass(vue.unref(ns).e("caret"))
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(_component_CaretBottom)
+                  ]),
+                  _: 1
+                }, 8, ["class"])
+              ], 2),
+              vue.createTextVNode(" \u81F3 "),
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass([vue.unref(ns).e("time"), vue.unref(ns).is("empty", !vue.unref(formatEndTime))])
+              }, [
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass(vue.unref(ns).e("content"))
+                }, vue.toDisplayString(vue.unref(formatEndTime) ? vue.unref(formatEndTime) : "\u7ED3\u675F\u65E5\u671F"), 3),
+                vue.createVNode(_component_ElIcon, {
+                  class: vue.normalizeClass(vue.unref(ns).e("caret"))
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(_component_CaretBottom)
+                  ]),
+                  _: 1
+                }, 8, ["class"])
+              ], 2)
+            ], 2)
+          ])
+        ]),
+        content: vue.withCtx(() => [
+          vue.createVNode(PanelDateRange__default["default"], {
+            "parsed-value": vue.unref(parsedValue),
+            type: "daterange",
+            visible: pickerVisivle.value,
+            onPick,
+            teleported: false
+          }, null, 8, ["parsed-value", "visible"])
+        ]),
+        _: 3
+      }, 8, ["visible"]);
+    };
+  }
+});
+var DateRange = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "date-range.vue"]]);
+
+exports["default"] = DateRange;

package/lib/date-range/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var dateRange = require('./date-range.js');
+
+const BwaDateRange = install.withInstall(dateRange["default"]);
+
+exports.BwaDateRange = BwaDateRange;
+exports["default"] = BwaDateRange;

package/lib/drag-list/constants.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const dragListContextKey = "DRAG_LIST_CONTEXT_KEY";
+
+exports.dragListContextKey = dragListContextKey;