@king-one/antdv 1.2.21 → 2.0.0

package/dist/es/components/pro-user-avatar/index.mjs

@@ -1,11 +1,10 @@
-import { withInstall as r } from "../utils/install.mjs";
+import { withInstall } from "@king-one/utils";
 import "./src/index.vue.mjs";
 import "./src/style/index.mjs";
 import "./src/types.mjs";
-import t from "./src/index.vue2.mjs";
-const p = r(t), e = r(t);
+import _sfc_main from "./src/index.vue2.mjs";
+const KUserAvatar = withInstall(_sfc_main);
 export {
-  e as KProUserAvatar,
-  p as KUserAvatar,
-  p as default
+  KUserAvatar,
+  KUserAvatar as default
 };

package/dist/es/components/pro-user-avatar/src/index.vue.mjs

@@ -1,4 +1,4 @@
-import f from "./index.vue2.mjs";
+import _sfc_main from "./index.vue2.mjs";
 export {
-  f as default
+  _sfc_main as default
 };

package/dist/es/components/pro-user-avatar/src/index.vue2.mjs

@@ -1,126 +1,69 @@
-import { defineComponent as E, ref as l, computed as I, onMounted as B, onBeforeUnmount as N, createElementBlock as s, openBlock as t, normalizeClass as c, unref as o, createBlock as R, createCommentVNode as V, normalizeStyle as p, toDisplayString as _, createElementVNode as M } from "vue";
-import { useNamespace as A } from "../../../hooks/use-namespace/index.mjs";
-import { Image as O } from "ant-design-vue";
-import { getColorFromString as P } from "./util.mjs";
-import U from "./load-error.png.mjs";
-const D = ["data-src", "alt"], F = {
-  key: 1,
-  style: { width: "100%", height: "100%" }
-}, H = { key: 1 }, T = ["src"], K = /* @__PURE__ */ E({
-  name: "ProUserAvatar",
+import { defineComponent, ref, computed, createElementBlock, openBlock, normalizeClass, unref, normalizeStyle, toDisplayString } from "vue";
+import { useNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { getColorFromString } from "./util.mjs";
+const _hoisted_1 = ["src", "alt"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "ProUserAvatar"
+  },
   __name: "index",
   props: {
-    name: { default: "" },
+    name: { default: "未知" },
     avatar: {},
-    size: { default: "default" },
-    round: { default: "50%" },
-    fontSize: {},
-    preview: { type: Boolean, default: !0 }
+    size: { default: "default" }
   },
   emits: ["error"],
-  setup(h, { expose: y, emit: b }) {
-    const n = h, L = b, u = A("user-avatar"), v = l(!1), d = l(!1), a = l(null), k = l(!1), r = l(null), m = I(() => n.name.length >= 2 ? n.name.slice(n.name.length - 2) : n.name ? n.name : "unknown");
-    function w(e) {
-      d.value = e;
-    }
-    function f() {
-      n.preview && !v.value && n.avatar && (d.value = !0);
-    }
-    function z(e) {
-      v.value = !0, L("error", e);
-    }
-    function S() {
-      if (a.value) {
-        const e = "loading" in HTMLImageElement.prototype, i = a.value.complete || a.value.currentSrc !== "";
-        return k.value = e, console.log("浏览器支持原生懒加载:", e), console.log("图片已开始加载:", i), { hasNativeLazyLoading: e, hasStartedLoading: i };
-      }
-      return { hasNativeLazyLoading: !1, hasStartedLoading: !1 };
-    }
-    function C() {
-      if (!("IntersectionObserver" in window)) {
-        g();
-        return;
-      }
-      r.value = new IntersectionObserver((e) => {
-        e.forEach((i) => {
-          i.isIntersecting && (g(), r.value && a.value && r.value.unobserve(a.value));
-        });
-      }, {
-        // 设置根元素为null表示相对于视口
-        root: null,
-        // 设置根边距，可以提前加载
-        rootMargin: "0px",
-        // 设置阈值，当元素有50%进入视口时触发回调
-        threshold: 0.5
-      }), a.value && r.value.observe(a.value);
-    }
-    function g() {
-      if (a.value && n.avatar) {
-        const e = a.value.getAttribute("data-src");
-        e && (a.value.src = e);
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const ns = useNamespace("user-avatar");
+    const imgLoadError = ref(false);
+    const nameChars = computed(() => {
+      if (props.name.length >= 2) {
+        return props.name.slice(props.name.length - 2);
+      } else {
+        return props.name ? props.name : "未知";
       }
+    });
+    function handleError(event) {
+      imgLoadError.value = true;
+      emit("error", event);
     }
-    return B(() => {
-      C();
-    }), N(() => {
-      r.value && (r.value.disconnect(), r.value = null);
-    }), y({
-      handlePreview: f,
-      checkLazyLoading: S
-    }), (e, i) => (t(), s(
-      "div",
-      {
-        class: c([o(u).b(), o(u).b(e.size)]),
-        onClick: f
-      },
-      [
-        e.avatar && !v.value ? (t(), s("img", {
-          key: 0,
-          ref_key: "imgRef",
-          ref: a,
-          class: c([o(u).e("img")]),
-          style: p({ borderRadius: e.round }),
-          "data-src": e.avatar,
-          alt: e.name,
-          onError: z
-        }, null, 46, D)) : (t(), s("div", F, [
-          m.value !== "unknown" ? (t(), s(
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass([unref(ns).b(), unref(ns).b(_ctx.size)])
+        },
+        [
+          _ctx.avatar && !imgLoadError.value ? (openBlock(), createElementBlock("img", {
+            key: 0,
+            class: normalizeClass([unref(ns).e("img")]),
+            src: _ctx.avatar,
+            alt: _ctx.name,
+            loading: "lazy",
+            decoding: "async",
+            onError: handleError
+          }, null, 42, _hoisted_1)) : (openBlock(), createElementBlock(
             "div",
             {
-              key: 0,
-              class: c([o(u).e("name")]),
-              style: p({
-                backgroundColor: o(P)(e.name),
-                borderRadius: e.round,
-                fontSize: `${e.fontSize} !important`
+              key: 1,
+              class: normalizeClass([unref(ns).e("name")]),
+              style: normalizeStyle({
+                backgroundColor: unref(getColorFromString)(_ctx.name)
               })
             },
-            _(m.value),
+            toDisplayString(nameChars.value),
             7
             /* TEXT, CLASS, STYLE */
-          )) : (t(), s("div", H, [
-            M("img", {
-              src: o(U),
-              style: { width: "100%", height: "100%", "max-width": "200px", "max-height": "200px" },
-              alt: ""
-            }, null, 8, T)
-          ]))
-        ])),
-        e.avatar && !v.value && e.preview ? (t(), R(o(O), {
-          key: 2,
-          style: { display: "none" },
-          preview: {
-            visible: d.value,
-            onVisibleChange: w
-          },
-          src: e.avatar
-        }, null, 8, ["preview", "src"])) : V("v-if", !0)
-      ],
-      2
-      /* CLASS */
-    ));
+          ))
+        ],
+        2
+        /* CLASS */
+      );
+    };
   }
 });
 export {
-  K as default
+  _sfc_main as default
 };

package/dist/es/components/pro-user-avatar/src/util.mjs

@@ -1,10 +1,11 @@
-function n(f) {
-  if (!f)
+function getColorFromString(str) {
+  if (!str)
     return "#e1e1e1";
-  let e = 0;
-  for (let a = 0; a < f.length; a++)
-    e = f.charCodeAt(a) + ((e << 5) - e);
-  const t = [
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const colors = [
     "#3286fa",
     "#f56a00",
     "#7265e6",
@@ -18,9 +19,10 @@ function n(f) {
     "#fa8c16",
     "#13c2c2",
     "#fadb14"
-  ], o = Math.abs(e) % t.length;
-  return t[o];
+  ];
+  const index = Math.abs(hash) % colors.length;
+  return colors[index];
 }
 export {
-  n as getColorFromString
+  getColorFromString
 };

package/dist/es/components/scale-virtual-list/component/scale-virtual-list.vue.mjs

@@ -1,4 +1,4 @@
-import f from "./scale-virtual-list.vue2.mjs";
+import _sfc_main from "./scale-virtual-list.vue2.mjs";
 export {
-  f as default
+  _sfc_main as default
 };

package/dist/es/components/scale-virtual-list/component/scale-virtual-list.vue2.mjs

@@ -1,79 +1,93 @@
-import { defineComponent as h, ref as B, computed as E, toRefs as P, createElementBlock as a, openBlock as l, mergeProps as i, unref as e, createElementVNode as p, normalizeStyle as R, normalizeClass as c, Fragment as S, renderList as z, renderSlot as L } from "vue";
-import { defaultNamespace as s } from "../../../hooks/use-namespace/index.mjs";
-import { useElementBounding as T } from "@vueuse/core";
-import { useVirtualList as V } from "../hooks/useVirtualList.mjs";
-const q = /* @__PURE__ */ h({
+import { defineComponent, ref, computed, toRefs, createElementBlock, openBlock, mergeProps, unref, createElementVNode, normalizeStyle, normalizeClass, Fragment, renderList, renderSlot } from "vue";
+import { defaultNamespace } from "../../../hooks/use-namespace/index.mjs";
+import { useElementBounding } from "@vueuse/core";
+import { useVirtualList } from "../hooks/useVirtualList.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "scale-virtual-list",
   props: {
     list: {},
     option: {},
-    itemClassName: { default: `${s}-scale-virtual-item` }
+    itemClassName: { default: `${defaultNamespace}-scale-virtual-item` }
   },
   emits: ["update:state"],
-  setup(m, { expose: u, emit: d }) {
-    const o = m, f = d, n = B(null), { width: v } = T(n), w = E(() => ({
-      width: `${v.value}px`
-    })), { list: $ } = P(o), { list: x, containerProps: y, wrapperProps: _, scrollTo: k, scaleTo: C, state: N, onUpdate: g } = V($, o.option);
-    return u({
-      scrollTo: k,
-      scaleTo: C,
-      state: N
-    }), g((t) => f("update:state", t)), (t, F) => (l(), a(
-      "div",
-      i({
-        class: `${e(s)}-scale-virtual-list`
-      }, e(y)),
-      [
-        p(
-          "div",
-          {
-            class: c(`${e(s)}-scale-virtual-list-container`),
-            style: R(w.value)
-          },
-          [
-            p(
-              "div",
-              i(e(_), {
-                ref_key: "wrapperRef",
-                ref: n,
-                class: `${e(s)}-scale-vittual-wrapper`
-              }),
-              [
-                (l(!0), a(
-                  S,
-                  null,
-                  z(e(x), (r) => (l(), a(
-                    "div",
-                    {
-                      key: r.index,
-                      class: c(t.itemClassName)
-                    },
-                    [
-                      L(t.$slots, "default", {
-                        item: r,
-                        index: r.index
-                      })
-                    ],
-                    2
-                    /* CLASS */
-                  ))),
-                  128
-                  /* KEYED_FRAGMENT */
-                ))
-              ],
-              16
-              /* FULL_PROPS */
-            )
-          ],
-          6
-          /* CLASS, STYLE */
-        )
-      ],
-      16
-      /* FULL_PROPS */
-    ));
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const wrapperRef = ref(null);
+    const { width } = useElementBounding(wrapperRef);
+    const containerSty = computed(() => {
+      return {
+        width: `${width.value}px`
+      };
+    });
+    const { list: Items } = toRefs(props);
+    const { list, containerProps, wrapperProps, scrollTo, scaleTo, state, onUpdate } = useVirtualList(Items, props.option);
+    __expose({
+      scrollTo,
+      scaleTo,
+      state
+    });
+    onUpdate((value) => emit("update:state", value));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        mergeProps({
+          class: `${unref(defaultNamespace)}-scale-virtual-list`
+        }, unref(containerProps)),
+        [
+          createElementVNode(
+            "div",
+            {
+              class: normalizeClass(`${unref(defaultNamespace)}-scale-virtual-list-container`),
+              style: normalizeStyle(containerSty.value)
+            },
+            [
+              createElementVNode(
+                "div",
+                mergeProps(unref(wrapperProps), {
+                  ref_key: "wrapperRef",
+                  ref: wrapperRef,
+                  class: `${unref(defaultNamespace)}-scale-vittual-wrapper`
+                }),
+                [
+                  (openBlock(true), createElementBlock(
+                    Fragment,
+                    null,
+                    renderList(unref(list), (item) => {
+                      return openBlock(), createElementBlock(
+                        "div",
+                        {
+                          key: item.index,
+                          class: normalizeClass(_ctx.itemClassName)
+                        },
+                        [
+                          renderSlot(_ctx.$slots, "default", {
+                            item,
+                            index: item.index
+                          })
+                        ],
+                        2
+                        /* CLASS */
+                      );
+                    }),
+                    128
+                    /* KEYED_FRAGMENT */
+                  ))
+                ],
+                16
+                /* FULL_PROPS */
+              )
+            ],
+            6
+            /* CLASS, STYLE */
+          )
+        ],
+        16
+        /* FULL_PROPS */
+      );
+    };
   }
 });
 export {
-  q as default
+  _sfc_main as default
 };