yc-design-vue 1.7.6 → 1.7.7

package/es/Progress/ProgressLine.vue.js

@@ -1,7 +1,99 @@
-import _sfc_main from "./ProgressLine.vue2.js";
-/* empty css                  */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const ProgressLine = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ccea0502"]]);
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, unref, createElementVNode, createCommentVNode, normalizeStyle, renderSlot, createBlock, toDisplayString, resolveDynamicComponent } from "vue";
+import { TYPE_ICON_MAP, TYPE_ICON_COLOR_MAP } from "../_shared/constants/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../_shared/utils/dom.js";
+import { isObject } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+const _hoisted_1 = ["aria-valuenow"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-progress-line-text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ProgressLine",
+  props: {
+    size: {},
+    percent: {},
+    status: {},
+    showText: { type: Boolean },
+    text: {},
+    width: {},
+    strokeWidth: {},
+    color: {},
+    trackColor: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      width,
+      trackColor,
+      color,
+      percent,
+      size,
+      strokeWidth: _strokeWidth
+    } = toRefs(props);
+    const strokeWidth = computed(() => {
+      const map = {
+        small: 3,
+        medium: 4,
+        large: 8
+      };
+      return _strokeWidth.value ?? map[size.value];
+    });
+    const style = computed(() => ({
+      width: valueToPx(width.value),
+      height: valueToPx(strokeWidth.value),
+      backgroundColor: trackColor.value
+    }));
+    const barStyle = computed(() => {
+      return {
+        width: `${percent.value * 100}%`,
+        ...getBackground(color.value)
+      };
+    });
+    const getBackground = (color2) => {
+      if (isObject(color2)) {
+        const val = Object.keys(color2).map((key) => `${color2[key]} ${key}`).join(",");
+        return {
+          backgroundImage: `linear-gradient(to right, ${val})`
+        };
+      }
+      return {
+        backgroundColor: color2
+      };
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "progressbar",
+        "aria-valuemin": "0",
+        "aria-valuemax": "100",
+        "aria-valuenow": unref(percent),
+        class: "yc-progress-line-wrapper"
+      }, [
+        createElementVNode("div", {
+          class: "yc-progress-line",
+          style: normalizeStyle(style.value)
+        }, [
+          createElementVNode("div", {
+            class: "yc-progress-line-bar",
+            style: normalizeStyle(barStyle.value)
+          }, null, 4)
+        ], 4),
+        _ctx.showText ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          renderSlot(_ctx.$slots, "text", { percent: unref(percent) }, () => [
+            createElementVNode("span", null, toDisplayString(_ctx.text), 1),
+            _ctx.status === "danger" ? (openBlock(), createBlock(resolveDynamicComponent(unref(TYPE_ICON_MAP).warning), {
+              key: 0,
+              color: unref(TYPE_ICON_COLOR_MAP).error
+            }, null, 8, ["color"])) : createCommentVNode("", true)
+          ])
+        ])) : createCommentVNode("", true)
+      ], 8, _hoisted_1);
+    };
+  }
+});
 export {
-  ProgressLine as default
+  _sfc_main as default
 };

package/es/Progress/ProgressLine.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./ProgressLine.vue.js";
+/* empty css                  */
+export {
+  _sfc_main as default
+};

package/es/Progress/index.js

