yc-design-vue 1.7.6 → 1.7.7

package/es/VerificationCode/index.vue.js

@@ -1,7 +1,127 @@
-import _sfc_main from "./index.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _VerificationCode = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b458a923"]]);
+import { defineComponent, toRefs, computed, ref, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, createVNode, createBlock, createCommentVNode, resolveDynamicComponent } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { sleep } from "../_shared/utils/dom.js";
+import { isNumber, isString, isFunction } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import { getSlotFunction } from "../_shared/utils/vue-utils.js";
+import { getGlobalConfig } from "../_shared/utils/global-config.js";
+import useControlValue from "../_shared/utils/control.js";
+import { nanoid } from "../node_modules/nanoid/index.browser.js";
+import Input from "../Input/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "VerificationCode"
+  },
+  __name: "index",
+  props: {
+    modelValue: { default: void 0 },
+    defaultValue: { default: "" },
+    length: { default: 6 },
+    size: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    masked: { type: Boolean },
+    readonly: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    separator: {},
+    formatter: {}
+  },
+  emits: ["update:modelValue", "input", "change", "finish"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { modelValue, defaultValue, length: _length } = toRefs(props);
+    const { formatter } = props;
+    const { size } = getGlobalConfig(props);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        if (val.length == _length.value) {
+          emits("finish", val);
+        }
+        emits("update:modelValue", val);
+      }
+    );
+    const length = computed(
+      () => new Array(_length.value).fill("").map(() => nanoid())
+    );
+    const formatValue = ref([]);
+    const inputValue = computed(() => {
+      const base = [...computedValue.value];
+      for (let i = base.length; i < _length.value; i++) {
+        base[i] = "";
+      }
+      return base.map((item, i) => {
+        const format = formatter == null ? void 0 : formatter(item, i, formatValue.value.join(""));
+        return item && (isNumber(format) || isString(format)) ? format : item;
+      });
+    });
+    const inputList = ref([]);
+    const isWritable = (i) => {
+      for (let k = 1; k < i; k++) {
+        if (!inputValue.value[k]) return false;
+      }
+      return true;
+    };
+    const handleInput = async (v, ev, i) => {
+      const value = v ? v.at(v.length - 1) : " ";
+      const format = formatter == null ? void 0 : formatter(value, i, formatValue.value.join(""));
+      if (isFunction(formatter) && !isNumber(format) && !isString(format)) {
+        return;
+      }
+      emits("input", value, ev, i);
+      computedValue.value = computedValue.value.slice(0, i) + value + computedValue.value.slice(i + 1);
+      if (v && !inputValue.value[i + 1] && i < _length.value - 1) {
+        inputList.value[i].blur();
+        await sleep(0);
+        inputList.value[i + 1].focus();
+      }
+    };
+    const handleMousedown = (e, i) => {
+      if (isWritable(i)) return;
+      e.preventDefault();
+    };
+    const handleClick = async (i) => {
+      var _a;
+      if (isWritable(i)) return;
+      const index = inputValue.value.findIndex((item) => !item);
+      await sleep(0);
+      (_a = inputList.value[index]) == null ? void 0 : _a.focus();
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["yc-verification-code", `yc-verification-code-size-${unref(size)}`])
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(length.value, (v, i) => {
+          var _a;
+          return openBlock(), createElementBlock(Fragment, { key: v }, [
+            createVNode(unref(Input), {
+              "model-value": inputValue.value[i],
+              size: unref(size),
+              disabled: _ctx.disabled,
+              error: _ctx.error,
+              "invisible-button": false,
+              visibility: _ctx.masked,
+              readonly: _ctx.readonly || !isWritable(i),
+              class: normalizeClass([
+                {
+                  "yc-input-disabled-write": !isWritable(i)
+                }
+              ]),
+              ref_for: true,
+              ref: (el) => inputList.value[i] = el,
+              onClick: ($event) => handleClick(i),
+              onMousedown: ($event) => handleMousedown($event, i),
+              onInput: (v2, ev) => handleInput(v2, ev, i),
+              onChange: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("change", unref(computedValue)))
+            }, null, 8, ["model-value", "size", "disabled", "error", "visibility", "readonly", "class", "onClick", "onMousedown", "onInput"]),
+            ((_a = _ctx.separator) == null ? void 0 : _a.call(_ctx, i, inputValue.value[i])) ? (openBlock(), createBlock(resolveDynamicComponent(unref(getSlotFunction)(_ctx.separator(i, inputValue.value[i]))), { key: 0 })) : createCommentVNode("", true)
+          ], 64);
+        }), 128))
+      ], 2);
+    };
+  }
+});
 export {
-  _VerificationCode as default
+  _sfc_main as default
 };

