bm-admin-ui 1.0.82-alpha → 1.0.83-alpha

package/es/components/videoView/index.js

@@ -0,0 +1,100 @@
+import { withInstall } from 'bm-admin-ui/es/utils/with-install';
+import { defineComponent, ref, resolveComponent, openBlock, createElementBlock, Fragment, createElementVNode, normalizeStyle, withModifiers, createVNode, unref, withCtx } from 'vue';
+import { PlayCircleFilled } from '@ant-design/icons-vue';
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = /* @__PURE__ */ createElementVNode("div", { class: "mask" }, null, -1);
+const _hoisted_3 = ["src"];
+const _hoisted_4 = ["src"];
+const _hoisted_5 = ["src"];
+const _hoisted_6 = ["src"];
+const _hoisted_7 = ["src"];
+const _hoisted_8 = ["src"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "videoView",
+  props: {
+    src: {
+      type: String,
+      required: true
+    },
+    width: {
+      type: String || Number,
+      default: 102
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const visible = ref(false);
+    const play = () => {
+      visible.value = true;
+    };
+    return (_ctx, _cache) => {
+      const _component_a_modal = resolveComponent("a-modal");
+      return openBlock(), createElementBlock(Fragment, null, [
+        createElementVNode("div", {
+          class: "my_video",
+          style: normalizeStyle({ width: `${props.width}px`, height: `${props.width}px` }),
+          onClick: withModifiers(play, ["prevent"])
+        }, [
+          _hoisted_2,
+          createVNode(unref(PlayCircleFilled), { class: "play" }),
+          createElementVNode("video", {
+            src: props.src,
+            muted: "",
+            class: "video"
+          }, [
+            createElementVNode("source", {
+              src: props.src,
+              type: "video/mp4"
+            }, null, 8, _hoisted_4),
+            createElementVNode("source", {
+              src: props.src,
+              type: "video/mov"
+            }, null, 8, _hoisted_5)
+          ], 8, _hoisted_3)
+        ], 12, _hoisted_1),
+        createVNode(_component_a_modal, {
+          visible: visible.value,
+          "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => visible.value = $event),
+          "destroy-on-close": "",
+          centered: "",
+          class: "my_video_modal",
+          width: "1000px",
+          footer: null
+        }, {
+          default: withCtx(() => [
+            createElementVNode("video", {
+              style: { "margin-top": "20px" },
+              src: props.src,
+              autoplay: "",
+              controls: ""
+            }, [
+              createElementVNode("source", {
+                src: props.src,
+                type: "video/mp4"
+              }, null, 8, _hoisted_7),
+              createElementVNode("source", {
+                src: props.src,
+                type: "video/mov"
+              }, null, 8, _hoisted_8)
+            ], 8, _hoisted_6)
+          ]),
+          _: 1
+        }, 8, ["visible"])
+      ], 64);
+    };
+  }
+});
+var MyVideo = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "videoView.vue"]]);
+
+const BmVideo = withInstall(MyVideo);
+
+export { BmVideo, BmVideo as default };

