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

package/lib/drag-list/drag-item.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var constants = require('./constants.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({ name: "BwaDragItem" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  setup(__props, { expose }) {
+    const ns = webBaseClientVue.useNamespace("dragitem");
+    ;
+    const dragListContext = vue.inject(constants.dragListContextKey);
+    const id = dragListContext.nextID();
+    const instance = vue.getCurrentInstance();
+    const handleMousedown = (event) => {
+      if (event.button !== 0) {
+        return;
+      }
+      dragListContext.startDrag(instance.proxy);
+    };
+    vue.onMounted(() => {
+      dragListContext.handleItemCreate(id, instance.proxy);
+    });
+    vue.onBeforeUnmount(() => {
+      dragListContext.handleItemDestroy(id, instance.proxy);
+    });
+    expose({
+      id
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        "draggable-context-id": "",
+        onMousedown: handleMousedown
+      }, [
+        vue.createElementVNode("i", {
+          class: vue.normalizeClass([vue.unref(ns).e("drag-icon"), "ptp-icon", "ptp-buzhou-yidong"])
+        }, null, 2),
+        vue.createElementVNode("span", {
+          class: vue.normalizeClass(vue.unref(ns).e("content"))
+        }, [
+          vue.renderSlot(_ctx.$slots, "default")
+        ], 2)
+      ], 34);
+    };
+  }
+});
+var DragItem = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "drag-item.vue"]]);
+
+exports["default"] = DragItem;

package/lib/drag-list/drag-list.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var constants = require('./constants.js');
+var dragItem = require('./drag-item.js');
+var useDragList = require('./use-drag-list.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({ name: "BwaDragList" });
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    data: {
+      type: Array,
+      default: () => []
+    },
+    idAttr: {
+      type: String,
+      default: "id"
+    }
+  },
+  emits: ["sort-change"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ns = webBaseClientVue.useNamespace("draglist");
+    const { startDrag, nextID, handleItemCreate, handleItemDestroy, dragging } = useDragList.useDragList(props, { emit });
+    vue.provide(
+      constants.dragListContextKey,
+      vue.reactive({
+        dragging,
+        startDrag,
+        nextID,
+        handleItemCreate,
+        handleItemDestroy
+      })
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).e("dragging", vue.unref(dragging))])
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.data, (item, i) => {
+          return vue.openBlock(), vue.createBlock(dragItem["default"], {
+            key: item[__props.idAttr],
+            "data-key": item[__props.idAttr]
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "default", { item })
+            ]),
+            _: 2
+          }, 1032, ["data-key"]);
+        }), 128))
+      ], 2);
+    };
+  }
+});
+var DragList = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "drag-list.vue"]]);
+
+exports["default"] = DragList;

package/lib/drag-list/index.js

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

package/lib/drag-list/use-drag-list.js