package/es/VerificationCode/index.vue3.js

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

package/es/Watermark/index.js

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

package/es/Watermark/index.vue.js

@@ -1,7 +1,276 @@
-import _sfc_main from "./index.vue2.js";
-/* empty css           */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Watermark = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2c1dbccf"]]);
+import { defineComponent, toRefs, ref, computed, watch, onMounted, createElementBlock, openBlock, renderSlot } from "vue";
+import { useMutationObserver } from "../node_modules/@vueuse/core/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { isArray } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Watermark"
+  },
+  __name: "index",
+  props: {
+    content: { default: "" },
+    image: { default: "" },
+    width: { default: void 0 },
+    height: { default: void 0 },
+    gap: { default: () => [90, 90] },
+    offset: { default: () => [45, 45] },
+    rotate: { default: -22 },
+    font: { default: () => {
+      return {
+        color: "rgba(0, 0, 0, 0.15)",
+        fontSize: 16,
+        fontFamily: "sans-serif",
+        fontStyle: "normal",
+        textAlign: "center",
+        fontWeight: "normal"
+      };
+    } },
+    zIndex: { default: 6 },
+    alpha: { default: 1 },
+    grayscale: { type: Boolean, default: false },
+    repeat: { type: Boolean, default: true },
+    staggered: { type: Boolean, default: true },
+    antiTamper: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const {
+      width,
+      height,
+      alpha,
+      image,
+      grayscale,
+      rotate,
+      repeat,
+      staggered,
+      antiTamper,
+      zIndex
+    } = toRefs(props);
+    const containerRef = ref();
+    const ratio = window.devicePixelRatio || 1;
+    const watermarkMap = ref(/* @__PURE__ */ new Map());
+    const color = computed(() => {
+      var _a;
+      return (_a = props.font) == null ? void 0 : _a.color;
+    });
+    const fontSize = computed(() => {
+      var _a;
+      return ((_a = props.font) == null ? void 0 : _a.fontSize) ?? 16;
+    });
+    const fontWeight = computed(() => {
+      var _a;
+      return ((_a = props.font) == null ? void 0 : _a.fontWeight) ?? "normal";
+    });
+    const fontStyle = computed(() => {
+      var _a;
+      return ((_a = props.font) == null ? void 0 : _a.fontStyle) ?? "normal";
+    });
+    const fontFamily = computed(() => {
+      var _a;
+      return ((_a = props.font) == null ? void 0 : _a.fontFamily) ?? "sans-serif";
+    });
+    const textAlign = computed(() => {
+      var _a;
+      return ((_a = props.font) == null ? void 0 : _a.textAlign) ?? "center";
+    });
+    const contents = computed(
+      () => isArray(props.content) ? props.content : [props.content]
+    );
+    const gapX = computed(() => {
+      var _a;
+      return ((_a = props.gap) == null ? void 0 : _a[0]) ?? 90;
+    });
+    const gapY = computed(() => {
+      var _a;
+      return ((_a = props.gap) == null ? void 0 : _a[1]) ?? 90;
+    });
+    const gapXCenter = computed(() => gapX.value / 2);
+    const gapYCenter = computed(() => gapY.value / 2);
+    const offsetLeft = computed(() => {
+      var _a;
+      return ((_a = props.offset) == null ? void 0 : _a[0]) ?? gapXCenter.value;
+    });
+    const offsetTop = computed(() => {
+      var _a;
+      return ((_a = props.offset) == null ? void 0 : _a[1]) ?? gapYCenter.value;
+    });
+    const markStyle = computed(() => {
+      const left = offsetLeft.value - gapXCenter.value;
+      const top = offsetTop.value - gapYCenter.value;
+      return {
+        position: "absolute",
+        left: left > 0 ? `${left}px` : 0,
+        top: top > 0 ? `${top}px` : 0,
+        width: left > 0 ? `calc(100% - ${left}px)` : "100%",
+        height: top > 0 ? `calc(100% - ${top}px)` : "100%",
+        pointerEvents: "none",
+        backgroundRepeat: props.repeat ? "repeat" : "no-repeat",
+        backgroundPosition: `${left > 0 ? 0 : left}px ${top > 0 ? 0 : top}px`,
+        zIndex: zIndex.value ?? 6
+      };
+    });
+    const isStaggered = computed(() => staggered.value && repeat.value);
+    function camelToKebab(camelCase) {
+      return camelCase.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+    }
+    function styleToString(style) {
+      return Object.entries(style).map(([key, value]) => `${camelToKebab(key)}:${value}`).join(";");
+    }
+    function canvasToGray(canvas) {
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+      const { data } = imageData;
+      for (let i = 0; i < data.length; i += 4) {
+        const brightness = (data[i] + data[i + 1] + data[i + 2]) / 3;
+        data[i] = brightness;
+        data[i + 1] = brightness;
+        data[i + 2] = brightness;
+      }
+      ctx.putImageData(imageData, 0, 0);
+    }
+    const appendWatermark = (base64, width2) => {
+      var _a;
+      if (containerRef.value) {
+        const watermarkEle = watermarkMap.value.get(containerRef.value);
+        if (watermarkEle) {
+          if (containerRef.value.contains(watermarkEle)) {
+            containerRef.value.removeChild(watermarkEle);
+          }
+          watermarkMap.value.delete(containerRef.value);
+        }
+        const newWatermarkEle = document.createElement("div");
+        newWatermarkEle.setAttribute(
+          "style",
+          styleToString({
+            ...markStyle.value,
+            backgroundImage: `url('${base64}')`,
+            backgroundSize: `${width2}px`
+          })
+        );
+        (_a = containerRef.value) == null ? void 0 : _a.append(newWatermarkEle);
+        watermarkMap.value.set(containerRef.value, newWatermarkEle);
+      }
+    };
+    const getMarkSize = (ctx) => {
+      let defaultWidth = 120;
+      let defaultHeight = 28;
+      if (!image.value && ctx.measureText) {
+        ctx.font = `${fontSize.value}px ${fontFamily.value}`;
+        const widths = contents.value.map((item) => ctx.measureText(item).width);
+        defaultWidth = Math.ceil(Math.max(...widths));
+        defaultHeight = fontSize.value * contents.value.length + (contents.value.length - 1) * 3;
+      }
+      return [width.value ?? defaultWidth, height.value ?? defaultHeight];
+    };
+    const renderWatermark = () => {
+      var _a;
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      const [markWidth, markheight] = getMarkSize(ctx);
+      const realMarkWidth = markWidth * ratio;
+      const realMarkHeight = markheight * ratio;
+      const canvasWidth = (gapX.value + markWidth) * ratio;
+      const canvasHeight = (gapY.value + markheight) * ratio;
+      const drawX = gapX.value / 2 * ratio;
+      const drawY = gapY.value / 2 * ratio;
+      const rotateX = canvasWidth / 2;
+      const rotateY = canvasHeight / 2;
+      const baseSize = isStaggered.value ? 2 : 1;
+      const fillWidth = (gapX.value + markWidth) * baseSize;
+      canvas.width = canvasWidth * baseSize;
+      canvas.height = canvasHeight * baseSize;
+      ctx.globalAlpha = alpha.value;
+      ctx.save();
+      ctx.translate(rotateX, rotateY);
+      ctx.rotate(Math.PI / 180 * rotate.value);
+      ctx.translate(-rotateX, -rotateY);
+      const drawImage = () => {
+        ctx.restore();
+        if (isStaggered.value) {
+          ctx.drawImage(
+            canvas,
+            0,
+            0,
+            canvasWidth,
+            canvasHeight,
+            canvasWidth,
+            canvasHeight,
+            canvasWidth,
+            canvasHeight
+          );
+        }
+        grayscale.value && canvasToGray(canvas);
+        appendWatermark(canvas.toDataURL(), fillWidth);
+      };
+      if (image.value) {
+        const img = new Image();
+        img.onload = () => {
+          ctx.drawImage(img, drawX, drawY, realMarkWidth, realMarkHeight);
+          drawImage();
+        };
+        img.crossOrigin = "anonymous";
+        img.referrerPolicy = "no-referrer";
+        img.src = image.value;
+      } else {
+        const mergedFontSize = Number(fontSize.value) * ratio;
+        ctx.font = `${fontStyle.value} normal ${fontWeight.value} ${mergedFontSize}px/${markheight}px ${fontFamily.value}`;
+        ctx.fillStyle = color.value;
+        ctx.textAlign = textAlign.value;
+        ctx.textBaseline = "top";
+        ctx.translate(realMarkWidth / 2, 0);
+        (_a = contents.value) == null ? void 0 : _a.forEach((item, index) => {
+          ctx.fillText(
+            item ?? "",
+            drawX,
+            drawY + index * (mergedFontSize + 3 * ratio)
+          );
+        });
+        drawImage();
+      }
+    };
+    const isWatermarkEle = (ele) => {
+      return Array.from(watermarkMap.value.values()).includes(ele);
+    };
+    const handleMutations = (mutations) => {
+      if (!antiTamper.value) return;
+      for (const mutation of mutations) {
+        const isRemoved = Array.from(mutation.removedNodes).some(
+          (node) => isWatermarkEle(node)
+        );
+        const isModified = mutation.type === "attributes" && isWatermarkEle(mutation.target);
+        if (isRemoved || isModified) {
+          renderWatermark();
+          break;
+        }
+      }
+    };
+    watch(props, renderWatermark, { deep: true, flush: "post" });
+    useMutationObserver(containerRef, handleMutations, {
+      attributes: true,
+      childList: true,
+      characterData: true,
+      subtree: true
+    });
+    onMounted(() => {
+      renderWatermark();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "yc-watermark",
+        ref_key: "containerRef",
+        ref: containerRef
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 512);
+    };
+  }
+});
 export {
-  _Watermark as default
+  _sfc_main as default
 };

