ele-admin-plus 1.3.0-beta.3 → 1.3.0-beta.4

package/lib/ele-edit-tag/index.cjs

@@ -5,19 +5,15 @@ const EleTooltip = require("../ele-tooltip/index");
 const icons = require("../icons");
 const util = require("../ele-basic-select/util");
 const props = require("./props");
-const _sfc_main = vue.defineComponent({
-  name: "EleEditTag",
-  components: {
-    ElTag: elementPlus.ElTag,
-    ElInput: elementPlus.ElInput,
-    ElIcon: elementPlus.ElIcon,
-    EleTooltip,
-    PlusOutlined: icons.PlusOutlined,
-    LoadingOutlined: icons.LoadingOutlined
-  },
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleEditTag" },
+  __name: "index",
   props: props.editTagProps,
   emits: props.editTagEmits,
-  setup(props2, { emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props2 = __props;
+    const emit = __emit;
     const { validateChange } = util.useFormValidate();
     const inputTagRef = vue.ref(null);
     const inputRef = vue.ref(null);
@@ -44,12 +40,12 @@ const _sfc_main = vue.defineComponent({
         updateModelValue(temp);
       }
     };
-    const removeTag = (index2) => {
+    const removeTag = (index) => {
       if (!props2.modelValue) {
         return;
       }
       const temp = [...props2.modelValue];
-      temp.splice(index2, 1);
+      temp.splice(index, 1);
       updateModelValue(temp);
     };
     const updateInputValue = (value) => {
@@ -71,18 +67,18 @@ const _sfc_main = vue.defineComponent({
         focusInput();
       });
     };
-    const handleTagClose = (index2, item) => {
+    const handleTagClose = (index, item) => {
       if (typeof props2.beforeRemove !== "function") {
-        removeTag(index2);
+        removeTag(index);
         return;
       }
-      props2.beforeRemove(index2, item).then(() => {
-        removeTag(index2);
+      props2.beforeRemove(index, item).then(() => {
+        removeTag(index);
       }).catch(() => {
       });
     };
-    const handleTagClick = (index2, item) => {
-      emit("itemClick", index2, item);
+    const handleTagClick = (index, item) => {
+      emit("itemClick", index, item);
     };
     const handleInputChange = () => {
       if (!inputValue.value) {
@@ -127,149 +123,124 @@ const _sfc_main = vue.defineComponent({
     vue.onActivated(() => {
       isDeactivated.value = false;
     });
-    return {
+    __expose({
       inputTagRef,
-      inputRef,
-      isEdit,
-      inputValue,
-      errorMessage,
-      loading,
-      tooltipVisible,
-      updateInputValue,
-      handleAddClick,
-      handleTagClose,
-      handleTagClick,
-      handleInputChange,
-      handleInputBlur,
-      handleInputFocus
-    };
-  }
-});
-const _export_sfc = (sfc, props2) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props2) {
-    target[key] = val;
-  }
-  return target;
-};
-const _hoisted_1 = { key: 0 };
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ElTag = vue.resolveComponent("ElTag");
-  const _component_PlusOutlined = vue.resolveComponent("PlusOutlined");
-  const _component_ElIcon = vue.resolveComponent("ElIcon");
-  const _component_LoadingOutlined = vue.resolveComponent("LoadingOutlined");
-  const _component_ElInput = vue.resolveComponent("ElInput");
-  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
-  return vue.openBlock(), vue.createElementBlock("div", {
-    class: vue.normalizeClass([
-      "ele-edit-tag",
-      { "is-large": _ctx.size === "large" },
-      { "is-small": _ctx.size === "small" },
-      { "is-disabled": _ctx.disabled },
-      { "is-readonly": _ctx.readonly }
-    ])
-  }, [
-    _ctx.modelValue ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.modelValue, (item, index2) => {
-      return vue.openBlock(), vue.createBlock(_component_ElTag, {
-        key: index2 + "-" + item,
-        hit: _ctx.hit,
-        type: _ctx.type,
-        color: _ctx.color,
-        size: _ctx.size,
-        effect: _ctx.effect,
-        round: _ctx.round,
-        closable: _ctx.readonly || _ctx.disabled ? false : true,
-        disableTransitions: true,
-        style: vue.normalizeStyle(_ctx.itemStyle),
-        onClose: ($event) => _ctx.handleTagClose(index2, item),
-        onClick: ($event) => _ctx.handleTagClick(index2, item)
-      }, {
-        default: vue.withCtx(() => [
-          vue.createTextVNode(vue.toDisplayString(item), 1)
-        ]),
-        _: 2
-      }, 1032, ["hit", "type", "color", "size", "effect", "round", "closable", "style", "onClose", "onClick"]);
-    }), 128)) : vue.createCommentVNode("", true),
-    !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_ElTag, {
-      key: 1,
-      hit: _ctx.hit,
-      type: "info",
-      size: _ctx.size,
-      round: _ctx.round,
-      disableTransitions: true,
-      class: "ele-edit-tag-add",
-      style: vue.normalizeStyle(_ctx.buttonStyle),
-      onClick: _ctx.handleAddClick
-    }, {
-      default: vue.withCtx(() => [
-        vue.renderSlot(_ctx.$slots, "placeholder", {}, () => [
-          _ctx.placeholder ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1, vue.toDisplayString(_ctx.placeholder), 1)) : (vue.openBlock(), vue.createBlock(_component_ElIcon, {
-            key: 1,
-            class: "ele-edit-tag-add-icon"
+      inputRef
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          "ele-edit-tag",
+          { "is-large": _ctx.size === "large" },
+          { "is-small": _ctx.size === "small" },
+          { "is-disabled": _ctx.disabled },
+          { "is-readonly": _ctx.readonly }
+        ])
+      }, [
+        _ctx.modelValue ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.modelValue, (item, index) => {
+          return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTag), {
+            key: index + "-" + item,
+            hit: _ctx.hit,
+            type: _ctx.type,
+            color: _ctx.color,
+            size: _ctx.size,
+            effect: _ctx.effect,
+            round: _ctx.round,
+            closable: _ctx.readonly || _ctx.disabled ? false : true,
+            disableTransitions: true,
+            style: vue.normalizeStyle(_ctx.itemStyle),
+            onClose: ($event) => handleTagClose(index, item),
+            onClick: ($event) => handleTagClick(index, item)
           }, {
             default: vue.withCtx(() => [
-              vue.createVNode(_component_PlusOutlined)
+              vue.createTextVNode(vue.toDisplayString(item), 1)
             ]),
-            _: 1
-          }))
-        ])
-      ]),
-      _: 3
-    }, 8, ["hit", "size", "round", "style", "onClick"])), [
-      [vue.vShow, !_ctx.isEdit]
-    ]) : vue.createCommentVNode("", true),
-    !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_ElTag, {
-      key: 2,
-      ref: "inputTagRef",
-      size: _ctx.size,
-      round: _ctx.round,
-      disableTransitions: true,
-      class: vue.normalizeClass(["ele-edit-tag-input", { "is-error": !!_ctx.errorMessage }]),
-      style: vue.normalizeStyle(_ctx.inputTagStyle)
-    }, {
-      default: vue.withCtx(() => [
-        vue.createVNode(_component_ElInput, {
-          ref: "inputRef",
-          disabled: _ctx.loading,
-          modelValue: _ctx.inputValue,
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.inputValue = $event),
-          validateEvent: false,
-          style: vue.normalizeStyle(_ctx.inputStyle),
-          onChange: _ctx.handleInputChange,
-          onBlur: _ctx.handleInputBlur,
-          onFocus: _ctx.handleInputFocus
+            _: 2
+          }, 1032, ["hit", "type", "color", "size", "effect", "round", "closable", "style", "onClose", "onClick"]);
+        }), 128)) : vue.createCommentVNode("", true),
+        !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTag), {
+          key: 1,
+          hit: _ctx.hit,
+          type: "info",
+          size: _ctx.size,
+          round: _ctx.round,
+          disableTransitions: true,
+          class: "ele-edit-tag-add",
+          style: vue.normalizeStyle(_ctx.buttonStyle),
+          onClick: handleAddClick
+        }, {
+          default: vue.withCtx(() => [
+            vue.renderSlot(_ctx.$slots, "placeholder", {}, () => [
+              _ctx.placeholder ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1, vue.toDisplayString(_ctx.placeholder), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElIcon), {
+                key: 1,
+                class: "ele-edit-tag-add-icon"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(icons.PlusOutlined))
+                ]),
+                _: 1
+              }))
+            ])
+          ]),
+          _: 3
+        }, 8, ["hit", "size", "round", "style"])), [
+          [vue.vShow, !isEdit.value]
+        ]) : vue.createCommentVNode("", true),
+        !_ctx.readonly ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTag), {
+          key: 2,
+          ref_key: "inputTagRef",
+          ref: inputTagRef,
+          size: _ctx.size,
+          round: _ctx.round,
+          disableTransitions: true,
+          class: vue.normalizeClass(["ele-edit-tag-input", { "is-error": !!errorMessage.value }]),
+          style: vue.normalizeStyle(_ctx.inputTagStyle)
         }, {
-          suffix: vue.withCtx(() => [
-            _ctx.loading ? (vue.openBlock(), vue.createBlock(_component_ElIcon, {
-              key: 0,
-              class: "is-loading"
+          default: vue.withCtx(() => [
+            vue.createVNode(vue.unref(elementPlus.ElInput), {
+              ref_key: "inputRef",
+              ref: inputRef,
+              disabled: loading.value,
+              modelValue: inputValue.value,
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => inputValue.value = $event),
+              validateEvent: false,
+              style: vue.normalizeStyle(_ctx.inputStyle),
+              onChange: handleInputChange,
+              onBlur: handleInputBlur,
+              onFocus: handleInputFocus
             }, {
-              default: vue.withCtx(() => [
-                vue.createVNode(_component_LoadingOutlined)
+              suffix: vue.withCtx(() => [
+                loading.value ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElIcon), {
+                  key: 0,
+                  class: "is-loading"
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(icons.LoadingOutlined))
+                  ]),
+                  _: 1
+                })) : vue.createCommentVNode("", true)
               ]),
               _: 1
-            })) : vue.createCommentVNode("", true)
+            }, 8, ["disabled", "modelValue", "style"])
           ]),
           _: 1