@@ -0,0 +1,158 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('../node_modules/.pnpm/@vueuse_core@9.6.0_vue@3.2.41/node_modules/@vueuse/core/index.js');
+var vue = require('vue');
+
+const useDragList = (props, context) => {
+  let uid = 1;
+  const itemMap = /* @__PURE__ */ new Map();
+  const containerInstance = vue.getCurrentInstance();
+  const mouseInfo = index.useMouse();
+  let bounding = null;
+  let currentInstance = vue.ref(null);
+  let startPosition = null;
+  let offset = null;
+  let timer = null;
+  let clonedEl = null;
+  const dragging = vue.ref(false);
+  const currentEl = vue.computed(() => {
+    const instance = vue.unref(currentInstance);
+    if (!instance) {
+      return null;
+    }
+    return instance.$el;
+  });
+  const brotherItemList = vue.computed(() => {
+    const children = Array.from(itemMap.values());
+    const _currentInstance = vue.unref(currentInstance);
+    return children.filter((item) => item !== _currentInstance);
+  });
+  let animationFrameKey = -1;
+  const calcTransform = () => {
+    const targetX = vue.unref(mouseInfo.x) - startPosition.x - offset.x;
+    const targetY = vue.unref(mouseInfo.y) - startPosition.y - offset.y;
+    vue.unref(currentEl).style.transform = `translate(${targetX}px, ${targetY}px)`;
+    const currentBounding = vue.unref(currentEl).getBoundingClientRect();
+    for (const brother of vue.unref(brotherItemList)) {
+      const _bounding = brother.$el.getBoundingClientRect();
+      if (currentBounding.y + currentBounding.height / 2 <= _bounding.y + vue.unref(_bounding.height) / 2) {
+        brother.$el.style.transform = `translate(0, ${vue.unref(bounding.height)}px)`;
+      } else {
+        brother.$el.style.transform = `translate(0, 0px)`;
+      }
+    }
+  };
+  const animationFrameCallback = () => {
+    calcTransform();
+    animationFrameKey = requestAnimationFrame(animationFrameCallback);
+  };
+  const getSorted = () => {
+    const el = vue.unref(currentEl);
+    const container = el.parentElement;
+    const children = Array.from(container.children);
+    let before = [];
+    let after = [];
+    for (const child of children) {
+      if (child === el || child === clonedEl) {
+        continue;
+      }
+      if (["translate(0px, 0px)", "translate(0px)"].includes(child.style.transform)) {
+        before.push(child.dataset.key);
+      } else {
+        after.push(child.dataset.key);
+      }
+    }
+    return [...before, el.dataset.key, ...after];
+  };
+  const handleMouseup = (event) => {
+    cancelAnimationFrame(animationFrameKey);
+    document.removeEventListener("mouseup", handleMouseup);
+    context.emit("sort-change", getSorted());
+    for (const brotherItem of [...vue.unref(brotherItemList), vue.unref(currentInstance)]) {
+      brotherItem.$el.setAttribute("draggable-context-id", "");
+    }
+    clearTimeout(timer);
+    containerInstance.proxy.$el.removeChild(clonedEl);
+    Object.assign(vue.unref(currentEl).style, {
+      position: "",
+      left: "",
+      top: "",
+      transform: "",
+      width: "",
+      height: "",
+      cursor: "",
+      zIndex: ""
+    });
+    Object.assign(document.body.style, {
+      userSelect: "",
+      cursor: ""
+    });
+    clonedEl = timer = startPosition = offset = currentInstance.value = bounding = null;
+    for (const brother of vue.unref(brotherItemList)) {
+      brother.$el.style.transform = ``;
+    }
+    dragging.value = false;
+  };
+  const startDrag = (el) => {
+    dragging.value = true;
+    currentInstance.value = el;
+    bounding = index.useElementBounding(currentEl);
+    startPosition = {
+      x: vue.unref(bounding.x),
+      y: vue.unref(bounding.y)
+    };
+    Object.assign(document.body.style, {
+      userSelect: "none",
+      cursor: "grabbing"
+    });
+    offset = {
+      x: vue.unref(mouseInfo.x) - vue.unref(bounding.x),
+      y: vue.unref(mouseInfo.y) - vue.unref(bounding.y)
+    };
+    clonedEl = document.createElement("div");
+    Object.assign(clonedEl.style, {
+      height: `${vue.unref(bounding.height)}px`,
+      width: `${vue.unref(bounding.width)}px`
+    });
+    containerInstance.proxy.$el.append(clonedEl);
+    Object.assign(vue.unref(currentEl).style, {
+      position: "fixed",
+      left: `${vue.unref(startPosition.x)}px`,
+      top: `${vue.unref(startPosition.y)}px`,
+      width: `${vue.unref(bounding.width)}px`,
+      height: `${vue.unref(bounding.height)}px`,
+      transform: "translate(0px, 0px)",
+      cursor: "grabbing",
+      zIndex: "5000"
+    });
+    calcTransform();
+    timer = setTimeout(() => {
+      vue.unref(currentInstance).$el.setAttribute("draggable-context-id", "1");
+      for (const brotherItem of vue.unref(brotherItemList)) {
+        brotherItem.$el.setAttribute("draggable-context-id", "0");
+      }
+    });
+    animationFrameKey = requestAnimationFrame(animationFrameCallback);
+    document.addEventListener("mouseup", handleMouseup);
+  };
+  const nextID = () => {
+    return uid++;
+  };
+  const handleItemCreate = (id, instance) => {
+    itemMap.set(id, instance);
+  };
+  const handleItemDestroy = (id, instance) => {
+    itemMap.delete(id);
+  };
+  return {
+    startDrag,
+    nextID,
+    handleItemCreate,
+    handleItemDestroy,
+    dragging
+  };
+};
+
+exports.useDragList = useDragList;

package/lib/dragable/constants.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const dragableContextKey = "DRAGABLE_CONTEXT_KEY";
+const dragableItemContextKey = "DRAGABLE_ITEM_CONTEXT_KEY";
+
+exports.dragableContextKey = dragableContextKey;
+exports.dragableItemContextKey = dragableItemContextKey;

package/lib/dragable/dragable-item.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var constants = require('./constants.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaDragableItem"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  setup(__props) {
+    ;
+    const ns = webBaseClientVue.useNamespace("dragable-item");
+    vue.provide(constants.dragableItemContextKey, {});
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b())
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var DragableItem = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "dragable-item.vue"]]);
+
+exports["default"] = DragableItem;

