ele-admin-plus 1.0.0-beta.1

package/lib/ele-cropper/components/cropper-tools.js

@@ -0,0 +1,185 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const iconsVue = require("@element-plus/icons-vue");
+const useReceiver = require("../../ele-config-provider/use-receiver");
+const TOOL_ICONS = {
+  zoomIn: iconsVue.ZoomIn,
+  zoomOut: iconsVue.ZoomOut,
+  moveLeft: iconsVue.Back,
+  moveRight: iconsVue.Right,
+  moveUp: iconsVue.Top,
+  moveDown: iconsVue.Bottom,
+  rotateLeft: iconsVue.RefreshLeft,
+  rotateRight: iconsVue.RefreshRight,
+  flipX: iconsVue.Switch,
+  flipY: iconsVue.Sort,
+  reset: iconsVue.Refresh,
+  upload: iconsVue.Upload,
+  ok: iconsVue.Check
+};
+const _sfc_main = vue.defineComponent({
+  name: "CropperTools",
+  components: { ElButtonGroup: elementPlus.ElButtonGroup, ElButton: elementPlus.ElButton, ElUpload: elementPlus.ElUpload, ElTooltip: elementPlus.ElTooltip },
+  props: {
+    // 操作按钮布局
+    tools: String,
+    // 允许上传的图片类型
+    accept: String,
+    // 是否需要提示组件
+    tooltip: Boolean,
+    // 提示组件属性
+    tooltipProps: Object,
+    // 国际化
+    locale: Object
+  },
+  emits: {
+    zoomIn: () => true,
+    zoomOut: () => true,
+    moveLeft: () => true,
+    moveRight: () => true,
+    moveUp: () => true,
+    moveDown: () => true,
+    rotateLeft: () => true,
+    rotateRight: () => true,
+    flipX: () => true,
+    flipY: () => true,
+    reset: () => true,
+    upload: (_option) => true,
+    ok: () => true
+  },
+  setup(props, { emit }) {
+    const { lang } = useReceiver.useLocale("cropper", props);
+    const groups = vue.shallowRef([]);
+    const tooltipContent = vue.ref("");
+    const virtualRef = vue.ref();
+    const onUpload = (file) => {
+      const reader = new FileReader();
+      reader.onload = (e) => {
+        var _a;
+        emit("upload", {
+          data: (_a = e.target) == null ? void 0 : _a.result,
+          type: file.type
+        });
+      };
+      reader.readAsDataURL(file);
+      return false;
+    };
+    const onClick = (name) => {
+      emit(name);
+    };
+    const onItemHover = (item, e) => {
+      const title = lang.value[item.name];
+      if (props.tooltip && item.name !== "ok" && title) {
+        virtualRef.value = e.currentTarget;
+        tooltipContent.value = title;
+      }
+    };
+    vue.watch(
+      () => props.tools,
+      (tools) => {
+        if (!tools) {
+          groups.value = [];
+          return;
+        }
+        const names = Object.keys(TOOL_ICONS);
+        groups.value = tools.split("|").filter((g) => !!g.trim()).map((g, i) => {
+          const items = g.split(",").filter((t) => {
+            const name = t.trim();
+            return name && names.includes(name);
+          }).map((t, j) => {
+            const name = t.trim();
+            return {
+              key: i + "-" + j + name,
+              name,
+              icon: TOOL_ICONS[name],
+              className: `ele-cropper-${name}`
+            };
+          });
+          return { key: i + g, items };
+        });
+      },
+      { immediate: true }
+    );
+    return {
+      lang,
+      groups,
+      tooltipContent,
+      virtualRef,
+      onUpload,
+      onClick,
+      onItemHover
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-cropper-tools" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_ElUpload = vue.resolveComponent("ElUpload");
+  const _component_ElButtonGroup = vue.resolveComponent("ElButtonGroup");
+  const _component_ElTooltip = vue.resolveComponent("ElTooltip");
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.groups, (group) => {
+      return vue.openBlock(), vue.createBlock(_component_ElButtonGroup, {
+        key: group.key,
+        class: "ele-cropper-tool-item"
+      }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.items, (item) => {
+            return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+              key: item.key
+            }, [
+              item.name === "upload" ? (vue.openBlock(), vue.createBlock(_component_ElUpload, {
+                key: 0,
+                action: "",
+                accept: _ctx.accept,
+                showUploadList: false,
+                beforeUpload: _ctx.onUpload,
+                style: { "display": "inline-block", "line-height": "0" }
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_ElButton, {
+                    type: "primary",
+                    icon: item.icon,
+                    class: vue.normalizeClass(["ele-cropper-tool", item.className]),
+                    onMouseover: (e) => _ctx.onItemHover(item, e)
+                  }, null, 8, ["icon", "class", "onMouseover"])
+                ]),
+                _: 2
+              }, 1032, ["accept", "beforeUpload"])) : (vue.openBlock(), vue.createBlock(_component_ElButton, {
+                key: 1,
+                type: "primary",
+                icon: item.icon,
+                class: vue.normalizeClass(["ele-cropper-tool", item.className]),
+                onMouseover: (e) => _ctx.onItemHover(item, e),
+                onClick: ($event) => _ctx.onClick(item.name)
+              }, {
+                default: vue.withCtx(() => [
+                  item.name === "ok" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.lang.ok), 1)
+                  ], 64)) : vue.createCommentVNode("", true)
+                ]),
+                _: 2
+              }, 1032, ["icon", "class", "onMouseover", "onClick"]))
+            ], 64);
+          }), 128))
+        ]),
+        _: 2
+      }, 1024);
+    }), 128)),
+    vue.createVNode(_component_ElTooltip, vue.mergeProps({ placement: "top" }, _ctx.tooltipProps, {
+      content: _ctx.tooltipContent,
+      virtualRef: _ctx.virtualRef,
+      virtualTriggering: true
+    }), null, 16, ["content", "virtualRef"])
+  ]);
+}
+const cropperTools = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = cropperTools;

