hys-ui 0.5.0 → 0.7.0

package/dist/components/HysSortableList/useSortWindow.js

@@ -0,0 +1,144 @@
+import { computed as d, ref as k, shallowRef as p, watch as F, onBeforeUnmount as q, nextTick as I } from "vue";
+import { layoutOf as K, keyToken as N } from "./model.js";
+const G = (n, u, l, s) => Number.isFinite(n) ? Math.min(s, Math.max(l, n)) : u;
+function H(n, u) {
+  let l = 0, s = n.length - 1;
+  for (; l < s; ) {
+    const m = Math.ceil((l + s) / 2);
+    n[m] <= u ? l = m : s = m - 1;
+  }
+  return Math.min(l, Math.max(0, n.length - 2));
+}
+function J(n, u, l, s, m) {
+  const x = d(
+    () => typeof n.virtual == "object" ? n.virtual : {}
+  ), c = d(() => K(n) === "horizontal"), v = k(0), L = k(0), z = k(0), y = k(0), h = /* @__PURE__ */ new Map(), R = p(0), b = d(() => {
+    if (K(n) !== "grid" || !n.virtual) return 1;
+    const e = x.value.columns;
+    return Math.floor(
+      G(
+        typeof e == "function" ? e(L.value) : e,
+        2,
+        1,
+        100
+      )
+    );
+  }), w = d(() => {
+    if (!n.virtual) return [0];
+    R.value;
+    const e = [0], t = G(
+      x.value.estimateSize,
+      c.value ? 160 : 48,
+      1,
+      2e3
+    ), a = b.value;
+    for (let o = 0; o < u.value.length; o += a) {
+      let i = 0;
+      for (let r = o; r < Math.min(o + a, u.value.length); r++)
+        i = Math.max(
+          i,
+          h.get(N(m(u.value[r]))) ?? t
+        );
+      e.push(e[e.length - 1] + i + y.value);
+    }
+    return e;
+  }), W = d(() => {
+    if (!n.virtual)
+      return { start: 0, end: u.value.length, before: 0, after: 0 };
+    const e = w.value, t = e.length - 1, a = Math.floor(G(x.value.overscan, 4, 1, 100)), o = Math.max(0, H(e, v.value) - a), i = Math.min(
+      t,
+      H(e, v.value + (z.value || 300)) + a + 1
+    );
+    return {
+      start: o * b.value,
+      end: Math.min(i * b.value, u.value.length),
+      before: Math.max(0, e[o] - y.value),
+      after: Math.max(0, e[t] - e[i] - y.value)
+    };
+  }), P = d(
+    () => u.value.slice(W.value.start, W.value.end)
+  ), O = d(() => {
+    if (!n.virtual) return;
+    const e = x.value.height ?? (c.value ? "auto" : 320);
+    return typeof e == "number" ? `${Math.max(1, e)}px` : e;
+  });
+  let g, f;
+  const M = /* @__PURE__ */ new Set();
+  function S() {
+    const e = l.value;
+    if (!e || !n.virtual) return;
+    v.value = c.value ? Math.abs(e.scrollLeft) : e.scrollTop, z.value = c.value ? e.clientWidth : e.clientHeight, L.value = e.clientWidth;
+    const t = s.value;
+    if (t) {
+      const a = getComputedStyle(t);
+      y.value = parseFloat(c.value ? a.columnGap : a.rowGap) || 0;
+    }
+  }
+  function T(e) {
+    const t = l.value;
+    t && (c.value ? t.scrollLeft = getComputedStyle(t).direction === "rtl" ? -e : e : t.scrollTop = e, S());
+  }
+  function U(e) {
+    const t = w.value, a = H(t, v.value);
+    let o = !1;
+    for (const i of e) {
+      const r = i.target, A = r.dataset.sortKey;
+      if (A === void 0 || !M.has(r)) continue;
+      const C = c.value ? r.offsetWidth : r.offsetHeight;
+      !C || h.get(A) === C || (h.set(A, C), o = !0);
+    }
+    if (o) {
+      R.value++;
+      const i = (w.value[a] ?? 0) - (t[a] ?? 0);
+      if (i && v.value > 0) {
+        const r = v.value;
+        I(() => {
+          v.value === r && T(r + i);
+        });
+      }
+    }
+  }
+  function j() {
+    if (!f || !s.value) return;
+    const e = new Set(
+      Array.from(s.value.children).filter(
+        (t) => t.hasAttribute("data-sort-key")
+      )
+    );
+    for (const t of M)
+      e.has(t) || (f.unobserve(t), M.delete(t));
+    for (const t of e)
+      M.has(t) || (M.add(t), f.observe(t));
+  }
+  function B() {
+    g == null || g.disconnect(), f == null || f.disconnect(), g = f = void 0, M.clear();
+  }
+  F(
+    [l, s, () => !!n.virtual, c],
+    () => {
+      B(), h.clear(), R.value++, !(!l.value || !n.virtual) && (S(), typeof ResizeObserver < "u" && (g = new ResizeObserver(S), g.observe(l.value), f = new ResizeObserver(U), j()));
+    },
+    { flush: "post" }
+  ), F(P, j, { flush: "post" }), F(u, (e) => {
+    if (!h.size) return;
+    const t = new Set(e.map((a) => N(m(a))));
+    for (const a of h.keys()) t.has(a) || h.delete(a);
+  }), q(B);
+  async function $(e) {
+    if (!n.virtual || e < 0) return;
+    const t = Math.floor(e / b.value), a = w.value[t], o = w.value[t + 1] - y.value;
+    a < v.value ? T(a) : o > v.value + z.value && T(Math.max(0, o - z.value)), await I();
+  }
+  return {
+    visibleItems: P,
+    range: W,
+    horizontal: c,
+    length: O,
+    columns: b,
+    reveal: $,
+    syncPosition: S
+  };
+}
+export {
+  J as useSortWindow
+};

