yuang-framework-ui-pc 1.1.44 → 1.1.46

package/es/ele-copyable/index.js

@@ -0,0 +1,137 @@
+import { defineComponent, ref, onDeactivated, onBeforeUnmount, resolveComponent, createElementBlock, openBlock, normalizeClass, createElementVNode, createVNode, normalizeStyle, renderSlot, createBlock, normalizeProps, mergeProps, withCtx, resolveDynamicComponent } from "vue";
+import { ElIcon } from "element-plus";
+import { CheckOutlined, CopyOutlined } from "../icons";
+import { copyText } from "../utils/core";
+import { useLocale } from "../ele-config-provider/receiver";
+import EleTooltip from "../ele-tooltip/index";
+import { copyableEmits, copyableProps } from "./props";
+const _sfc_main = defineComponent({
+  name: "EleCopyable",
+  components: { ElIcon, CopyOutlined, CheckOutlined, EleTooltip },
+  props: copyableProps,
+  emits: copyableEmits,
+  setup(props, { emit }) {
+    const { lang } = useLocale("copyable", props);
+    const state = { timer: null };
+    const innerRef = ref(null);
+    const tooltipRef = ref(null);
+    const virtualRef = ref();
+    const copied = ref(false);
+    const updateTooltip = () => {
+      tooltipRef.value && tooltipRef.value.updatePopper();
+    };
+    const getText = () => {
+      var _a;
+      if (props.text) {
+        return props.text;
+      }
+      return ((_a = innerRef.value) == null ? void 0 : _a.innerText) || "";
+    };
+    const handleCopyClick = () => {
+      copyText(getText()).then(() => {
+        copied.value = true;
+        updateTooltip();
+        state.timer && clearTimeout(state.timer);
+        state.timer = setTimeout(() => {
+          copied.value = false;
+          updateTooltip();
+        }, props.resetAfter || 1e3);
+        emit("copy");
+      }).catch((error) => {
+        copied.value = false;
+        updateTooltip();
+        emit("copy", error);
+      });
+    };
+    const handleCopyHover = (e) => {
+      if (props.tooltip) {
+        virtualRef.value = e.currentTarget;
+      }
+    };
+    onDeactivated(() => {
+      state.timer && clearTimeout(state.timer);
+      state.timer = null;
+      copied.value = false;
+    });
+    onBeforeUnmount(() => {
+      state.timer && clearTimeout(state.timer);
+      state.timer = null;
+    });
+    return {
+      lang,
+      innerRef,
+      tooltipRef,
+      virtualRef,
+      copied,
+      handleCopyClick,
+      handleCopyHover
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_CheckOutlined = resolveComponent("CheckOutlined");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_CopyOutlined = resolveComponent("CopyOutlined");
+  const _component_EleTooltip = resolveComponent("EleTooltip");
+  return openBlock(), createElementBlock("div", {
+    class: normalizeClass(["ele-copyable", { "ele-copyable-done": _ctx.copied }])
+  }, [
+    createElementVNode("div", {
+      ref: "innerRef",
+      class: "ele-copyable-inner",
+      style: normalizeStyle(_ctx.innerStyle)
+    }, [
+      renderSlot(_ctx.$slots, "default")
+    ], 4),
+    createElementVNode("div", {
+      class: "ele-copyable-icon",
+      style: normalizeStyle(_ctx.customStyle),
+      onMouseover: _cache[0] || (_cache[0] = (...args) => _ctx.handleCopyHover && _ctx.handleCopyHover(...args)),
+      onClick: _cache[1] || (_cache[1] = (...args) => _ctx.handleCopyClick && _ctx.handleCopyClick(...args))
+    }, [
+      _ctx.copied ? (openBlock(), createBlock(_component_ElIcon, normalizeProps(mergeProps({ key: 0 }, _ctx.copiedIconProps || {})), {
+        default: withCtx(() => [
+          _ctx.copiedIcon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.copiedIcon), {
+            key: 0,
+            style: normalizeStyle(_ctx.copiedIconStyle)
+          }, null, 8, ["style"])) : (openBlock(), createBlock(_component_CheckOutlined, {
+            key: 1,
+            style: normalizeStyle(_ctx.copiedIconStyle)
+          }, null, 8, ["style"]))
+        ]),
+        _: 1
+      }, 16)) : (openBlock(), createBlock(_component_ElIcon, normalizeProps(mergeProps({ key: 1 }, _ctx.iconProps || {})), {
+        default: withCtx(() => [
+          _ctx.icon ? (openBlock(), createBlock(resolveDynamicComponent(_ctx.icon), {
+            key: 0,
+            style: normalizeStyle(_ctx.iconStyle)
+          }, null, 8, ["style"])) : (openBlock(), createBlock(_component_CopyOutlined, {
+            key: 1,
+            style: normalizeStyle(_ctx.iconStyle)
+          }, null, 8, ["style"]))
+        ]),
+        _: 1
+      }, 16))
+    ], 36),
+    createVNode(_component_EleTooltip, mergeProps({
+      placement: "top",
+      offset: 6
+    }, !_ctx.tooltip || _ctx.tooltip === true ? {} : _ctx.tooltip, {
+      content: _ctx.copied ? _ctx.lang.copied : _ctx.lang.copy,
+      virtualRef: _ctx.virtualRef,
+      virtualTriggering: true,
+      ref: "tooltipRef"
+    }), null, 16, ["content", "virtualRef"])
+  ], 2);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/ele-copyable/props.d.ts

@@ -0,0 +1,48 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { StyleValue } from '../ele-app/types';
+import { ElIconProps } from '../ele-app/el';
+import { EleTooltipProps } from '../ele-app/plus';
+import { CopyableIcon, CopyableLocale } from './types';
+
+/**
+ * 属性
+ */
+export declare const copyableProps: {
+    /** 重新定义拷贝到剪切板里的文本 */
+    text: StringConstructor;
+    /** 自定义内容样式 */
+    innerStyle: PropType<StyleValue>;
+    /** 自定义拷贝按钮样式 */
+    customStyle: PropType<StyleValue>;
+    /** 自定义拷贝图标 */
+    icon: PropType<CopyableIcon>;
+    /** 自定义拷贝图标属性 */
+    iconProps: PropType<ElIconProps>;
+    /** 自定义拷贝图标样式 */
+    iconStyle: PropType<StyleValue>;
+    /** 自定义拷贝后图标 */
+    copiedIcon: PropType<CopyableIcon>;
+    /** 自定义拷贝后图标属性 */
+    copiedIconProps: PropType<ElIconProps>;
+    /** 自定义拷贝后图标样式 */
+    copiedIconStyle: PropType<StyleValue>;
+    /** 文字提示属性 */
+    tooltip: {
+        type: PropType<boolean | EleTooltipProps>;
+        default: boolean;
+    };
+    /** 拷贝成功状态重置时间 */
+    resetAfter: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** 国际化 */
+    locale: PropType<Partial<CopyableLocale>>;
+};
+export type CopyableProps = ExtractPropTypes<typeof copyableProps>;
+/**
+ * 事件
+ */
+export declare const copyableEmits: {
+    copy: (_error?: any) => boolean;
+};

package/es/ele-copyable/props.js

@@ -0,0 +1,39 @@
+const copyableProps = {
+  /** 重新定义拷贝到剪切板里的文本 */
+  text: String,
+  /** 自定义内容样式 */
+  innerStyle: Object,
+  /** 自定义拷贝按钮样式 */
+  customStyle: Object,
+  /** 自定义拷贝图标 */
+  icon: [String, Object, Function],
+  /** 自定义拷贝图标属性 */
+  iconProps: Object,
+  /** 自定义拷贝图标样式 */
+  iconStyle: Object,
+  /** 自定义拷贝后图标 */
+  copiedIcon: [String, Object, Function],
+  /** 自定义拷贝后图标属性 */
+  copiedIconProps: Object,
+  /** 自定义拷贝后图标样式 */
+  copiedIconStyle: Object,
+  /** 文字提示属性 */
+  tooltip: {
+    type: [Boolean, Object],
+    default: true
+  },
+  /** 拷贝成功状态重置时间 */
+  resetAfter: {
+    type: Number,
+    default: 1e3
+  },
+  /** 国际化 */
+  locale: Object
+};
+const copyableEmits = {
+  copy: (_error) => true
+};
+export {
+  copyableEmits,
+  copyableProps
+};

package/es/ele-count-up/index.d.ts

@@ -0,0 +1,37 @@
+import { CountUp } from 'countup.js';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    endVal: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    options: import('vue').PropType<import('countup.js').CountUpOptions>;
+}>, {
+    rootRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    printValue: (value: number) => void;
+    start: (callback?: (args?: any) => any) => void;
+    pauseResume: () => void;
+    reset: () => void;
+    update: (newEndVal?: string | number) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: (_instance?: CountUp | null) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    endVal: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    options: import('vue').PropType<import('countup.js').CountUpOptions>;
+}>> & Readonly<{
+    onReady?: ((_instance?: CountUp | null | undefined) => any) | undefined;
+}>, {
+    delay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/ele-count-up/index.js

@@ -0,0 +1,108 @@
+import { defineComponent, ref, watch, onMounted, onBeforeUnmount, unref, createElementBlock, openBlock } from "vue";
+import { CountUp } from "countup.js";
+import { countUpEmits, countUpProps } from "./props";
+const isFunction = (value) => typeof value === "function";
+const _sfc_main = defineComponent({
+  name: "EleCountUp",
+  props: countUpProps,
+  emits: countUpEmits,
+  setup(props, { emit }) {
+    let instance;
+    const rootRef = ref(null);
+    const create = () => {
+      const elem = unref(rootRef);
+      if (instance || !elem) {
+        return;
+      }
+      const ins = new CountUp(elem, props.endVal ?? 0, props.options);
+      if (ins.error) {
+        console.warn(ins);
+        return;
+      }
+      instance = ins;
+    };
+    const printValue = (value) => {
+      if (instance && isFunction(instance.printValue)) {
+        return instance.printValue(value);
+      }
+    };
+    const start = (callback) => {
+      if (instance && isFunction(instance.start)) {
+        return instance.start(callback);
+      }
+    };
+    const pauseResume = () => {
+      if (instance && isFunction(instance.pauseResume)) {
+        return instance.pauseResume();
+      }
+    };
+    const reset = () => {
+      if (instance && isFunction(instance.reset)) {
+        return instance.reset();
+      }
+    };
+    const update = (newEndVal) => {
+      if (instance && isFunction(instance.update)) {
+        return instance.update(newEndVal ?? 0);
+      }
+    };
+    const destroy = () => {
+      reset();
+      instance = null;
+    };
+    watch(
+      () => props.endVal,
+      (value) => {
+        update(value);
+      }
+    );
+    watch(
+      () => props.options,
+      () => {
+        destroy();
+        create();
+        emit("ready", instance);
+      }
+    );
+    onMounted(() => {
+      create();
+      if (props.delay < 0) {
+        emit("ready", instance);
+        return;
+      }
+      setTimeout(() => {
+        if (instance && isFunction(instance.start)) {
+          instance.start(() => {
+            emit("ready", instance);
+          });
+        }
+      }, props.delay);
+    });
+    onBeforeUnmount(() => {
+      destroy();
+    });
+    return {
+      rootRef,
+      printValue,
+      start,
+      pauseResume,
+      reset,
+      update
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { ref: "rootRef" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("span", _hoisted_1, null, 512);
+}
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  index as default
+};

package/es/ele-count-up/props.d.ts

@@ -0,0 +1,28 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { CountUpOptions, CountUp } from 'countup.js';
+
+/**
+ * 属性
+ */
+export declare const countUpProps: {
+    /** 首次动画延迟时间 */
+    delay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /** 结束值 */
+    endVal: {
+        type: NumberConstructor;
+        required: boolean;
+    };
+    /** 参数配置 */
+    options: PropType<CountUpOptions>;
+};
+export type CountUpProps = ExtractPropTypes<typeof countUpProps>;
+/**
+ * 事件
+ */
+export declare const countUpEmits: {
+    /** 渲染完成事件 */
+    ready: (_instance?: CountUp | null) => boolean;
+};

package/es/ele-count-up/props.js

@@ -0,0 +1,22 @@
+const countUpProps = {
+  /** 首次动画延迟时间 */
+  delay: {
+    type: Number,
+    default: 300
+  },
+  /** 结束值 */
+  endVal: {
+    type: Number,
+    required: true
+  },
+  /** 参数配置 */
+  options: Object
+};
+const countUpEmits = {
+  /** 渲染完成事件 */
+  ready: (_instance) => true
+};
+export {
+  countUpEmits,
+  countUpProps
+};

package/es/ele-cropper/components/cropper-preview.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** 组件宽度 */
+    previewWidth: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /** 裁剪比例 */
+    aspectRatio: NumberConstructor;
+}>, {
+    rootRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    getPreviews: () => NodeListOf<HTMLElement> | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 组件宽度 */
+    previewWidth: {
+        type: NumberConstructor;
+        required: true;
+    };
+    /** 裁剪比例 */
+    aspectRatio: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/ele-cropper/components/cropper-preview.js

@@ -0,0 +1,74 @@
+import { defineComponent, ref, createElementBlock, openBlock, normalizeStyle, createElementVNode, createCommentVNode, Fragment } from "vue";
+const _sfc_main = defineComponent({
+  name: "CropperPreview",
+  props: {
+    /** 组件宽度 */
+    previewWidth: {
+      type: Number,
+      required: true
+    },
+    /** 裁剪比例 */
+    aspectRatio: Number
+  },
+  setup() {
+    const rootRef = ref(null);
+    const getPreviews = () => {
+      if (!rootRef.value) {
+        return;
+      }
+      return rootRef.value.querySelectorAll(".ele-cropper-preview");
+    };
+    return { rootRef, getPreviews };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    ref: "rootRef",
+    class: "ele-cropper-previews",
+    style: normalizeStyle({ width: `${_ctx.previewWidth + 14}px` })
+  }, [
+    createElementVNode("div", {
+      class: "ele-cropper-preview",
+      style: normalizeStyle({
+        width: `${_ctx.previewWidth}px`,
+        height: `${_ctx.previewWidth / (_ctx.aspectRatio || 1)}px`,
+        marginTop: "0px"
+      })
+    }, null, 4),
+    _ctx.aspectRatio === 1 ? (openBlock(), createElementBlock("div", {
+      key: 0,
+      class: "ele-cropper-preview is-circle",
+      style: normalizeStyle({
+        width: `${_ctx.previewWidth}px`,
+        height: `${_ctx.previewWidth / _ctx.aspectRatio}px`
+      })
+    }, null, 4)) : _ctx.aspectRatio ? (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+      createElementVNode("div", {
+        class: "ele-cropper-preview",
+        style: normalizeStyle({
+          width: `${_ctx.previewWidth}px`,
+          height: `${(_ctx.previewWidth / 3 * 2 - 10) / _ctx.aspectRatio}px`
+        })
+      }, null, 4),
+      createElementVNode("div", {
+        class: "ele-cropper-preview",
+        style: normalizeStyle({
+          width: `${_ctx.previewWidth}px`,
+          height: `${_ctx.previewWidth / 3 / _ctx.aspectRatio}px`,
+          marginLeft: "10px"
+        })
+      }, null, 4)
+    ], 64)) : createCommentVNode("", true)
+  ], 4);
+}
+const cropperPreview = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  cropperPreview as default
+};