package/lib/ele-cropper/index.d.ts

@@ -0,0 +1,108 @@
+import Cropper from 'cropperjs';
+declare const _sfc_main: import("vue").DefineComponent<{
+    height: StringConstructor;
+    src: StringConstructor;
+    imageType: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
+    tools: {
+        type: StringConstructor;
+        default: string;
+    };
+    preview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    previewWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    toBlob: BooleanConstructor;
+    options: import("vue").PropType<Cropper.Options<HTMLImageElement>>;
+    croppedOptions: import("vue").PropType<Cropper.GetCroppedCanvasOptions>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import("vue").PropType<Partial<import("element-plus").ElTooltipProps>>;
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    locale: import("vue").PropType<import("./types").CropperLocale>;
+}, {
+    imageRef: import("vue").Ref<HTMLImageElement | null>;
+    previewRef: any;
+    isResponsive: import("vue").ComputedRef<boolean>;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onMoveLeft: () => void;
+    onMoveRight: () => void;
+    onMoveUp: () => void;
+    onMoveDown: () => void;
+    onRotateLeft: () => void;
+    onRotateRight: () => void;
+    onFlipX: () => void;
+    onFlipY: () => void;
+    onReset: () => void;
+    onUpload: ({ data, type }: {
+        data: string;
+        type: string;
+    }) => void;
+    onOk: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    done: (_result?: string | Blob | null | undefined) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    height: StringConstructor;
+    src: StringConstructor;
+    imageType: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
+    tools: {
+        type: StringConstructor;
+        default: string;
+    };
+    preview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    previewWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    toBlob: BooleanConstructor;
+    options: import("vue").PropType<Cropper.Options<HTMLImageElement>>;
+    croppedOptions: import("vue").PropType<Cropper.GetCroppedCanvasOptions>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import("vue").PropType<Partial<import("element-plus").ElTooltipProps>>;
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    locale: import("vue").PropType<import("./types").CropperLocale>;
+}>> & {
+    onDone?: ((_result?: string | Blob | null | undefined) => any) | undefined;
+}, {
+    tooltip: boolean;
+    imageType: string;
+    accept: string;
+    tools: string;
+    preview: boolean;
+    previewWidth: number;
+    toBlob: boolean;
+    responsive: boolean;
+}, {}>;
+export default _sfc_main;

package/lib/ele-cropper/index.js