package/lib/dragable/dragable-operation.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var constants = require('./constants.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const _hoisted_1 = ["dragable-operation"];
+const __default__ = vue.defineComponent({
+  name: "BwaDragableOperation"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  setup(__props) {
+    ;
+    const ns = webBaseClientVue.useNamespace("dragable-operation");
+    const dragableContext = vue.inject(constants.dragableContextKey);
+    const dragableItemContext = vue.inject(constants.dragableItemContextKey);
+    const dragableOperation = vue.ref(
+      new Boolean(dragableContext && dragableItemContext).valueOf()
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", {
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        onMousedown: _cache[0] || (_cache[0] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
+        "dragable-operation": dragableOperation.value
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 42, _hoisted_1);
+    };
+  }
+});
+var DragableOperation = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "dragable-operation.vue"]]);
+
+exports["default"] = DragableOperation;

package/lib/dragable/dragable.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var webBaseClientVue = require('@ctzy-web-client/web-base-client-vue');
+var constants = require('./constants.js');
+var useDragable = require('./use-dragable.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaDragable"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  emits: ["move"],
+  setup(__props, { emit }) {
+    ;
+    const ns = webBaseClientVue.useNamespace("dragable");
+    const el = vue.ref(null);
+    useDragable.useDragable(el, ns.b("item"), ns.b("operation"), { emit });
+    vue.provide(constants.dragableContextKey, {});
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        ref_key: "el",
+        ref: el
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var Dragable = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "dragable.vue"]]);
+
+exports["default"] = Dragable;

package/lib/dragable/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var dragable = require('./dragable.js');
+var dragableItem = require('./dragable-item.js');
+var dragableOperation = require('./dragable-operation.js');
+
+const BwaDragable = install.withInstall(dragable["default"], {
+  DragableItem: dragableItem["default"],
+  DragableOperation: dragableOperation["default"]
+});
+const BwaDragableItem = install.withInstall(dragableItem["default"], {
+  DragableOperation: dragableOperation["default"]
+});
+const BwaDragableOperation = install.withInstall(dragableOperation["default"]);
+
+exports.BwaDragable = BwaDragable;
+exports.BwaDragableItem = BwaDragableItem;
+exports.BwaDragableOperation = BwaDragableOperation;
+exports["default"] = BwaDragable;

package/lib/dragable/use-dragable.js