package/lib/components/attachment/index.js

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var withInstall = require('bm-admin-ui/lib/utils/with-install');
+var vue = require('vue');
+var iconsVue = require('@ant-design/icons-vue');
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _sfc_main$1 = {
+  name: "BmOverTooltips",
+  props: {
+    title: {
+      type: String,
+      default: void 0
+    },
+    labelTitle: {
+      type: String,
+      default: void 0
+    },
+    line: {
+      type: Number,
+      default: 1
+    },
+    width: {
+      type: [Number, String],
+      default: 0
+    },
+    showAlways: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, context) {
+    const state = vue.reactive({
+      mSlots: {},
+      isShow: false,
+      openShow: false
+    });
+    const observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((item) => {
+          if (item.intersectionRatio > 0.3) {
+            observerDom();
+            observer.disconnect();
+          }
+        });
+      },
+      {
+        threshold: 0.3
+      }
+    );
+    function observerDom() {
+      if (props.line === 1) {
+        if (mySelf.value.scrollWidth > mySelf.value.clientWidth) {
+          state.openShow = true;
+        }
+      } else if (props.line > 1) {
+        if (mySelf.value.scrollHeight > mySelf.value.clientHeight) {
+          state.openShow = true;
+        }
+      }
+    }
+    vue.onBeforeUnmount(function() {
+      observer.disconnect();
+    });
+    let mySelf = vue.ref();
+    vue.watch(
+      () => props.showAlways,
+      function(showAlways) {
+        if (showAlways)
+          state.openShow = showAlways;
+        mySelf.value && observer.unobserve(mySelf.value);
+        vue.nextTick(function() {
+          mySelf.value && observer.observe(mySelf.value);
+        });
+      },
+      {
+        immediate: true
+      }
+    );
+    const handleVisibleChange = (val) => {
+      state.isShow = !state.openShow ? false : val;
+    };
+    const getPopupContainer = () => {
+      return document.body;
+    };
+    return {
+      ...vue.toRefs(state),
+      mySelf,
+      handleVisibleChange,
+      getPopupContainer
+    };
+  }
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_a_tooltip = vue.resolveComponent("a-tooltip");
+  return vue.openBlock(), vue.createBlock(_component_a_tooltip, {
+    visible: _ctx.isShow,
+    "onUpdate:visible": _cache[0] || (_cache[0] = ($event) => _ctx.isShow = $event),
+    title: $props.labelTitle || $props.title,
+    "get-popup-container": $setup.getPopupContainer,
+    onVisibleChange: $setup.handleVisibleChange
+  }, {
+    title: vue.withCtx(() => [
+      vue.renderSlot(_ctx.$slots, "title")
+    ]),
+    default: vue.withCtx(() => [
+      vue.createElementVNode("div", {
+        ref: "mySelf",
+        style: vue.normalizeStyle({
+          width: $props.width ? $props.width + "px" : "100%",
+          WebkitLineClamp: $props.line
+        }),
+        class: vue.normalizeClass($props.line === 1 ? `bm-over-tooltip` : `bm-over-tooltip-multi`)
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {}, () => [
+          vue.renderSlot(_ctx.$slots, "title", {}, () => [
+            vue.createTextVNode(vue.toDisplayString($props.title), 1)
+          ])
+        ])
+      ], 6)
+    ]),
+    _: 3
+  }, 8, ["visible", "title", "get-popup-container", "onVisibleChange"]);
+}
+var OverTooltips = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "over-tooltips.vue"]]);
+
+const BmOverTooltips = withInstall.withInstall(OverTooltips);
+var BmOverTooltips$1 = BmOverTooltips;
+
+const _hoisted_1 = { class: "file_block" };
+const _hoisted_2 = { class: "file_name" };
+const _hoisted_3 = { class: "file_info" };
+const _hoisted_4 = { class: "icon_text" };
+const _hoisted_5 = /* @__PURE__ */ vue.createElementVNode("span", { class: "icon_text" }, "\u5728\u7EBF\u67E5\u770B", -1);
+const __default__ = {
+  name: "BmAttachment"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: {
+    file: {
+      type: Object,
+      default: () => {
+      }
+    }
+  },
+  emits: ["preview", "download"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const visible = vue.ref(false);
+    const data = vue.reactive({
+      fileType: vue.computed(() => {
+        const getFileType = (file) => {
+          const index = file.lastIndexOf(".");
+          return file.substr(index + 1);
+        };
+        return getFileType(props.file.fileName);
+      }),
+      nonsupportPreview: vue.computed(() => {
+        return ["zip", "rar"].includes(data.fileType);
+      }),
+      pictureFileTypes: [
+        "img",
+        "image",
+        "png",
+        "PNG",
+        "image/png",
+        "jpg",
+        "JPG",
+        "jpeg",
+        "JPEG",
+        "image/jpeg",
+        "gif",
+        "GIF",
+        "image/gif"
+      ],
+      openViewImage: ""
+    });
+    const renderSize = (size) => {
+      const pow1024 = (num) => {
+        return Math.pow(1024, num);
+      };
+      if (!size)
+        return "0KB";
+      if (size < pow1024(1))
+        return `${size.toFixed(2)}KB`;
+      if (size < pow1024(2))
+        return `${(size / pow1024(1)).toFixed(2)}MB`;
+      if (size < pow1024(3))
+        return `${(size / pow1024(2)).toFixed(2)}GB`;
+      return `${(size / pow1024(3)).toFixed(2)}TB`;
+    };
+    const setVisible = (value) => {
+      visible.value = value;
+    };
+    const preview = (item) => {
+      if (data.pictureFileTypes.indexOf(data.fileType) > -1) {
+        setVisible(true);
+        data.openViewImage = item.filePath;
+        return;
+      }
+      window.open(item.filePath);
+    };
+    const download = (item) => {
+      emit("download", { file: item });
+    };
+    return (_ctx, _cache) => {
+      const _component_a_image = vue.resolveComponent("a-image");
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("div", _hoisted_1, [
+          vue.createElementVNode("i", {
+            class: vue.normalizeClass({
+              file_icon: true,
+              icon_excel: data.fileType === "xlsx",
+              icon_ppt: ["ppt", "pptx"].indexOf(data.fileType) > -1,
+              icon_word: ["docx", "doc"].indexOf(data.fileType) > -1,
+              icon_image: ["png", "jpg", "jpeg", "gif"].indexOf(data.fileType) > -1,
+              icon_video: data.fileType === "mp4",
+              icon_pdf: data.fileType === "pdf",
+              icon_compress: ["rar", "zip"].indexOf(data.fileType) > -1,
+              icon_others: true
+            })
+          }, null, 2),
+          vue.createElementVNode("div", null, [
+            vue.createElementVNode("div", _hoisted_2, [
+              vue.createVNode(vue.unref(BmOverTooltips$1), {
+                placement: "topLeft",
+                title: __props.file.fileName || ""
+              }, null, 8, ["title"])
+            ]),
+            vue.createElementVNode("div", _hoisted_3, [
+              __props.file.isAllowDownload ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                class: "file_size",
+                onClick: download
+              }, [
+                vue.createVNode(vue.unref(iconsVue.DownloadOutlined)),
+                vue.createTextVNode(),
+                vue.createElementVNode("span", _hoisted_4, vue.toDisplayString(renderSize(__props.file.fileSize)), 1)
+              ])) : vue.createCommentVNode("v-if", true),
+              !data.nonsupportPreview ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 1,
+                class: "file_preview",
+                onClick: _cache[0] || (_cache[0] = ($event) => preview(__props.file))
+              }, [
+                vue.createVNode(vue.unref(iconsVue.EyeOutlined)),
+                _hoisted_5
+              ])) : vue.createCommentVNode("v-if", true)
+            ])
+          ])
+        ]),
+        vue.createVNode(_component_a_image, {
+          style: { display: "none" },
+          preview: {
+            visible: visible.value,
+            onVisibleChange: setVisible
+          },
+          src: data.openViewImage
+        }, null, 8, ["preview", "src"])
+      ], 64);
+    };
+  }
+});
+var Attachment = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "attachment.vue"]]);
+
+const BmAttachment = withInstall.withInstall(Attachment);
+
+exports.BmAttachment = BmAttachment;
+exports["default"] = BmAttachment;