@@ -1,7 +1,8 @@
-import _Progress from "./Progress.vue.js";
-const Progress = Object.assign(_Progress, {
+import _sfc_main from "./Progress.vue.js";
+/* empty css              */
+const Progress = Object.assign(_sfc_main, {
   install: (app) => {
-    app.component("Yc" + _Progress.name, _Progress);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
   }
 });
 export {

package/es/Radio/Radio.vue.js

@@ -1,7 +1,124 @@
-import _sfc_main from "./Radio.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Radio = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-351c0cc3"]]);
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, renderSlot, Fragment, createVNode, createCommentVNode, withCtx } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import useControlValue from "../_shared/utils/control.js";
+import useContext from "./hooks/useContext.js";
+import _sfc_main$1 from "../_shared/components/IconButton.vue.js";
+/* empty css                                    */
+/* empty css                                         */
+const _hoisted_1 = ["value", "checked", "disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-radio-label text-ellipsis"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "yc-radio-button-content"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Radio"
+  },
+  __name: "Radio",
+  props: {
+    modelValue: { type: [String, Number, Boolean], default: void 0 },
+    defaultChecked: { type: Boolean, default: false },
+    value: { type: [String, Number, Boolean], default: true },
+    type: { default: void 0 },
+    disabled: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultChecked,
+      value: radioValue,
+      disabled,
+      type
+    } = toRefs(props);
+    const {
+      computedValue: _computedValue,
+      disabled: injectDisabled,
+      type: injectType,
+      size,
+      hasGroup,
+      emits: _emits
+    } = useContext().inject();
+    const computedValue = useControlValue(
+      modelValue,
+      defaultChecked.value,
+      (val) => {
+        emits("update:modelValue", val);
+      }
+    );
+    const checked = computed(() => {
+      return hasGroup.value ? _computedValue.value == radioValue.value : computedValue.value;
+    });
+    const computedDisabled = computed(() => {
+      return injectDisabled.value || disabled.value;
+    });
+    const computedType = computed(() => {
+      return type.value ?? injectType.value;
+    });
+    const handleChange = (e) => {
+      if (computedDisabled.value) return;
+      if (hasGroup.value) {
+        _computedValue.value = radioValue.value;
+      } else {
+        computedValue.value = radioValue.value;
+        emits("change", radioValue.value, e);
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: normalizeClass([
+          `yc-radio-button-size-${unref(size)}`,
+          `yc-radio${computedType.value == "radio" ? "" : "-button"}`,
+          `yc-radio-${checked.value ? "checked" : "unchecked"}`,
+          {
+            "yc-radio-disabled": computedDisabled.value
+          }
+        ]),
+        onClick: handleChange
+      }, [
+        createElementVNode("input", {
+          type: "radio",
+          class: "yc-radio-target",
+          value: _ctx.value,
+          checked: checked.value,
+          disabled: computedDisabled.value
+        }, null, 8, _hoisted_1),
+        renderSlot(_ctx.$slots, "radio", {
+          checked: checked.value,
+          disabled: computedDisabled.value
+        }, () => [
+          computedType.value == "radio" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+            createVNode(unref(_sfc_main$1), {
+              "hover-size": 24,
+              hoverable: !checked.value && !computedDisabled.value
+            }, {
+              default: withCtx(() => _cache[0] || (_cache[0] = [
+                createElementVNode("span", { class: "yc-radio-icon" }, null, -1)
+              ])),
+              _: 1,
+              __: [0]
+            }, 8, ["hoverable"]),
+            _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_2, [
+              renderSlot(_ctx.$slots, "default")
+            ])) : createCommentVNode("", true)
+          ], 64)) : (openBlock(), createElementBlock("span", _hoisted_3, [
+            renderSlot(_ctx.$slots, "default")
+          ]))
+        ])
+      ], 2);
+    };
+  }
+});
 export {
-  _Radio as default
+  _sfc_main as default
 };

package/es/Radio/Radio.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./Radio.vue.js";
+/* empty css           */
+export {
+  _sfc_main as default
+};

package/es/Radio/RadioGroup.vue.js

@@ -1,6 +1,7 @@
 import { defineComponent, createElementBlock, openBlock, normalizeClass, renderSlot, Fragment, renderList, unref, createBlock, createSlots, withCtx, createTextVNode, toDisplayString, mergeProps } from "vue";
 import useContext from "./hooks/useContext.js";
-import _Radio from "./Radio.vue.js";
+import _sfc_main$1 from "./Radio.vue.js";
+/* empty css           */
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
     name: "RadioGroup"