@@ -0,0 +1,215 @@
+"use strict";
+const vue = require("vue");
+const Cropper = require("cropperjs");
+const licenseUtil = require("../utils/license-util");
+const useReceiver = require("../ele-config-provider/use-receiver");
+const CropperPreview = require("./components/cropper-preview");
+const CropperTools = require("./components/cropper-tools");
+const props = require("./props");
+const _sfc_main = vue.defineComponent({
+  name: "EleCropper",
+  components: { CropperPreview, CropperTools },
+  props: props.cropperProps,
+  emits: props.cropperEmits,
+  setup(props2, { emit }) {
+    const { authenticated } = licenseUtil.useLicense();
+    const isResponsive = useReceiver.useResponsive(props2);
+    const imageRef = vue.ref(null);
+    const previewRef = vue.ref(null);
+    const current = {
+      instance: null,
+      imageType: props2.imageType,
+      scaleXValue: -1,
+      scaleYValue: -1
+    };
+    const render = () => {
+      destroy();
+      const options = { ...props2.options };
+      if (props2.preview && previewRef.value) {
+        options.preview = previewRef.value.getPreviews();
+      }
+      if (imageRef.value) {
+        current.instance = new Cropper(imageRef.value, options);
+      }
+    };
+    const destroy = () => {
+      current.instance && current.instance.destroy();
+      current.instance = null;
+    };
+    const onZoomIn = () => {
+      current.instance && current.instance.zoom(0.1);
+    };
+    const onZoomOut = () => {
+      current.instance && current.instance.zoom(-0.1);
+    };
+    const onMoveLeft = () => {
+      current.instance && current.instance.move(-10, 0);
+    };
+    const onMoveRight = () => {
+      current.instance && current.instance.move(10, 0);
+    };
+    const onMoveUp = () => {
+      current.instance && current.instance.move(0, -10);
+    };
+    const onMoveDown = () => {
+      current.instance && current.instance.move(0, 10);
+    };
+    const onRotateLeft = () => {
+      current.instance && current.instance.rotate(-45);
+    };
+    const onRotateRight = () => {
+      current.instance && current.instance.rotate(45);
+    };
+    const onFlipX = () => {
+      current.instance && current.instance.scaleX(current.scaleXValue);
+      current.scaleXValue = -current.scaleXValue;
+    };
+    const onFlipY = () => {
+      current.instance && current.instance.scaleY(current.scaleYValue);
+      current.scaleYValue = -current.scaleYValue;
+    };
+    const onReset = () => {
+      current.instance && current.instance.reset();
+    };
+    const onUpload = ({ data, type }) => {
+      current.imageType = type;
+      if (current.instance) {
+        current.instance.replace(data);
+      } else {
+        const elem = imageRef.value;
+        if (elem) {
+          elem.src = data;
+          elem.style.display = "block";
+        }
+        render();
+      }
+    };
+    const onOk = () => {
+      if (!authenticated.value) {
+        console.warn(licenseUtil.UNAUTHORIZED_TIP);
+        return;
+      }
+      if (!current.instance) {
+        emit("done");
+        return;
+      }
+      const result = current.instance.getCroppedCanvas(props2.croppedOptions);
+      if (!result) {
+        emit("done");
+        return;
+      }
+      if (props2.toBlob) {
+        result.toBlob((blob) => {
+          emit("done", blob);
+        }, current.imageType);
+        return;
+      }
+      emit("done", result.toDataURL(current.imageType));
+    };
+    vue.watch(
+      () => props2.src,
+      (src) => {
+        if (src) {
+          if (current.instance) {
+            current.instance.replace(src);
+          } else {
+            vue.nextTick(() => {
+              render();
+            });
+          }
+        } else {
+          destroy();
+        }
+      }
+    );
+    vue.watch(
+      () => props2.imageType,
+      (value) => {
+        if (value) {
+          current.imageType = value;
+        }
+      }
+    );
+    vue.onMounted(() => {
+      props2.src && render();
+    });
+    vue.onBeforeUnmount(() => {
+      destroy();
+    });
+    return {
+      imageRef,
+      previewRef,
+      isResponsive,
+      onZoomIn,
+      onZoomOut,
+      onMoveLeft,
+      onMoveRight,
+      onMoveUp,
+      onMoveDown,
+      onRotateLeft,
+      onRotateRight,
+      onFlipX,
+      onFlipY,
+      onReset,
+      onUpload,
+      onOk
+    };
+  }
+});
+const _export_sfc = (sfc, props2) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props2) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-cropper-main" };
+const _hoisted_2 = ["src"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CropperPreview = vue.resolveComponent("CropperPreview");
+  const _component_CropperTools = vue.resolveComponent("CropperTools");
+  return vue.openBlock(), vue.createElementBlock("div", {
+    class: vue.normalizeClass(["ele-cropper", { "is-responsive": _ctx.isResponsive }])
+  }, [
+    vue.createElementVNode("div", _hoisted_1, [
+      vue.createElementVNode("div", {
+        class: "ele-cropper-image",
+        style: vue.normalizeStyle({ height: _ctx.height })
+      }, [
+        vue.createElementVNode("img", {
+          ref: "imageRef",
+          src: _ctx.src,
+          style: vue.normalizeStyle(_ctx.src ? void 0 : { display: "none" })
+        }, null, 12, _hoisted_2)
+      ], 4),
+      _ctx.preview ? (vue.openBlock(), vue.createBlock(_component_CropperPreview, {
+        key: 0,
+        ref: "previewRef",
+        previewWidth: _ctx.previewWidth,
+        aspectRatio: _ctx.options ? _ctx.options.aspectRatio : void 0
+      }, null, 8, ["previewWidth", "aspectRatio"])) : vue.createCommentVNode("", true)
+    ]),
+    vue.createVNode(_component_CropperTools, {
+      tools: _ctx.tools,
+      accept: _ctx.accept,
+      locale: _ctx.locale,
+      tooltip: _ctx.tooltip,
+      tooltipProps: _ctx.tooltipProps,
+      onZoomIn: _ctx.onZoomIn,
+      onZoomOut: _ctx.onZoomOut,
+      onMoveLeft: _ctx.onMoveLeft,
+      onMoveRight: _ctx.onMoveRight,
+      onMoveUp: _ctx.onMoveUp,
+      onMoveDown: _ctx.onMoveDown,
+      onRotateLeft: _ctx.onRotateLeft,
+      onRotateRight: _ctx.onRotateRight,
+      onFlipX: _ctx.onFlipX,
+      onFlipY: _ctx.onFlipY,
+      onReset: _ctx.onReset,
+      onUpload: _ctx.onUpload,
+      onOk: _ctx.onOk
+    }, null, 8, ["tools", "accept", "locale", "tooltip", "tooltipProps", "onZoomIn", "onZoomOut", "onMoveLeft", "onMoveRight", "onMoveUp", "onMoveDown", "onRotateLeft", "onRotateRight", "onFlipX", "onFlipY", "onReset", "onUpload", "onOk"])
+  ], 2);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = index;

package/lib/ele-cropper/props.d.ts

@@ -0,0 +1,51 @@
+import type { PropType, ExtractPropTypes } from 'vue';
+import type { ElTooltipProps } from 'element-plus';
+import type Cropper from 'cropperjs';
+import type { CropperLocale } from './types';
+/**
+ * 属性
+ */
+export declare const cropperProps: {
+    height: StringConstructor;
+    src: StringConstructor;
+    imageType: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
+    tools: {
+        type: StringConstructor;
+        default: string;
+    };
+    preview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    previewWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    toBlob: BooleanConstructor;
+    options: PropType<Cropper.Options<HTMLImageElement>>;
+    croppedOptions: PropType<Cropper.GetCroppedCanvasOptions>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: PropType<Partial<ElTooltipProps>>;
+    responsive: {
+        type: BooleanConstructor;
+        default: null;
+    };
+    locale: PropType<CropperLocale>;
+};
+export type CropperProps = ExtractPropTypes<typeof cropperProps>;
+/**
+ * 事件
+ */
+export declare const cropperEmits: {
+    done: (_result?: Blob | string | null) => boolean;
+};

package/lib/ele-cropper/props.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const cropperProps = {
+  // 图片高度
+  height: String,
+  // 图片地址
+  src: String,
+  // 图片地址对应的图片类型,如'image/jpeg'
+  imageType: {
+    type: String,
+    default: "image/png"
+  },
+  // 允许上传的图片类型
+  accept: {
+    type: String,
+    default: "image/*"
+  },
+  // 操作按钮布局
+  tools: {
+    type: String,
+    default: "zoomIn,zoomOut | moveLeft,moveRight,moveUp,moveDown | rotateLeft,rotateRight | flipX,flipY | reset,upload | ok"
+  },
+  // 是否需要预览组件
+  preview: {
+    type: Boolean,
+    default: true
+  },
+  // 预览组件宽度
+  previewWidth: {
+    type: Number,
+    default: 120
+  },
+  // 是否返回blob数据
+  toBlob: Boolean,
+  // cropperjs的参数
+  options: Object,
+  // cropperjs裁剪方法的参数
+  croppedOptions: Object,
+  // 是否需要tooltip
+  tooltip: {
+    type: Boolean,
+    default: true
+  },
+  // tooltip属性
+  tooltipProps: Object,
+  // 是否开启响应式
+  responsive: {
+    type: Boolean,
+    default: null
+  },
+  // 国际化
+  locale: Object
+};
+const cropperEmits = {
+  // 裁剪完成事件
+  done: (_result) => true
+};
+exports.cropperEmits = cropperEmits;
+exports.cropperProps = cropperProps;

package/lib/ele-cropper/style/index.js

@@ -0,0 +1,7 @@
+"use strict";
+require("element-plus/es/components/button-group/style/index");
+require("element-plus/es/components/button/style/index");
+require("element-plus/es/components/upload/style/index");
+require("element-plus/es/components/tooltip/style/index");
+require("cropperjs/dist/cropper.css");
+require("./index.scss");