@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rxjs = require('rxjs');
+var vue = require('vue');
+var Rectangle = require('../math/Rectangle.js');
+
+const useDragable = (dragableEl, itemClass, operationClass, context) => {
+  let dragSubscription = null;
+  vue.onMounted(() => {
+    const mousedownObservable = rxjs.fromEvent(vue.unref(dragableEl), "mousedown").pipe(rxjs.filter((event) => {
+      const children = Array.from(vue.unref(dragableEl).children).filter((el) => el.classList.contains(itemClass));
+      const operations = children.map((el) => el.querySelector(`.${operationClass}`)).filter(Boolean).filter((operation) => operation.classList.contains(operationClass));
+      return !!operations.find((operation) => operation.contains(event.target));
+    }));
+    const mousemoveObservable = rxjs.fromEvent(document, "mousemove");
+    const mouseupObservable = rxjs.fromEvent(document, "mouseup");
+    const dragObservable = mousedownObservable.pipe(rxjs.switchMap((startEvent) => mousemoveObservable.pipe(rxjs.takeUntil(mouseupObservable), rxjs.map((event) => ({
+      startEvent,
+      moveEvent: event
+    })))));
+    let animationFrameKey = -1;
+    let otherInfos = [];
+    let currentEl = null;
+    let currentRectangle = null;
+    let tempEl = null;
+    let offset = null;
+    let sourceIndex = -1;
+    const animationFrameCallback = () => {
+      for (let otherInfo of otherInfos) {
+        const translateY = otherInfo.rectangle.cy < currentRectangle.cy ? 0 : currentRectangle.height;
+        otherInfo.el.style.transform = `translate(0px, ${translateY}px)`;
+      }
+      otherInfos = otherInfos.map((info) => {
+        const bound = info.el.getBoundingClientRect();
+        return {
+          el: info.el,
+          rectangle: new Rectangle.Rectangle(bound.x, bound.y, bound.width, bound.height)
+        };
+      });
+      animationFrameKey = requestAnimationFrame(animationFrameCallback);
+    };
+    dragSubscription = dragObservable.subscribe(({
+      moveEvent
+    }) => {
+      if (!currentEl) {
+        return;
+      }
+      const bound = currentEl.getBoundingClientRect();
+      currentRectangle = new Rectangle.Rectangle(bound.x, bound.y, bound.width, bound.height);
+      Object.assign(currentEl.style, {
+        position: "fixed",
+        transform: `translate(${moveEvent.clientX - offset.x}px, ${moveEvent.clientY - offset.y}px)`,
+        zIndex: "5000"
+      });
+    });
+    dragSubscription.add(mousedownObservable.subscribe((event) => {
+      var _a;
+      let children = Array.from(vue.unref(dragableEl).children).filter((el) => el.classList.contains(itemClass));
+      currentEl = (_a = children.find((el) => el.contains(event.target))) != null ? _a : null;
+      if (!currentEl) {
+        return;
+      }
+      sourceIndex = children.findIndex((el) => el.contains(event.target));
+      if (sourceIndex === -1) {
+        return;
+      }
+      const bound = currentEl.getBoundingClientRect();
+      currentRectangle = new Rectangle.Rectangle(bound.x, bound.y, bound.width, bound.height);
+      offset = {
+        x: event.x - bound.x,
+        y: event.y - bound.y
+      };
+      tempEl = document.createElement("div");
+      Object.assign(tempEl.style, {
+        height: `${currentRectangle.height}px`,
+        width: `${currentRectangle.width}px`
+      });
+      vue.unref(dragableEl).appendChild(tempEl);
+      Object.assign(currentEl.style, {
+        position: "fixed",
+        left: "0",
+        top: "0",
+        transform: `translate(${event.clientX - offset.x}px, ${event.clientY - offset.y}px)`,
+        zIndex: "5000"
+      });
+      const otherItems = children.filter((item) => !item.contains(event.target));
+      otherInfos = otherItems.map((el) => {
+        const bound2 = el.getBoundingClientRect();
+        const rectangle = new Rectangle.Rectangle(bound2.x, bound2.y, bound2.width, bound2.height);
+        return {
+          el,
+          rectangle
+        };
+      });
+      animationFrameCallback();
+      for (let otherInfo of otherInfos) {
+        otherInfo.el.setAttribute("dragable-relative", "true");
+      }
+    }));
+    dragSubscription.add(mousedownObservable.pipe(rxjs.switchMap(() => mouseupObservable.pipe(rxjs.take(1)))).subscribe(() => {
+      if (!currentEl) {
+        return;
+      }
+      tempEl.remove();
+      for (let otherInfo of otherInfos) {
+        otherInfo.el.style.transform = "";
+      }
+      Object.assign(currentEl.style, {
+        position: "",
+        left: "",
+        top: "",
+        transform: "",
+        zIndex: ""
+      });
+      const tartgetIndex = otherInfos.filter((info) => info.rectangle.cy < currentRectangle.cy).length;
+      if (sourceIndex !== tartgetIndex) {
+        context.emit("move", sourceIndex, tartgetIndex);
+      }
+      for (let otherInfo of otherInfos) {
+        otherInfo.el.removeAttribute("dragable-relative");
+      }
+      otherInfos = [];
+      currentEl = tempEl = offset = currentRectangle = null;
+      sourceIndex = -1;
+      if (animationFrameKey !== -1) {
+        cancelAnimationFrame(animationFrameKey);
+        animationFrameKey = -1;
+      }
+    }));
+  });
+  vue.onUnmounted(() => {
+    dragSubscription == null ? void 0 : dragSubscription.unsubscribe();
+  });
+};
+
+exports.useDragable = useDragable;

package/lib/filter-panel/conditions/condition.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var utils = require('../../utils.js');
+
+var Condition = {
+  name: "BwaCondition",
+  props: {
+    modelValue: null,
+    column: Object,
+    record: Object
+  },
+  emits: ["on-change", "update:modelValue"],
+  setup(props, context) {
+    const {
+      component,
+      params
+    } = utils.useDynamicComponent(props, context, "BwaMultipleMenuCondition", "fullAttrName");
+    const slots = vue.useSlots();
+    return () => vue.h(vue.unref(component), {
+      ...vue.unref(params),
+      modelValue: props.modelValue,
+      "onUpdate:modelValue": (v) => {
+        context.emit("update:modelValue", v);
+      }
+    }, {
+      ...slots
+    });
+  }
+};
+
+exports["default"] = Condition;

package/lib/filter-panel/conditions/date-range-condition.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../date-range/index.js');
+var _pluginVue_exportHelper = require('../../_virtual/_plugin-vue_export-helper.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaDateRangeCondition",
+  __conditionTitle__: "\u65E5\u671F\u9009\u62E9",
+  __conditionDefault__: () => ({ start: "", end: "" })
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    modelValue: {
+      type: null
+    },
+    valueFormat: {
+      type: String,
+      default: "YYYY-MM-DD"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const value = vue.computed({
+      get: () => props.modelValue,
+      set: (v) => {
+        emit("update:modelValue", v);
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(index.BwaDateRange), {
+        modelValue: vue.unref(value),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null),
+        multiple: true,
+        "value-format": __props.valueFormat
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["modelValue", "value-format"]);
+    };
+  }
+});
+var DateRangeCondition = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "date-range-condition.vue"]]);
+
+exports["default"] = DateRangeCondition;