@@ -29,7 +30,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }, [
         renderSlot(_ctx.$slots, "default"),
         (openBlock(true), createElementBlock(Fragment, null, renderList(unref(options), (item, index) => {
-          return openBlock(), createBlock(_Radio, {
+          return openBlock(), createBlock(_sfc_main$1, {
             key: index,
             value: item.value,
             disabled: item.disabled

package/es/Radio/index.js

@@ -1,14 +1,15 @@
-import _Radio from "./Radio.vue.js";
-import _sfc_main from "./RadioGroup.vue.js";
+import _sfc_main from "./Radio.vue.js";
+/* empty css           */
+import _sfc_main$1 from "./RadioGroup.vue.js";
 /* empty css                */
-const Radio = Object.assign(_Radio, {
-  group: _sfc_main,
+const Radio = Object.assign(_sfc_main, {
+  group: _sfc_main$1,
   install: (app) => {
-    app.component("Yc" + _Radio.name, _Radio);
     app.component("Yc" + _sfc_main.name, _sfc_main);
+    app.component("Yc" + _sfc_main$1.name, _sfc_main$1);
   }
 });
 export {
-  _sfc_main as RadioGroup,
+  _sfc_main$1 as RadioGroup,
   Radio as default
 };

package/es/Rate/index.js

@@ -1,7 +1,8 @@
-import _Rate from "./index.vue.js";
-const Rate = Object.assign(_Rate, {
+import _sfc_main from "./index.vue.js";
+/* empty css           */
+const Rate = Object.assign(_sfc_main, {
   install: (app) => {
-    app.component("Yc" + _Rate.name, _Rate);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
   }
 });
 export {

package/es/Rate/index.vue.js

@@ -1,7 +1,148 @@
-import _sfc_main from "./index.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Rate = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-18dacb32"]]);
+import { defineComponent, toRefs, ref, computed, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, createCommentVNode, createElementVNode, withModifiers, normalizeStyle, renderSlot, createBlock } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { sleep } from "../_shared/utils/dom.js";
+import { isObject } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import _sfc_main$1 from "../_shared/icons/IconFaceSmile.vue.js";
+import _sfc_main$2 from "../_shared/icons/IconStar.vue.js";
+import useControlValue from "../_shared/utils/control.js";
+const _hoisted_1 = ["onClick", "onMouseenter"];
+const _hoisted_2 = ["onClick", "onMouseenter"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Rate"
+  },
+  __name: "index",
+  props: {
+    count: { default: 5 },
+    modelValue: { default: void 0 },
+    defaultValue: { default: 0 },
+    allowHalf: { type: Boolean, default: false },
+    allowClear: { type: Boolean },
+    grading: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    color: { default: "rgb(247, 186, 30)" }
+  },
+  emits: ["update:modelValue", "change", "hover-change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultValue,
+      readonly,
+      disabled,
+      count,
+      allowClear,
+      color: _color
+    } = toRefs(props);
+    const chars = ref([]);
+    let loading = false;
+    const curHover = ref(0);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits("update:modelValue", val);
+      }
+    );
+    const color = computed(() => {
+      var _a;
+      if (isObject(_color.value)) {
+        return ((_a = Object.entries(_color.value).find(
+          ([key]) => curHover.value <= +key
+        )) == null ? void 0 : _a[1]) ?? "rgb(247, 186, 30)";
+      } else {
+        return _color.value ?? "rgb(247, 186, 30)";
+      }
+    });
+    const handleClick = async (index) => {
+      if (readonly.value || disabled.value || loading) {
+        return;
+      }
+      computedValue.value = allowClear.value && computedValue.value == index ? 0 : index;
+      emits("change", computedValue.value);
+      loading = true;
+      for (let i = 1; i <= count.value; i++) {
+        if (i > computedValue.value) {
+          continue;
+        }
+        const el = chars.value[i];
+        el.classList.add("yc-rate-character-scale");
+        await sleep(50);
+        setTimeout(() => {
+          el.classList.remove("yc-rate-character-scale");
+        }, 150);
+      }
+      loading = false;
+    };
+    let timer;
+    const handleMouseenter = (i) => {
+      if (readonly.value || disabled.value) return;
+      if (timer) clearTimeout(timer);
+      curHover.value = i;
+      emits("hover-change", i);
+    };
+    const handleMouseleave = () => {
+      if (readonly.value || disabled.value) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        curHover.value = 0;
+      }, 100);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-rate",
+          {
+            "yc-rate-disabled": unref(disabled),
+            "yc-rate-readonly": unref(readonly)
+          }
+        ])
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(count), (i) => {
+          return openBlock(), createElementBlock("div", {
+            key: i,
+            class: "yc-rate-character",
+            ref_for: true,
+            ref: (el) => chars.value[i] = el
+          }, [
+            _ctx.allowHalf ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "yc-rate-character-left",
+              style: normalizeStyle({
+                color: i - 0.5 <= unref(computedValue) && !curHover.value || i - 0.5 <= curHover.value ? color.value : ""
+              }),
+              onClick: withModifiers(($event) => handleClick(i - 0.5), ["stop"]),
+              onMouseenter: ($event) => handleMouseenter(i - 0.5),
+              onMouseleave: handleMouseleave
+            }, [
+              renderSlot(_ctx.$slots, "character", { index: i }, () => [
+                _ctx.grading ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$2), { key: 1 }))
+              ])
+            ], 44, _hoisted_1)) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: "yc-rate-character-right",
+              style: normalizeStyle({
+                color: i <= unref(computedValue) && !curHover.value || i <= curHover.value ? color.value : ""
+              }),
+              onClick: ($event) => handleClick(i),
+              onMouseenter: ($event) => handleMouseenter(i),
+              onMouseleave: handleMouseleave
+            }, [
+              renderSlot(_ctx.$slots, "character", { index: i }, () => [
+                _ctx.grading ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$2), { key: 1 }))
+              ])
+            ], 44, _hoisted_2)
+          ]);
+        }), 128))
+      ], 2);
+    };
+  }
+});
 export {
-  _Rate as default
+  _sfc_main as default
 };