package/dist/components/HysSpace/HysSpace.vue.js

@@ -0,0 +1,7 @@
+import o from "./HysSpace2.vue.js";
+/* empty css              */
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const r = /* @__PURE__ */ t(o, [["__scopeId", "data-v-fe7a4d4f"]]);
+export {
+  r as default
+};

package/dist/components/HysSpace/HysSpace2.vue.js

@@ -0,0 +1,79 @@
+import { defineComponent as g, useSlots as v, computed as w, openBlock as a, createElementBlock as o, mergeProps as x, unref as p, Fragment as i, renderList as f, renderSlot as B, createTextVNode as j, toDisplayString as z, createCommentVNode as S, createElementVNode as V, createBlock as C, resolveDynamicComponent as N } from "vue";
+import { useHysRootAttrs as R } from "../../config.js";
+import { spaceGap as y, collectSpaceItems as D } from "./spaceItems.js";
+const E = ["data-direction", "data-wrap", "data-block", "data-fill"], F = {
+  key: 0,
+  class: "hys-space-separator",
+  "aria-hidden": "true"
+}, H = { class: "hys-space-content" }, G = /* @__PURE__ */ g({
+  __name: "HysSpace",
+  props: {
+    direction: { default: "horizontal" },
+    size: { default: "sm" },
+    align: {},
+    justify: { default: "start" },
+    wrap: { type: Boolean },
+    block: { type: Boolean },
+    fill: { type: Boolean },
+    fillRatio: {},
+    separator: {}
+  },
+  setup(e) {
+    const t = e, s = v(), m = R(), h = {
+      start: "flex-start",
+      center: "center",
+      end: "flex-end",
+      between: "space-between",
+      around: "space-around",
+      evenly: "space-evenly"
+    }, k = {
+      start: "flex-start",
+      center: "center",
+      end: "flex-end",
+      baseline: "baseline",
+      stretch: "stretch"
+    }, b = w(() => {
+      const n = t.size, [c, r] = typeof n == "object" ? n : [n, n], l = t.align ?? (t.direction === "horizontal" ? "center" : t.fill ? "stretch" : "start");
+      return {
+        "--hys-space-inline-gap": y(c),
+        "--hys-space-block-gap": y(r),
+        "--hys-space-basis": Number.isFinite(t.fillRatio) ? Math.max(0, Math.min(100, t.fillRatio)) + "%" : t.wrap ? "auto" : "0%",
+        alignItems: k[l],
+        justifyContent: h[t.justify]
+      };
+    });
+    return (n, c) => {
+      var r;
+      return a(), o("div", x(p(m), {
+        class: "hys-ui-space",
+        style: b.value,
+        "data-direction": e.direction,
+        "data-wrap": e.wrap && e.direction === "horizontal" || void 0,
+        "data-block": e.block || e.fill || void 0,
+        "data-fill": e.fill || void 0
+      }), [
+        (a(!0), o(i, null, f([p(D)(((r = s.default) == null ? void 0 : r.call(s)) ?? [])], (l) => (a(), o(i, { key: 0 }, [
+          (a(!0), o(i, null, f(l, (d, u) => (a(), o("div", {
+            key: d.key,
+            class: "hys-space-item"
+          }, [
+            u && (s.separator || e.separator) ? (a(), o("div", F, [
+              B(n.$slots, "separator", {
+                index: u,
+                count: l.length
+              }, () => [
+                j(z(e.separator), 1)
+              ], !0)
+            ])) : S("", !0),
+            V("div", H, [
+              (a(), C(N(d.node)))
+            ])
+          ]))), 128))
+        ], 64))), 128))
+      ], 16, E);
+    };
+  }
+});
+export {
+  G as default
+};