package/lib/components/breadcrumb/index.js

@@ -0,0 +1,168 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var withInstall = require('bm-admin-ui/lib/utils/with-install');
+var vue = require('vue');
+var ABreadcrumb = require('ant-design-vue/lib/breadcrumb');
+var ABreadcrumbItem = require('ant-design-vue/lib/breadcrumb/BreadcrumbItem');
+require('@vue/devtools-api');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ABreadcrumb__default = /*#__PURE__*/_interopDefaultLegacy(ABreadcrumb);
+var ABreadcrumbItem__default = /*#__PURE__*/_interopDefaultLegacy(ABreadcrumbItem);
+
+/*!
+  * vue-router v4.1.6
+  * (c) 2022 Eduardo San Martin Morote
+  * @license MIT
+  */
+
+var NavigationType;
+(function (NavigationType) {
+    NavigationType["pop"] = "pop";
+    NavigationType["push"] = "push";
+})(NavigationType || (NavigationType = {}));
+var NavigationDirection;
+(function (NavigationDirection) {
+    NavigationDirection["back"] = "back";
+    NavigationDirection["forward"] = "forward";
+    NavigationDirection["unknown"] = "";
+})(NavigationDirection || (NavigationDirection = {}));
+
+Symbol((process.env.NODE_ENV !== 'production') ? 'navigation failure' : '');
+/**
+ * Enumeration with all possible types for navigation failures. Can be passed to
+ * {@link isNavigationFailure} to check for specific failures.
+ */
+var NavigationFailureType;
+(function (NavigationFailureType) {
+    /**
+     * An aborted navigation is a navigation that failed because a navigation
+     * guard returned `false` or called `next(false)`
+     */
+    NavigationFailureType[NavigationFailureType["aborted"] = 4] = "aborted";
+    /**
+     * A cancelled navigation is a navigation that failed because a more recent
+     * navigation finished started (not necessarily finished).
+     */
+    NavigationFailureType[NavigationFailureType["cancelled"] = 8] = "cancelled";
+    /**
+     * A duplicated navigation is a navigation that failed because it was
+     * initiated while already being at the exact same location.
+     */
+    NavigationFailureType[NavigationFailureType["duplicated"] = 16] = "duplicated";
+})(NavigationFailureType || (NavigationFailureType = {}));
+
+/**
+ * RouteRecord being rendered by the closest ancestor Router View. Used for
+ * `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
+ * Location Matched
+ *
+ * @internal
+ */
+Symbol((process.env.NODE_ENV !== 'production') ? 'router view location matched' : '');
+/**
+ * Allows overriding the router view depth to control which component in
+ * `matched` is rendered. rvd stands for Router View Depth
+ *
+ * @internal
+ */
+Symbol((process.env.NODE_ENV !== 'production') ? 'router view depth' : '');
+/**
+ * Allows overriding the router instance returned by `useRouter` in tests. r
+ * stands for router
+ *
+ * @internal
+ */
+const routerKey = Symbol((process.env.NODE_ENV !== 'production') ? 'router' : '');
+/**
+ * Allows overriding the current route returned by `useRoute` in tests. rl
+ * stands for route location
+ *
+ * @internal
+ */
+Symbol((process.env.NODE_ENV !== 'production') ? 'route location' : '');
+/**
+ * Allows overriding the current route used by router-view. Internally this is
+ * used when the `route` prop is passed.
+ *
+ * @internal
+ */
+Symbol((process.env.NODE_ENV !== 'production') ? 'router view location' : '');
+
+/**
+ * Returns the router instance. Equivalent to using `$router` inside
+ * templates.
+ */
+function useRouter() {
+    return vue.inject(routerKey);
+}
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = {
+  key: 1,
+  class: "link"
+};
+const __default__ = {
+  name: "BmBreadcrumb"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: {
+    path: {
+      type: Array,
+      required: true
+    }
+  },
+  emits: ["back"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const router = useRouter();
+    const handleJump = (path, backFn) => {
+      console.log(path);
+      if (!path)
+        return;
+      if (backFn)
+        return emit("back", path);
+      console.log(path);
+      router.push(path);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(ABreadcrumb__default["default"]), { class: "breadcrumb" }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(props.path, (item, index) => {
+            return vue.openBlock(), vue.createBlock(vue.unref(ABreadcrumbItem__default["default"]), {
+              key: item.url
+            }, {
+              default: vue.withCtx(() => [
+                index < __props.path.length - 1 ? (vue.openBlock(), vue.createElementBlock("span", {
+                  key: 0,
+                  class: "link",
+                  onClick: ($event) => handleJump(item.url, item.backFn)
+                }, vue.toDisplayString(item.name), 9, _hoisted_1)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_2, vue.toDisplayString(item.name), 1))
+              ]),
+              _: 2
+            }, 1024);
+          }), 128))
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+var Breadcrumb = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "breadcrumb.vue"]]);
+
+const BmBreadcrumb = withInstall.withInstall(Breadcrumb);
+
+exports.BmBreadcrumb = BmBreadcrumb;
+exports["default"] = BmBreadcrumb;

package/lib/components/button/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var withInstall = require('bm-admin-ui/lib/utils/with-install');
+var vue = require('vue');
+var AButton = require('ant-design-vue/lib/button');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var AButton__default = /*#__PURE__*/_interopDefaultLegacy(AButton);
+
+const buttonProps = {
+    size: {
+        type: String,
+        default: 'middle',
+    },
+    type: {
+        type: String,
+        default: 'bm-primary',
+    },
+};
+
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const __default__ = {
+  name: "BmButton"
+};
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: buttonProps,
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(AButton__default["default"]), {
+        size: props.size,
+        type: props.type
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["size", "type"]);
+    };
+  }
+});
+var Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "button.vue"]]);
+
+const BmButton = withInstall.withInstall(Button);
+
+exports.BmButton = BmButton;
+exports["default"] = BmButton;