package/es/Rate/index.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./index.vue.js";
+/* empty css           */
+export {
+  _sfc_main as default
+};

package/es/ResizeBox/index.js

@@ -1,7 +1,8 @@
-import _ResizeBox from "./index.vue.js";
-const ResizeBox = Object.assign(_ResizeBox, {
+import _sfc_main from "./index.vue.js";
+/* empty css           */
+const ResizeBox = Object.assign(_sfc_main, {
   install: (app) => {
-    app.component("Yc" + _ResizeBox.name, _ResizeBox);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
   }
 });
 export {

package/es/ResizeBox/index.vue.js

@@ -1,7 +1,161 @@
-import _sfc_main from "./index.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _ResizeBox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a9bac180"]]);
+import { defineComponent, useSlots, toRefs, reactive, ref, createBlock, openBlock, resolveDynamicComponent, withCtx, renderSlot, createElementBlock, Fragment, renderList, normalizeClass, createElementVNode, createVNode, unref } from "vue";
+import { useEventListener, useResizeObserver } from "../node_modules/@vueuse/core/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+import useControlValue from "../_shared/utils/control.js";
+/* empty css                             */
+import _sfc_main$1 from "../_shared/icons/IconDragDot.vue.js";
+const _hoisted_1 = ["dir", "onMousedown"];
+const _hoisted_2 = { class: "yc-resizebox-trigger-icon-wrapper" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "ResizeBox"
+  },
+  __name: "index",
+  props: {
+    width: { default: void 0 },
+    height: { default: void 0 },
+    component: { default: "div" },
+    directions: { default: () => ["right"] }
+  },
+  emits: ["update:width", "update:height", "moving-start", "moving", "moving-end"],
+  setup(__props, { emit: __emit }) {
+    useSlots();
+    const props = __props;
+    const emits = __emit;
+    const { width, height } = toRefs(props);
+    const computedWidth = useControlValue(width, 0, (val) => {
+      emits("update:width", val);
+    });
+    const computedHeight = useControlValue(height, 0, (val) => {
+      emits("update:height", val);
+    });
+    const triggeDoms = reactive([]);
+    const triggerSize = reactive({
+      left: 0,
+      right: 0,
+      bottom: 0,
+      top: 0
+    });
+    const boxRef = ref();
+    const dragDirection = ref(null);
+    const x = ref(0);
+    const y = ref(0);
+    let cursor;
+    const handleMovingStart = (dir, e) => {
+      e.preventDefault();
+      dragDirection.value = dir;
+      const { width: width2, height: height2 } = boxRef.value.getBoundingClientRect();
+      const { clientX, clientY } = e;
+      computedWidth.value = width2;
+      computedHeight.value = height2;
+      x.value = clientX;
+      y.value = clientY;
+      cursor = getComputedStyle(document.body).cursor;
+      document.body.style.cursor = ["left", "right"].includes(dir) ? "col-resize" : "row-resize";
+      emits("moving-start", e);
+    };
+    const handleMoving = async (e) => {
+      if (!dragDirection.value || !boxRef.value) {
+        return;
+      }
+      const { clientX, clientY } = e;
+      const movementX = dragDirection.value == "left" ? x.value - clientX : clientX - x.value;
+      const movementY = dragDirection.value == "top" ? y.value - clientY : clientY - y.value;
+      const minWidth = triggerSize.left + triggerSize.right;
+      const minHeight = triggerSize.top + triggerSize.bottom;
+      x.value = clientX;
+      y.value = clientY;
+      if (["left", "right"].includes(dragDirection.value)) {
+        computedWidth.value += movementX;
+        computedWidth.value <= minWidth && (computedWidth.value = minWidth);
+        boxRef.value.style.width = valueToPx(computedWidth.value);
+      } else {
+        computedHeight.value += movementY;
+        computedHeight.value <= minHeight && (computedHeight.value = minHeight);
+        boxRef.value.style.height = valueToPx(computedHeight.value);
+      }
+      const { width: width2, height: height2 } = boxRef.value.getBoundingClientRect();
+      if (computedWidth.value != width2) {
+        computedWidth.value = width2;
+      }
+      if (height2 != computedHeight.value) {
+        computedHeight.value = height2;
+      }
+      emits(
+        "moving",
+        {
+          width: width2,
+          height: height2
+        },
+        e
+      );
+    };
+    const handleMovingEnd = (e) => {
+      if (!dragDirection.value) return;
+      dragDirection.value = null;
+      document.body.style.cursor = cursor;
+      emits("moving-end", e);
+    };
+    useEventListener("mousemove", handleMoving);
+    useEventListener("mouseup", handleMovingEnd);
+    useResizeObserver(
+      () => {
+        return triggeDoms;
+      },
+      (entries) => {
+        entries.forEach((item) => {
+          const direction = item.target.getAttribute("dir");
+          const {
+            contentRect: { width: width2, height: height2 }
+          } = item;
+          triggerSize[direction] = ["right", "left"].includes(direction) ? width2 : height2;
+        });
+      },
+      {
+        box: "border-box"
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(_ctx.component), {
+        class: "yc-resizebox",
+        ref_key: "boxRef",
+        ref: boxRef
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default"),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.directions, (dir, i) => {
+            return openBlock(), createElementBlock("div", {
+              key: dir,
+              class: normalizeClass([
+                "yc-resizebox-trigger",
+                `yc-resizebox-direction-${dir}`,
+                `yc-resizebox-trigger-${["left", "right"].includes(dir) ? "vertical" : "horizontal"}`
+              ]),
+              dir,
+              ref_for: true,
+              ref: (el) => triggeDoms[i] = el,
+              onMousedown: ($event) => handleMovingStart(dir, $event)
+            }, [
+              renderSlot(_ctx.$slots, "resize-trigger", { direction: dir }, () => [
+                createElementVNode("div", _hoisted_2, [
+                  renderSlot(_ctx.$slots, "resize-trigger-icon", { direction: dir }, () => [
+                    createVNode(unref(_sfc_main$1), {
+                      rotate: ["left", "right"].includes(dir) ? 90 : 0
+                    }, null, 8, ["rotate"])
+                  ])
+                ])
+              ])
+            ], 42, _hoisted_1);
+          }), 128))
+        ]),
+        _: 3
+      }, 512);
+    };
+  }
+});
 export {
-  _ResizeBox as default
+  _sfc_main as default
 };

package/es/ResizeBox/index.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./index.vue.js";
+/* empty css           */
+export {
+  _sfc_main as default
+};

package/es/Result/index.js

@@ -1,7 +1,8 @@
-import _Result from "./index.vue.js";
-const Result = Object.assign(_Result, {
+import _sfc_main from "./index.vue.js";
+/* empty css           */
+const Result = Object.assign(_sfc_main, {
   install: (app) => {
-    app.component("Yc" + _Result.name, _Result);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
   }
 });
 export {