package/dist/components/HysSpace/spaceItems.js

@@ -0,0 +1,17 @@
+import { isVNode as n, Comment as y, Text as m, Fragment as f } from "vue";
+function h(t, c = "", i = []) {
+  return t.forEach((r, s) => {
+    if (!n(r) || r.type === y || r.type === m && !String(r.children ?? "").trim())
+      return;
+    const p = c + "/" + (r.key === null ? "#" + s : JSON.stringify([typeof r.key, String(r.key)]));
+    r.type === f && Array.isArray(r.children) ? h(r.children, p, i) : i.push({ key: p, node: r });
+  }), i;
+}
+const e = { sm: "8px", md: "12px", lg: "20px" };
+function a(t) {
+  return typeof t == "number" ? Number.isFinite(t) ? Math.max(0, t) + "px" : e.sm : Object.hasOwn(e, t) ? e[t] : t;
+}
+export {
+  h as collectSpaceItems,
+  a as spaceGap
+};

package/dist/components/HysSpin/HysSpin.vue.js

@@ -0,0 +1,7 @@
+import o from "./HysSpin2.vue.js";
+/* empty css         */
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const m = /* @__PURE__ */ t(o, [["__scopeId", "data-v-e5d8e2d7"]]);
+export {
+  m as default
+};

package/dist/components/HysSpin/HysSpin2.vue.js