package/es/Watermark/index.vue3.js

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

package/es/_shared/components/ExpandTransition.vue2.js

@@ -1,7 +1,49 @@
-import _sfc_main from "./ExpandTransition.vue3.js";
-/* empty css                     */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-const ExpandTransition = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-6e588238"]]);
+import { defineComponent, createBlock, openBlock, Transition, mergeProps, withCtx, renderSlot } from "vue";
+import "../../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../utils/dom.js";
+import "../utils/time.js";
+import "../../Empty/index.js";
+/* empty css         */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ExpandTransition",
+  setup(__props) {
+    const transitions = {
+      onBeforeEnter(el) {
+        el.style.maxHeight = "0";
+        el.style.opacity = "0";
+      },
+      onEnter(el) {
+        el.style.maxHeight = valueToPx(el.scrollHeight);
+        el.style.opacity = "1";
+      },
+      onAfterEnter(el) {
+        el.style.maxHeight = "";
+        el.style.opacity = "";
+      },
+      // 收起的时候卡顿
+      onBeforeLeave(el) {
+        el.style.maxHeight = valueToPx(el.scrollHeight);
+        el.style.opacity = "1";
+      },
+      onLeave(el) {
+        el.style.maxHeight = "0";
+        el.style.opacity = "0";
+      },
+      onAfterLeave(el) {
+        el.style.maxHeight = "";
+        el.style.opacity = "";
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, mergeProps({ name: "expand" }, transitions), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
 export {
-  ExpandTransition as default
+  _sfc_main as default
 };

package/es/_shared/components/ExpandTransition.vue3.js

@@ -1,49 +1,5 @@
-import { defineComponent, createBlock, openBlock, Transition, mergeProps, withCtx, renderSlot } from "vue";
-import "../../node_modules/tinycolor2/esm/tinycolor.js";
-import { valueToPx } from "../utils/dom.js";
-import "../utils/time.js";
-import "../../Empty/index.js";
-/* empty css         */
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ExpandTransition",
-  setup(__props) {
-    const transitions = {
-      onBeforeEnter(el) {
-        el.style.maxHeight = "0";
-        el.style.opacity = "0";
-      },
-      onEnter(el) {
-        el.style.maxHeight = valueToPx(el.scrollHeight);
-        el.style.opacity = "1";
-      },
-      onAfterEnter(el) {
-        el.style.maxHeight = "";
-        el.style.opacity = "";
-      },
-      // 收起的时候卡顿
-      onBeforeLeave(el) {
-        el.style.maxHeight = valueToPx(el.scrollHeight);
-        el.style.opacity = "1";
-      },
-      onLeave(el) {
-        el.style.maxHeight = "0";
-        el.style.opacity = "0";
-      },
-      onAfterLeave(el) {
-        el.style.maxHeight = "";
-        el.style.opacity = "";
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(Transition, mergeProps({ name: "expand" }, transitions), {
-        default: withCtx(() => [
-          renderSlot(_ctx.$slots, "default", {}, void 0, true)
-        ]),
-        _: 3
-      }, 16);
-    };
-  }
-});
+import _sfc_main from "./ExpandTransition.vue2.js";
+/* empty css                     */
 export {
   _sfc_main as default
 };

package/es/_shared/components/Icon.vue2.js

@@ -1,7 +1,5 @@
 import _sfc_main from "./Icon.vue3.js";
 /* empty css         */
-import _export_sfc from "../../_virtual/_plugin-vue_export-helper.js";
-const YcIcon = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c4c2d409"]]);
 export {
-  YcIcon as default
+  _sfc_main as default
 };

package/es/_shared/components/Icon.vue3.js

@@ -68,7 +68,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           }
         ]
       }, attrs.value), [
-        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        renderSlot(_ctx.$slots, "default")
       ], 16);
     };
   }