-        }, 8, ["disabled", "modelValue", "style", "onChange", "onBlur", "onFocus"])
-      ]),
-      _: 1
-    }, 8, ["size", "round", "class", "style"])), [
-      [vue.vShow, _ctx.isEdit]
-    ]) : vue.createCommentVNode("", true),
-    vue.createVNode(_component_EleTooltip, vue.mergeProps({
-      offset: 7,
-      hideAfter: 0,
-      trigger: "click",
-      triggerKeys: [],
-      disabled: !_ctx.tooltipVisible
-    }, _ctx.tooltipProps || {}, {
-      virtualTriggering: true,
-      virtualRef: _ctx.inputTagRef ? _ctx.inputTagRef.$el : void 0,
-      content: _ctx.errorMessage,
-      visible: _ctx.tooltipVisible
-    }), null, 16, ["disabled", "virtualRef", "content", "visible"])
-  ], 2);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = index;
+        }, 8, ["size", "round", "class", "style"])), [
+          [vue.vShow, isEdit.value]
+        ]) : vue.createCommentVNode("", true),
+        vue.createVNode(EleTooltip, vue.mergeProps({
+          offset: 7,
+          hideAfter: 0,
+          trigger: "click",
+          triggerKeys: [],
+          disabled: !tooltipVisible.value
+        }, _ctx.tooltipProps || {}, {
+          virtualTriggering: true,
+          virtualRef: inputTagRef.value ? inputTagRef.value.$el : void 0,
+          content: errorMessage.value,
+          visible: tooltipVisible.value
+        }), null, 16, ["disabled", "virtualRef", "content", "visible"])
+      ], 2);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/ele-edit-tag/index.d.ts