@@ -0,0 +1,427 @@
+import { defineComponent as _e, useSlots as Te, useAttrs as Be, computed as l, ref as y, watch as V, onMounted as de, onDeactivated as $e, onActivated as we, openBlock as n, createElementBlock as o, mergeProps as ce, unref as g, normalizeClass as pe, renderSlot as h, createCommentVNode as v, createBlock as ze, Teleport as Ve, createVNode as me, Transition as Ce, withCtx as Le, normalizeProps as T, guardReactiveProps as B, createElementVNode as K, normalizeStyle as x, toDisplayString as c, createTextVNode as Pe, Fragment as He, renderList as Ie } from "vue";
+import { useHysRootAttrs as Me } from "../../config.js";
+import { usePageVisibility as De } from "../../composables/usePageVisibility.js";
+import xe from "./SpinGlyph/SpinGlyph.vue.js";
+/* empty css                        */
+import { useSpinConfig as Ee } from "./spinConfig.js";
+import { spinStyle as Ne, bounded as E } from "./spinStyle.js";
+import { useHysSpinTask as Re, clampSpinProgress as Ae } from "./useHysSpinTask.js";
+import { useSpinVisibility as Oe } from "./useSpinVisibility.js";
+import { useSpinFullscreen as We } from "./useSpinFullscreen.js";
+const je = ["data-mode"], qe = ["inert", "aria-busy"], Fe = ["data-mode", "data-placement", "data-block", "data-mask", "data-motion-off", "data-status", "role", "aria-modal", "aria-label", "tabindex"], Ge = ["data-layout", "data-align"], Ke = ["aria-busy"], Je = {
+  key: 0,
+  class: "hys-spin-title"
+}, Qe = {
+  key: 1,
+  class: "hys-spin-message"
+}, Ue = {
+  key: 2,
+  class: "hys-spin-description"
+}, Xe = {
+  key: 3,
+  class: "hys-spin-description"
+}, Ye = {
+  key: 4,
+  class: "hys-spin-description"
+}, Ze = {
+  key: 0,
+  class: "hys-spin-line",
+  "aria-hidden": "true"
+}, ea = {
+  key: 1,
+  class: "hys-spin-segments",
+  "aria-hidden": "true"
+}, aa = {
+  key: 2,
+  class: "hys-spin-percent"
+}, ta = {
+  key: 1,
+  class: "hys-spin-actions"
+}, la = ["aria-label", "aria-valuenow"], sa = ["role"], ya = /* @__PURE__ */ _e({
+  inheritAttrs: !1,
+  __name: "HysSpin",
+  props: {
+    spinning: { type: Boolean, default: void 0 },
+    modelValue: { type: Boolean, default: void 0 },
+    defaultSpinning: { type: Boolean, default: void 0 },
+    mode: {},
+    size: {},
+    width: {},
+    height: {},
+    regionHeight: {},
+    delay: {},
+    minDuration: {},
+    timeout: {},
+    autoEnd: {},
+    task: {},
+    status: {},
+    showResult: { type: Boolean, default: void 0 },
+    progress: {},
+    progressType: {},
+    segments: {},
+    showPercentage: { type: Boolean, default: void 0 },
+    formatProgress: {},
+    title: {},
+    message: {},
+    description: {},
+    stage: {},
+    remainingTime: {},
+    layout: {},
+    placement: {},
+    align: {},
+    gap: {},
+    ariaLabel: {},
+    mask: { type: Boolean, default: void 0 },
+    maskColor: {},
+    maskOpacity: {},
+    blur: {},
+    zIndex: {},
+    appendTo: {},
+    blockInteraction: { type: Boolean, default: void 0 },
+    lockScroll: { type: Boolean, default: void 0 },
+    cancellable: { type: Boolean, default: void 0 },
+    retryable: { type: Boolean, default: void 0 },
+    escapeCancel: { type: Boolean, default: void 0 },
+    cancelLabel: {},
+    retryLabel: {},
+    preset: {},
+    animationDelay: {},
+    animated: { type: Boolean, default: void 0 },
+    paused: { type: Boolean, default: void 0 },
+    pauseWhenHidden: { type: Boolean, default: void 0 },
+    transitionDuration: {},
+    color: {},
+    trackColor: {},
+    strokeWidth: {},
+    dotSize: {},
+    dotGap: {},
+    colors: {},
+    gradient: {},
+    indicatorStyle: {},
+    messageStyle: {},
+    overlayStyle: {},
+    animation: {},
+    animationName: {},
+    speed: {},
+    animationDuration: {},
+    easing: {},
+    direction: {},
+    iterations: {},
+    angle: {},
+    path: {}
+  },
+  emits: ["update:modelValue", "update:spinning", "change", "start", "end", "show", "hide", "afterHide", "cancel", "timeout", "retry", "error", "success"],
+  setup(ye, { expose: ge, emit: fe }) {
+    const J = ye, u = fe, he = Te(), Q = Ee(), U = Me(), X = Be(), e = l(() => {
+      const a = Q.defaults.value, r = J.preset ?? a.preset;
+      return {
+        ...a,
+        ...r ? Q.presets.value[r] : {},
+        ...Object.fromEntries(
+          Object.entries(J).filter(([, z]) => z !== void 0)
+        )
+      };
+    }), t = Re(), Y = y(), $ = y(!0), Z = y(!1), ee = y(), i = y({}), C = y(!1), L = y(!1), ae = y(0), ke = De(), k = l(
+      () => e.value.mode ?? (he.default ? "container" : "inline")
+    ), N = l(
+      () => ["container", "overlay", "fullscreen"].includes(k.value)
+    ), p = l(() => k.value === "fullscreen"), be = l(() => e.value.appendTo ?? "body"), P = l(
+      () => $.value && (e.value.spinning ?? e.value.modelValue ?? Y.value ?? (e.value.task ? !1 : e.value.defaultSpinning ?? !0))
+    ), d = l(
+      () => e.value.status ?? i.value.status ?? (t.state.value.status === "idle" ? P.value ? "loading" : "idle" : t.state.value.status)
+    ), m = l(
+      () => Ae(
+        e.value.progress ?? ("progress" in i.value ? i.value.progress ?? void 0 : t.state.value.progress)
+      )
+    ), w = l(
+      () => !["idle", "loading", "retrying"].includes(d.value)
+    ), s = l(() => ({
+      spinning: P.value,
+      status: d.value,
+      progress: m.value,
+      message: e.value.message ?? i.value.message ?? t.state.value.message,
+      stage: e.value.stage ?? i.value.stage ?? (t.state.value.spinning ? t.state.value.stage : void 0),
+      remainingTime: e.value.remainingTime ?? i.value.remainingTime ?? (t.state.value.spinning ? t.state.value.remainingTime : void 0),
+      error: t.state.value.error
+    }));
+    function R(a) {
+      Y.value = a, u("update:modelValue", a), u("update:spinning", a);
+    }
+    function te() {
+      i.value = {}, t.state.value.spinning || t.reset(), R(!0);
+    }
+    function H() {
+      R(!1);
+    }
+    function A(a) {
+      i.value = { ...i.value, ...a };
+    }
+    function I() {
+      t.state.value.spinning ? t.cancel() : (A({ status: "cancelled" }), H(), u("cancel", s.value));
+    }
+    function O() {
+      const a = t.retry();
+      return a && (i.value = {}), u("retry", s.value), a;
+    }
+    function W(a, r) {
+      return i.value = {}, t.run(a, { timeout: e.value.timeout, ...r });
+    }
+    V(() => t.state.value.spinning, R, { flush: "sync" }), V(
+      () => t.state.value.status,
+      (a) => {
+        a === "error" && u("error", t.state.value.error, s.value), a === "success" && u("success", s.value), a === "cancelled" && u("cancel", s.value), a === "timeout" && u("timeout", s.value);
+      }
+    ), V(
+      () => e.value.task,
+      (a) => {
+        !Z.value || !$.value || (a ? W(a).catch(() => {
+        }) : t.state.value.spinning && t.cancel());
+      }
+    ), de(() => {
+      Z.value = !0, e.value.task && W(e.value.task).catch(() => {
+      });
+    }), $e(() => {
+      $.value = !1, t.reset();
+    }), we(() => {
+      $.value = !0;
+    });
+    const j = Oe({
+      requested: () => P.value,
+      delay: () => e.value.delay,
+      minimum: () => e.value.minDuration,
+      timeout: () => t.state.value.spinning ? void 0 : e.value.timeout,
+      autoEnd: () => e.value.autoEnd,
+      start: () => u("start", s.value),
+      end: () => u("end", s.value),
+      stop(a) {
+        a === "timeout" ? (A({ status: "timeout" }), u("timeout", s.value)) : t.state.value.spinning && t.cancel(), H();
+      }
+    }), M = l(
+      () => $.value && (j.value || e.value.showResult && w.value)
+    ), f = l(() => j.value && !w.value), b = l(
+      () => f.value && N.value && e.value.blockInteraction !== !1
+    ), Se = We(ee, {
+      trap: () => p.value && b.value,
+      lock: () => p.value && f.value && e.value.lockScroll !== !1,
+      zIndex: () => e.value.zIndex ?? 2200,
+      escape: () => {
+        e.value.escapeCancel && e.value.cancellable && I();
+      }
+    }), S = l(() => m.value !== void 0), D = l(() => e.value.progressType ?? "ring"), le = l(
+      () => {
+        var a, r;
+        return S.value ? ((r = (a = e.value).formatProgress) == null ? void 0 : r.call(a, m.value)) ?? Math.round(m.value) + "%" : "";
+      }
+    ), _ = l(() => ({
+      ...s.value,
+      visible: M.value === !0,
+      percentText: le.value,
+      cancel: I,
+      retry: O
+    })), se = l(
+      () => Ne(
+        e.value,
+        C.value || !!e.value.paused || e.value.pauseWhenHidden !== !1 && ke.value
+      )
+    ), ne = {
+      retrying: "正在重试",
+      success: "加载完成",
+      error: "加载失败",
+      cancelled: "已取消加载",
+      timeout: "加载超时"
+    }, oe = l(
+      () => Object.hasOwn(ne, d.value) ? ne[d.value] : void 0
+    ), q = l(
+      () => w.value ? e.value.message ?? i.value.message ?? oe.value ?? s.value.message : s.value.message ?? oe.value
+    ), F = l(
+      () => e.value.ariaLabel || q.value || e.value.title || "正在加载"
+    ), ue = l(
+      () => Math.round(E(e.value.segments, 8, 2, 30))
+    );
+    V(s, (a) => u("change", a));
+    let ie = !1;
+    function re() {
+      const a = M.value === !0;
+      ie !== a && (ie = a, u(a ? "show" : "hide", s.value));
+    }
+    return V(M, re), de(re), ge({
+      show: te,
+      hide: H,
+      toggle: () => P.value ? H() : te(),
+      run: W,
+      cancel: I,
+      retry: O,
+      update: A,
+      pause: () => {
+        C.value = !0;
+      },
+      resume: () => {
+        C.value = L.value = !1;
+      },
+      stop: () => {
+        L.value = !0;
+      },
+      restart: () => {
+        L.value = C.value = !1, ae.value++;
+      },
+      clearResult: () => {
+        t.state.value.spinning || (t.reset(), i.value = {});
+      },
+      visible: j,
+      snapshot: s
+    }), (a, r) => (n(), o("div", ce({ ...g(U), ...g(X) }, {
+      class: "hys-ui-spin",
+      "data-mode": k.value,
+      style: [se.value, g(X).style]
+    }), [
+      a.$slots.default ? (n(), o("div", {
+        key: 0,
+        class: pe(["hys-spin-content", {
+          "hys-spin-scroll-locked": N.value && !p.value && f.value && e.value.lockScroll
+        }]),
+        inert: b.value || void 0,
+        "aria-busy": f.value || void 0
+      }, [
+        h(a.$slots, "default", {}, void 0, !0)
+      ], 10, qe)) : v("", !0),
+      (n(), ze(Ve, {
+        to: be.value,
+        disabled: !p.value
+      }, [
+        me(Ce, {
+          name: "hys-spin-fade",
+          appear: "",
+          onAfterLeave: r[1] || (r[1] = (z) => u("afterHide", s.value))
+        }, {
+          default: Le(() => {
+            var z;
+            return [
+              M.value ? (n(), o("div", ce({
+                key: 0,
+                ref_key: "panel",
+                ref: ee
+              }, g(U), {
+                class: "hys-spin-layer",
+                style: [
+                  se.value,
+                  { zIndex: ((z = g(Se)) == null ? void 0 : z.zIndex.value) ?? e.value.zIndex },
+                  e.value.overlayStyle
+                ],
+                "data-mode": k.value,
+                "data-placement": e.value.placement ?? "center",
+                "data-block": b.value || void 0,
+                "data-mask": N.value && e.value.mask !== !1 || void 0,
+                "data-motion-off": L.value || e.value.animated === !1 || void 0,
+                "data-status": d.value,
+                role: p.value && b.value ? "dialog" : void 0,
+                "aria-modal": p.value && b.value || void 0,
+                "aria-label": p.value ? F.value : void 0,
+                tabindex: p.value && b.value ? -1 : void 0
+              }), [
+                h(a.$slots, "overlay", T(B(_.value)), () => [
+                  K("div", {
+                    class: "hys-spin-indicator",
+                    "data-layout": e.value.layout ?? (k.value === "inline" || k.value === "indicator" ? "left" : "top"),
+                    "data-align": e.value.align ?? "center",
+                    style: x(e.value.indicatorStyle)
+                  }, [
+                    D.value === "ring" || !S.value || w.value || a.$slots.indicator || a.$slots.icon ? (n(), o("div", {
+                      key: ae.value,
+                      class: pe(["hys-spin-icon", { "hys-spin-custom": e.value.animationName }]),
+                      "aria-busy": !a.$slots.default && f.value || void 0
+                    }, [
+                      h(a.$slots, "indicator", T(B(_.value)), () => [
+                        h(a.$slots, "icon", T(B(_.value)), () => [
+                          me(xe, {
+                            animation: e.value.animation ?? "circle",
+                            status: d.value,
+                            progress: D.value === "ring" ? m.value : void 0,
+                            stroke: g(E)(e.value.strokeWidth, 4, 0.5, 8),
+                            dot: g(E)(e.value.dotSize, 4, 1, 8),
+                            spacing: g(E)(e.value.dotGap, 11, 6, 17),
+                            colors: e.value.colors,
+                            gradient: e.value.gradient,
+                            path: e.value.path
+                          }, null, 8, ["animation", "status", "progress", "stroke", "dot", "spacing", "colors", "gradient", "path"])
+                        ], !0)
+                      ], !0)
+                    ], 10, Ke)) : v("", !0),
+                    K("div", {
+                      class: "hys-spin-details",
+                      style: x(e.value.messageStyle)
+                    }, [
+                      e.value.title ? (n(), o("span", Je, c(e.value.title), 1)) : v("", !0),
+                      q.value || a.$slots.message ? (n(), o("div", Qe, [
+                        h(a.$slots, "message", T(B(_.value)), () => [
+                          Pe(c(q.value), 1)
+                        ], !0)
+                      ])) : v("", !0),
+                      e.value.description ? (n(), o("span", Ue, c(e.value.description), 1)) : v("", !0),
+                      s.value.stage ? (n(), o("span", Xe, c(s.value.stage), 1)) : v("", !0),
+                      s.value.remainingTime !== void 0 ? (n(), o("span", Ye, "约剩 " + c(Math.max(0, Math.ceil(s.value.remainingTime / 1e3))) + " 秒", 1)) : v("", !0),
+                      h(a.$slots, "progress", T(B(_.value)), () => [
+                        S.value && D.value === "line" ? (n(), o("span", Ze, [
+                          K("i", {
+                            style: x({ inlineSize: (m.value ?? 0) + "%" })
+                          }, null, 4)
+                        ])) : S.value && D.value === "segments" ? (n(), o("span", ea, [
+                          (n(!0), o(He, null, Ie(ue.value, (G) => (n(), o("i", {
+                            key: G,
+                            style: x({
+                              "--hys-spin-segment-fill": Math.min(
+                                1,
+                                Math.max(
+                                  0,
+                                  m.value / 100 * ue.value - G + 1
+                                )
+                              ) * 100 + "%"
+                            })
+                          }, null, 4))), 128))
+                        ])) : v("", !0),
+                        S.value && e.value.showPercentage !== !1 ? (n(), o("span", aa, c(le.value), 1)) : v("", !0)
+                      ], !0)
+                    ], 4),
+                    a.$slots.actions || e.value.cancellable && f.value || e.value.retryable && ["error", "timeout", "cancelled"].includes(d.value) ? (n(), o("div", ta, [
+                      h(a.$slots, "actions", T(B(_.value)), () => [
+                        e.value.cancellable && f.value ? (n(), o("button", {
+                          key: 0,
+                          type: "button",
+                          onClick: I
+                        }, c(e.value.cancelLabel ?? "取消加载"), 1)) : e.value.retryable ? (n(), o("button", {
+                          key: 1,
+                          type: "button",
+                          onClick: r[0] || (r[0] = (G) => {
+                            var ve;
+                            return (ve = O()) == null ? void 0 : ve.catch(() => {
+                            });
+                          })
+                        }, c(e.value.retryLabel ?? "重试"), 1)) : v("", !0)
+                      ], !0)
+                    ])) : v("", !0)
+                  ], 12, Ge)
+                ], !0),
+                S.value && !w.value ? (n(), o("div", {
+                  key: 0,
+                  class: "hys-spin-sr",
+                  role: "progressbar",
+                  "aria-label": F.value,
+                  "aria-valuenow": m.value,
+                  "aria-valuemin": "0",
+                  "aria-valuemax": "100"
+                }, null, 8, la)) : (n(), o("span", {
+                  key: 1,
+                  class: "hys-spin-sr",
+                  role: d.value === "error" || d.value === "timeout" ? "alert" : "status"
+                }, c(F.value), 9, sa))
+              ], 16, Fe)) : v("", !0)
+            ];
+          }),
+          _: 3
+        })
+      ], 8, ["to", "disabled"]))
+    ], 16, je));
+  }
+});
+export {
+  ya as default
+};