package/es/_shared/components/IconButton.vue.js

@@ -0,0 +1,44 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, renderSlot, createVNode, unref } from "vue";
+import "../../node_modules/tinycolor2/esm/tinycolor.js";
+import { valueToPx } from "../utils/dom.js";
+import "../utils/time.js";
+import "../../Empty/index.js";
+/* empty css         */
+import _sfc_main$1 from "../icons/IconClose.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "IconButton",
+  props: {
+    size: { default: 12 },
+    hoverSize: { default: 20 },
+    disabled: { type: Boolean, default: false },
+    hoverable: { type: Boolean, default: true },
+    preventFocus: { type: Boolean, default: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const { hoverSize: _hoverSize } = toRefs(props);
+    const hoverSize = computed(() => valueToPx(_hoverSize.value));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-icon-button",
+          {
+            "yc-icon-button-disabled": _ctx.disabled,
+            "yc-icon-button-hoverable": _ctx.hoverable
+          }
+        ]),
+        style: normalizeStyle({
+          "--icon-btn-size": hoverSize.value
+        }),
+        onMousedown: _cache[0] || (_cache[0] = (e) => _ctx.preventFocus && e.preventDefault())
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, () => [
+          createVNode(unref(_sfc_main$1), { size: _ctx.size }, null, 8, ["size"])
+        ])
+      ], 38);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/_shared/components/IconButton.vue3.js

