@ctzy-web-client/plugin-component-vue 1.0.0 → 1.0.1

package/lib/data-table/data-table.js

@@ -0,0 +1,373 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var ElementPlus = require('element-plus');
+var webBaseClientVue = require('web-base-client-vue');
+var dynamicComponent = require('./dynamic-component.js');
+var dataTableColumn = require('./data-table-column.js');
+var useDatatableDrag = require('./use-datatable-drag.js');
+var lodash = require('lodash');
+var rxjs = require('rxjs');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const _hoisted_1 = /* @__PURE__ */ vue.createElementVNode("i", { class: "ptp-icon ptp-buzhou-yidong" }, null, -1);
+const __default__ = vue.defineComponent({ name: "BwaDataTable" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    dataTable: {
+      type: Object,
+      required: true
+    },
+    autoLoad: {
+      type: Boolean,
+      default: true
+    },
+    showIndex: {
+      type: Boolean,
+      default: false
+    },
+    indexColumnLabel: {
+      type: String,
+      default: "\u7F16\u53F7"
+    },
+    selection: {
+      type: Boolean,
+      default: false
+    },
+    paginationLayout: {
+      type: String,
+      default: "sizes, prev, pager, next, jumper"
+    },
+    paginationPageSizes: {
+      type: Array,
+      default: () => [10, 20, 50, 100, 200]
+    },
+    showPagination: {
+      type: Boolean,
+      default: true
+    },
+    whereParamName: {
+      type: String,
+      default: ""
+    },
+    showDrag: {
+      type: Boolean,
+      default: false
+    },
+    border: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["drag"],
+  setup(__props, { emit }) {
+    var _a;
+    const props = __props;
+    const attrs = vue.useAttrs();
+    const userService = webBaseClientVue.useService("UserService");
+    const elTable = vue.ref(null);
+    const dataTable = props.dataTable;
+    dataTable._userService = (_a = userService.value) == null ? void 0 : _a.getUserList;
+    const dataTableEl = vue.ref(null);
+    const displayColumns = vue.computed(
+      () => vue.unref(dataTable).getDisplayColumns() || []
+    );
+    vue.watch(
+      vue.computed(() => props.whereParamName),
+      (whereParamName) => {
+        dataTable.setWhereParamName(whereParamName || "");
+      },
+      { immediate: true, flush: "sync" }
+    );
+    const searchParams = vue.computed(() => props.searchParams);
+    const debounceDelay = webBaseClientVue.useGlobalConfig("debounceDelay", 500);
+    vue.provide(
+      webBaseClientVue.dataTableKey,
+      vue.reactive({
+        dataTable,
+        displayColumns
+      })
+    );
+    const ns = webBaseClientVue.useNamespace("datatable");
+    const { barRectangle } = useDatatableDrag.useDataTableDrag(
+      dataTableEl,
+      ".bwa-datatable__drag",
+      ".el-table__row",
+      { emit }
+    );
+    const processing = vue.ref(false);
+    const data = vue.computed(() => {
+      return props.dataTable.data;
+    });
+    webBaseClientVue.useEventDispatcher(dataTable, "load-successfully", async (res) => {
+      if (res.code != 0) {
+        return;
+      }
+      const _userService = vue.unref(userService);
+      if (!_userService) {
+        return;
+      }
+      let columns = dataTable.getColumns();
+      const componentNames = ["BwaUserSelect", "BwaUserMultiSelect"];
+      columns = columns.filter((column) => componentNames.includes(column.formComponent)).filter((column) => column.visible).filter((column) => column.isExtend);
+      if (!columns.length) {
+        return;
+      }
+      processing.value = true;
+      const data2 = res.data;
+      let ids = data2.reduce((result, item) => {
+        return result.concat(
+          columns.reduce((result2, column) => {
+            let value = lodash.get(item, column.fullAttrName);
+            value = Array.isArray(value) ? value : value ? [value] : [];
+            return result2.concat(value);
+          }, [])
+        );
+      }, []).map((id) => id + "");
+      ids = [...new Set(ids)];
+      try {
+        const userListResult = await _userService.getUserListByIds(ids);
+        if (userListResult.code != 0) {
+          return;
+        }
+        for (const column of columns) {
+          column.componentProps = column.componentProps || {};
+          column.componentProps.options = (userListResult.data || []).map(
+            (item) => ({
+              label: item.label,
+              value: item.value
+            })
+          );
+        }
+        console.log(userListResult);
+      } finally {
+        processing.value = false;
+      }
+    });
+    const sortHandle = (column, prop, order) => {
+      let sortColumn2 = "";
+      let sortType = "";
+      if (column.order) {
+        sortColumn2 = column.prop;
+        sortType = column.order == "descending" ? 0 : 1;
+        dataTable.setParam("sortColumn", sortColumn2);
+        dataTable.setParam("sortType", sortType);
+      } else {
+        dataTable.setParam("sortColumn", sortColumn2);
+        dataTable.setParam("sortType", sortType);
+      }
+      dataTable.load();
+    };
+    webBaseClientVue.useEventDispatcher(dataTable, "load-successfully", (res) => {
+      if (!elTable.value) {
+        return;
+      }
+      vue.unref(elTable).store.updateSelectionByRowKey();
+      if (res.code != 0) {
+        ElementPlus.ElMessage.error(res.msg);
+      }
+    });
+    function sortColumn(array) {
+      array.forEach((item) => {
+        var _a2, _b;
+        item.no = (_a2 = item.getColumnIndex) == null ? void 0 : _a2.call(item);
+        if ((_b = item.children) == null ? void 0 : _b.length) {
+          sortColumn(item.children);
+        }
+      });
+      array.sort((cur, pre) => cur.no - pre.no);
+    }
+    const tableSelectSubject = new rxjs.Subject();
+    const selectionChange = tableSelectSubject.next.bind(tableSelectSubject);
+    const totalPage = vue.computed(() => dataTable.getTotalPage());
+    const tableSelectSubscription = tableSelectSubject.pipe(rxjs.debounceTime(debounceDelay)).subscribe(vue.unref(dataTable).setSelection.bind(vue.unref(dataTable)));
+    const selectChangeAPIObservable = new rxjs.Observable(
+      (observer) => webBaseClientVue.useEventDispatcher(
+        props.dataTable,
+        "select-change",
+        observer.next.bind(observer)
+      )
+    ).pipe(
+      rxjs.filter((selection) => {
+        if (!vue.unref(elTable)) {
+          return false;
+        }
+        const selectionRows = vue.unref(elTable).getSelectionRows();
+        if (selectionRows.length !== selection.length) {
+          return true;
+        }
+        const primaryKey = dataTable.primaryKey;
+        return !selectionRows.every(
+          (item) => selection.find((itm) => item[primaryKey] === item[primaryKey])
+        );
+      })
+    ).subscribe((selection) => {
+      vue.unref(elTable).clearSelection();
+      for (const item of selection) {
+        vue.unref(elTable).toggleRowSelection(item, true);
+      }
+    });
+    if (props.autoLoad) {
+      dataTable.load();
+    }
+    const searchParamsSubscription = new rxjs.Observable(
+      (observer) => webBaseClientVue.useEventDispatcher(
+        props.dataTable.filterPanel,
+        "params-change",
+        observer.next.bind(observer)
+      )
+    ).pipe(
+      rxjs.filter(() => props.dataTable.filterPanel.ready),
+      rxjs.debounceTime(vue.unref(debounceDelay))
+    ).subscribe(() => {
+      props.dataTable.load();
+    });
+    const subscription = props.dataTable.getDisplayColumnsSubject().pipe(
+      rxjs.map(() => vue.unref(elTable)),
+      rxjs.delayWhen(() => rxjs.from(vue.nextTick())),
+      rxjs.map((elTable2) => elTable2 == null ? void 0 : elTable2.store),
+      rxjs.skipWhile((store) => !store)
+    ).subscribe((store) => {
+      sortColumn(vue.unref(store.states._columns));
+      store.updateColumns();
+      store.scheduleLayout();
+    });
+    vue.onUnmounted(() => {
+      selectChangeAPIObservable.unsubscribe();
+      subscription.unsubscribe();
+      tableSelectSubscription.unsubscribe();
+      searchParamsSubscription.unsubscribe();
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        ref_key: "dataTableEl",
+        ref: dataTableEl
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", { dataTable: vue.unref(dataTable) }, () => [
+          vue.createVNode(vue.unref(ElementPlus.ElTable), vue.mergeProps({
+            class: "content",
+            height: "100%",
+            ref_key: "elTable",
+            ref: elTable,
+            data: vue.unref(data),
+            "row-key": vue.unref(dataTable).primaryKey,
+            "show-header": "",
+            stripe: ""
+          }, vue.unref(attrs), {
+            onSelectionChange: vue.unref(selectionChange),
+            onSortChange: sortHandle,
+            border: __props.border
+          }), {
+            empty: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "empty-table")
+            ]),
+            default: vue.withCtx(() => [
+              __props.showDrag ? (vue.openBlock(), vue.createBlock(vue.unref(ElementPlus.ElTableColumn), {
+                key: 0,
+                width: "40px"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createElementVNode("div", {
+                    class: vue.normalizeClass(vue.unref(ns).e("drag"))
+                  }, [
+                    vue.renderSlot(_ctx.$slots, "default", {}, () => [
+                      _hoisted_1
+                    ])
+                  ], 2)
+                ]),
+                _: 3
+              })) : vue.createCommentVNode("v-if", true),
+              __props.selection ? vue.renderSlot(_ctx.$slots, "selection", { key: 1 }, () => [
+                vue.createVNode(vue.unref(ElementPlus.ElTableColumn), {
+                  type: "selection",
+                  align: "center",
+                  width: "56",
+                  "reserve-selection": true
+                })
+              ]) : vue.createCommentVNode("v-if", true),
+              __props.showIndex ? vue.renderSlot(_ctx.$slots, "index", { key: 2 }, () => [
+                vue.createVNode(vue.unref(ElementPlus.ElTableColumn), {
+                  type: "index",
+                  width: "60",
+                  align: "center",
+                  label: __props.indexColumnLabel
+                }, null, 8, ["label"])
+              ]) : vue.createCommentVNode("v-if", true),
+              vue.renderSlot(_ctx.$slots, "table-columns", { dataTable: vue.unref(dataTable) }, () => [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(displayColumns), (item) => {
+                  return vue.openBlock(), vue.createBlock(dataTableColumn["default"], vue.mergeProps({
+                    "column-key": item.attrName,
+                    key: item.attrName,
+                    label: item.title,
+                    prop: item.fullAttrName,
+                    "min-width": item.width,
+                    align: item.align
+                  }, item.componentProps, {
+                    sortable: item.sortable == "custom"
+                  }), {
+                    header: vue.withCtx(() => [
+                      vue.renderSlot(_ctx.$slots, `table-header-col-${item.attrName}`, {}, () => [
+                        vue.createTextVNode(vue.toDisplayString(item.title), 1)
+                      ])
+                    ]),
+                    default: vue.withCtx(({ row, $index }) => [
+                      vue.unref(data).length ? vue.renderSlot(_ctx.$slots, "table-col-" + item.attrName, {
+                        key: 0,
+                        row,
+                        index: $index,
+                        column: item,
+                        dataTable: vue.unref(dataTable)
+                      }, () => [
+                        vue.createVNode(vue.unref(dynamicComponent["default"]), {
+                          column: item,
+                          record: row
+                        }, null, 8, ["column", "record"])
+                      ]) : vue.createCommentVNode("v-if", true)
+                    ]),
+                    _: 2
+                  }, 1040, ["column-key", "label", "prop", "min-width", "align", "sortable"]);
+                }), 128))
+              ]),
+              vue.renderSlot(_ctx.$slots, "column-append")
+            ]),
+            _: 3
+          }, 16, ["data", "row-key", "onSelectionChange", "border"])
+        ]),
+        __props.showPagination ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass(vue.unref(ns).e("pagination"))
+        }, [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ns).e("pagination-info"))
+          }, " \u5171" + vue.toDisplayString(vue.unref(totalPage)) + "\u9875\uFF0C" + vue.toDisplayString(vue.unref(dataTable).totalRecCount) + "\u6761 ", 3),
+          vue.createVNode(vue.unref(ElementPlus.ElPagination), {
+            currentPage: vue.unref(dataTable).pageNum,
+            "page-sizes": __props.paginationPageSizes,
+            "page-size": vue.unref(dataTable).pageSize,
+            layout: __props.paginationLayout,
+            total: vue.unref(dataTable).totalRecCount,
+            onSizeChange: _cache[0] || (_cache[0] = ($event) => vue.unref(dataTable).setPageSize($event)),
+            onCurrentChange: _cache[1] || (_cache[1] = ($event) => vue.unref(dataTable).pageTo($event)),
+            teleported: false
+          }, null, 8, ["currentPage", "page-sizes", "page-size", "layout", "total"])
+        ], 2)) : vue.createCommentVNode("v-if", true),
+        vue.unref(barRectangle) ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 1,
+          class: vue.normalizeClass(vue.unref(ns).e("dragbar")),
+          style: vue.normalizeStyle({
+            left: vue.unref(barRectangle).left + "px",
+            top: vue.unref(barRectangle).top + "px",
+            width: vue.unref(barRectangle).width + "px",
+            height: vue.unref(barRectangle).height + "px"
+          })
+        }, null, 6)) : vue.createCommentVNode("v-if", true)
+      ], 2);
+    };
+  }
+});
+var DataTable = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "data-table.vue"]]);
+
+exports["default"] = DataTable;