@@ -1,6 +1,9 @@
 import { ElTagInstance, ElInputInstance } from '../ele-app/el';
 
-declare const _default: import('vue').DefineComponent<{
+declare function __VLS_template(): {
+    placeholder?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     modelValue: import('vue').PropType<string[]>;
     type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
     hit: BooleanConstructor;
@@ -18,25 +21,13 @@ declare const _default: import('vue').DefineComponent<{
     tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
     readonly: BooleanConstructor;
     disabled: BooleanConstructor;
-}, {
-    inputTagRef: import('vue').Ref<ElTagInstance>;
-    inputRef: import('vue').Ref<ElInputInstance>;
-    isEdit: import('vue').Ref<boolean>;
-    inputValue: import('vue').Ref<string>;
-    errorMessage: import('vue').Ref<string>;
-    loading: import('vue').Ref<boolean>;
-    tooltipVisible: import('vue').Ref<boolean>;
-    updateInputValue: (value: string) => void;
-    handleAddClick: () => void;
-    handleTagClose: (index: number, item: string) => void;
-    handleTagClick: (index: number, item: string) => void;
-    handleInputChange: () => void;
-    handleInputBlur: () => void;
-    handleInputFocus: () => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    'update:modelValue': (_value?: string[]) => boolean;
-    change: (_value?: string[]) => boolean;
-    itemClick: (_index: number, _value: string) => boolean;
+}>, {
+    inputTagRef: import('vue').Ref<ElTagInstance, ElTagInstance>;
+    inputRef: import('vue').Ref<ElInputInstance, ElInputInstance>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (_value?: string[] | undefined) => void;
+    change: (_value?: string[] | undefined) => void;
+    itemClick: (_index: number, _value: string) => void;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     modelValue: import('vue').PropType<string[]>;
     type: import('vue').PropType<import('../ele-app/el').ElTagProps["type"]>;
@@ -55,14 +46,20 @@ declare const _default: import('vue').DefineComponent<{
     tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
     readonly: BooleanConstructor;
     disabled: BooleanConstructor;
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((_value?: string[] | undefined) => any) | undefined;
     onChange?: ((_value?: string[] | undefined) => any) | undefined;
     onItemClick?: ((_index: number, _value: string) => any) | undefined;
-}, {
+}>, {
     disabled: boolean;
     round: boolean;
     readonly: boolean;
     hit: boolean;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-ellipsis/index.cjs

@@ -5,11 +5,12 @@ const EleTooltip = require("../ele-tooltip/index");
 const EleText = require("../ele-text/index");
 const props$1 = require("../ele-text/props");
 const props = require("./props");
-const _sfc_main = vue.defineComponent({
-  name: "EleEllipsis",
-  components: { EleText, EleTooltip },
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "EleEllipsis" },
+  __name: "index",
   props: props.ellipsisProps,
-  setup(props2) {
+  setup(__props, { expose: __expose }) {
+    const props2 = __props;
     const textRef = vue.ref(null);
     const virtualRef = vue.ref();
     const text = vue.ref("");
@@ -74,39 +75,24 @@ const _sfc_main = vue.defineComponent({
         virtualRef.value = void 0;
       }
     };
-    return {
-      textRef,
-      virtualRef,
-      tooltipProps,
-      multiLine,
-      textProps,
-      rootStyle,
-      handleHover
+    __expose({
+      textRef
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(EleText, vue.mergeProps(textProps.value, {
+        ref_key: "textRef",
+        ref: textRef,
+        style: rootStyle.value,
+        class: ["ele-ellipsis", { "is-multi-line": multiLine.value }],
+        onMouseover: handleHover
+      }), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default"),
+          virtualRef.value ? (vue.openBlock(), vue.createBlock(EleTooltip, vue.normalizeProps(vue.mergeProps({ key: 0 }, tooltipProps.value)), null, 16)) : vue.createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 16, ["style", "class"]);
     };
   }
 });
-const _export_sfc = (sfc, props2) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props2) {
-    target[key] = val;
-  }
-  return target;
-};
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
-  const _component_EleText = vue.resolveComponent("EleText");
-  return vue.openBlock(), vue.createBlock(_component_EleText, vue.mergeProps(_ctx.textProps, {
-    ref: "textRef",
-    style: _ctx.rootStyle,
-    class: ["ele-ellipsis", { "is-multi-line": _ctx.multiLine }],
-    onMouseover: _ctx.handleHover
-  }), {
-    default: vue.withCtx(() => [
-      vue.renderSlot(_ctx.$slots, "default"),
-      _ctx.virtualRef ? (vue.openBlock(), vue.createBlock(_component_EleTooltip, vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.tooltipProps)), null, 16)) : vue.createCommentVNode("", true)
-    ]),
-    _: 3
-  }, 16, ["style", "class", "onMouseover"]);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = index;
+module.exports = _sfc_main;

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

@@ -1,8 +1,11 @@
 import { StyleValue } from '../ele-app/types';
-import { EleTextProps, EleTextInstance } from '../ele-app/plus';
+import { EleTextInstance } from '../ele-app/plus';
 import { EllipsisTooltip } from './types';
 
-declare const _default: import('vue').DefineComponent<{
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     maxLine: NumberConstructor;
     lineHeight: (StringConstructor | NumberConstructor)[];
     tooltip: {
@@ -21,15 +24,9 @@ declare const _default: import('vue').DefineComponent<{
     icon: import('vue').PropType<import('../ele-text/types').TextIcon>;
     iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
     iconStyle: import('vue').PropType<StyleValue>;
-}, {
-    textRef: import('vue').Ref<EleTextInstance>;
-    virtualRef: import('vue').Ref<HTMLElement | undefined>;
-    tooltipProps: import('vue').ComputedRef<Partial<import('../ele-tooltip/props').TooltipProps>>;
-    multiLine: import('vue').ComputedRef<boolean>;
-    textProps: import('vue').ComputedRef<EleTextProps>;
-    rootStyle: import('vue').ComputedRef<Partial<import('vue').CSSProperties>>;
-    handleHover: (e: MouseEvent) => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, {
+    textRef: import('vue').Ref<EleTextInstance, EleTextInstance>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     maxLine: NumberConstructor;
     lineHeight: (StringConstructor | NumberConstructor)[];
     tooltip: {
@@ -48,11 +45,17 @@ declare const _default: import('vue').DefineComponent<{
     icon: import('vue').PropType<import('../ele-text/types').TextIcon>;
     iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
     iconStyle: import('vue').PropType<StyleValue>;
-}>>, {
+}>> & Readonly<{}>, {
     strong: boolean;
     underline: boolean;
     tooltip: boolean | EllipsisTooltip;
     italic: boolean;
     deleted: boolean;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};