@@ -1,44 +1,5 @@
-import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, renderSlot, createVNode, unref } from "vue";
-import "../../node_modules/tinycolor2/esm/tinycolor.js";
-import { valueToPx } from "../utils/dom.js";
-import "../utils/time.js";
-import "../../Empty/index.js";
-/* empty css         */
-import _sfc_main$1 from "../icons/IconClose.vue.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "IconButton",
-  props: {
-    size: { default: 12 },
-    hoverSize: { default: 20 },
-    disabled: { type: Boolean, default: false },
-    hoverable: { type: Boolean, default: true },
-    preventFocus: { type: Boolean, default: true }
-  },
-  setup(__props) {
-    const props = __props;
-    const { hoverSize: _hoverSize } = toRefs(props);
-    const hoverSize = computed(() => valueToPx(_hoverSize.value));
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-icon-button",
-          {
-            "yc-icon-button-disabled": _ctx.disabled,
-            "yc-icon-button-hoverable": _ctx.hoverable
-          }
-        ]),
-        style: normalizeStyle({
-          "--icon-btn-size": hoverSize.value
-        }),
-        onMousedown: _cache[0] || (_cache[0] = (e) => _ctx.preventFocus && e.preventDefault())
-      }, [
-        renderSlot(_ctx.$slots, "default", {}, () => [
-          createVNode(unref(_sfc_main$1), { size: _ctx.size }, null, 8, ["size"])
-        ], true)
-      ], 38);
-    };
-  }
-});
+import _sfc_main from "./IconButton.vue.js";
+/* empty css                */
 export {
   _sfc_main as default
 };

package/es/_shared/icons/IconArrowDown.vue.js

@@ -1,10 +1,11 @@
 import { defineComponent, createBlock, openBlock, normalizeProps, guardReactiveProps, withCtx, createElementVNode } from "vue";
-import YcIcon from "../components/Icon.vue2.js";
+import _sfc_main$1 from "../components/Icon.vue3.js";
+/* empty css                     */
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "IconArrowDown",
   setup(__props) {
     return (_ctx, _cache) => {
-      return openBlock(), createBlock(YcIcon, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
+      return openBlock(), createBlock(_sfc_main$1, normalizeProps(guardReactiveProps(_ctx.$attrs)), {
         default: withCtx(() => _cache[0] || (_cache[0] = [
           createElementVNode("path", { d: "M39.6 17.443 24.043 33 8.487 17.443" }, null, -1)
         ])),