package/lib/data-table/dynamic-component.js

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var get = require('lodash/get');
+var utils = require('../utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
+
+const formatValue = (column, value) => {
+  const options = column.componentProps.options || [];
+  const _value = Array.isArray(value) ? value : [value];
+  const labels = _value.map((v) => {
+    var _a;
+    return (_a = options.find((option) => option.value === v)) != null ? _a : null;
+  });
+  if (labels.includes(null)) {
+    return null;
+  }
+  return labels.map((item) => item.label).join(",");
+};
+var DynamicComponent = {
+  props: {
+    column: Object,
+    record: Object
+  },
+  emits: ["on-change"],
+  setup(props, context) {
+    const {
+      component,
+      params
+    } = utils.useDynamicComponent(props, context, "BwaDataColumnView", "fullAttrName");
+    const viewType = vue.computed(() => props.column.formComponent === "BwaRichText" ? "html" : "");
+    return () => {
+      var _a;
+      let value = get__default["default"](props.record, props.column.fullAttrName);
+      if (Array.isArray((_a = props.column.componentProps) == null ? void 0 : _a.options)) {
+        value = formatValue(props.column, value) || value;
+      }
+      return vue.h(vue.unref(component), {
+        ...vue.unref(params),
+        value,
+        type: props.column.type,
+        align: props.column.align,
+        rule: props.column.rule,
+        template: props.column.template,
+        defaultValue: props.column.default || "-"
+      });
+    };
+  }
+};
+
+exports["default"] = DynamicComponent;

package/lib/data-table/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var dataTable = require('./data-table.js');
+var dataTableColumn = require('./data-table-column.js');
+var dataColumnView = require('./data-column-view.js');
+
+const BwaDataTable = install.withInstall(dataTable["default"], {
+  DataTableColumn: dataTableColumn["default"],
+  DataColumnView: dataColumnView["default"]
+});
+const BwaDataTableColumn = install.withInstall(dataTableColumn["default"]);
+const BwaDataColumnView = install.withInstall(dataColumnView["default"]);
+
+exports.BwaDataColumnView = BwaDataColumnView;
+exports.BwaDataTable = BwaDataTable;
+exports.BwaDataTableColumn = BwaDataTableColumn;
+exports["default"] = BwaDataTable;

package/lib/data-table/use-datatable-drag.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var rxjs = require('rxjs');
+var Rectangle = require('../math/Rectangle.js');
+
+const useDataTableDrag = (el, dragClass, itemClass, context) => {
+  let mousedownSubscription = null;
+  let barRectangle = vue.ref(null);
+  vue.onMounted(() => {
+    let mouseDownObservable = rxjs.fromEvent(vue.unref(el), "mousedown");
+    let mousemoveObservable = rxjs.fromEvent(vue.unref(document), "mousemove");
+    let mouseupObservable = rxjs.fromEvent(vue.unref(document), "mouseup");
+    let rectangles = [];
+    let cloneEl = null;
+    let offsetX = 0;
+    let offsetY = 0;
+    let targetIndex = -1;
+    mousedownSubscription = mouseDownObservable.pipe(rxjs.filter((event) => {
+      const list = Array.from(vue.unref(el).querySelectorAll(dragClass));
+      const item = list.find((item2) => item2.contains(event.target));
+      if (item) {
+        event.index = list.indexOf(item);
+        const row = Array.from(vue.unref(el).querySelectorAll(itemClass)).find((row2) => row2.contains(item));
+        const _cloneEl = row.cloneNode(true);
+        const boundary = row.getBoundingClientRect();
+        cloneEl = document.createElement("div");
+        cloneEl.className = "bwa-datatable";
+        const tableEl = document.createElement("table");
+        tableEl.className = "el-table";
+        const tbodyEl = document.createElement("tbody");
+        cloneEl.append(tableEl);
+        tableEl.appendChild(tbodyEl);
+        tbodyEl.appendChild(_cloneEl);
+        offsetX = event.x - boundary.left;
+        offsetY = event.y - boundary.top;
+        console.log();
+        Object.assign(cloneEl.style, {
+          position: "absolute",
+          left: event.clientX - offsetX + "px",
+          top: event.clientY - offsetY + "px",
+          zIndex: "9999",
+          height: boundary.height + "px",
+          width: boundary.width + "px",
+          opacity: "0.6",
+          pointerEvents: "none"
+        });
+        document.body.appendChild(cloneEl);
+        document.body.style.cursor = "move";
+        document.body.style.userSelect = "none";
+      }
+      return !!item;
+    }), rxjs.tap(() => {
+      rectangles = Array.from(vue.unref(el).querySelectorAll(itemClass)).map((item) => {
+        const {
+          x,
+          y,
+          width,
+          height
+        } = item.getBoundingClientRect();
+        return new Rectangle.Rectangle(x, y, width, height);
+      });
+    }), rxjs.map((event) => {
+      return {
+        index: event.index,
+        x: event.clientX,
+        y: event.clientY
+      };
+    }), rxjs.switchMap(({
+      index,
+      x,
+      y
+    }) => {
+      return mousemoveObservable.pipe(rxjs.takeUntil(mouseupObservable.pipe(rxjs.tap(() => {
+        if (targetIndex !== -1) {
+          context.emit("drag", index, targetIndex);
+        }
+        cloneEl == null ? void 0 : cloneEl.remove();
+        rectangles = [];
+        offsetX = offsetY = 0;
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        barRectangle.value = null;
+        targetIndex = -1;
+      }))), rxjs.map((event) => {
+        Object.assign(cloneEl.style, {
+          left: event.clientX - offsetX + "px",
+          top: event.clientY - offsetY + "px"
+        });
+        const rectangle = rectangles.find((rectangle2) => rectangle2.pointIn(event.x, event.y));
+        if (!rectangle) {
+          targetIndex = -1;
+          barRectangle.value = null;
+          return;
+        }
+        targetIndex = rectangles.indexOf(rectangle);
+        const direction = event.clientY >= rectangle.cy ? "after" : "before";
+        targetIndex = targetIndex + (direction === "after" ? 1 : 0);
+        barRectangle.value = new Rectangle.Rectangle(rectangle.left, direction === "after" ? rectangle.bottom : rectangle.top, rectangle.width, 2);
+      }));
+    })).subscribe((info) => {
+    });
+  });
+  vue.onBeforeUnmount(() => {
+    mousedownSubscription == null ? void 0 : mousedownSubscription.unsubscribe();
+  });
+  return {
+    barRectangle
+  };
+};
+
+exports.useDataTableDrag = useDataTableDrag;