@soft-stech/bootsman-ui-shadcn 1.5.7 → 2.0.1

package/dist/BuiSlider.vue_vue_type_script_setup_true_lang-CwWWg-YR.js

@@ -0,0 +1,629 @@
+import { defineComponent as B, toRefs as U, ref as M, computed as p, createBlock as x, openBlock as V, normalizeStyle as X, unref as e, withCtx as E, renderSlot as P, resolveDynamicComponent as ue, mergeProps as N, createCommentVNode as se, toRaw as de, onMounted as me, onUnmounted as fe, createVNode as F } from "vue";
+import { u as ve } from "./useEmitAsProps-CNuVpXM5.js";
+import { c as J } from "./clamp-CH0CcKBe.js";
+import { c as Q } from "./createContext-BWsUZRn1.js";
+import { u as pe } from "./useDirection-nP8SCoKq.js";
+import { u as ce } from "./useFormControl-kgOmRVjW.js";
+import { u as I } from "./useForwardExpose-DmyWSR4F.js";
+import { u as W } from "./Collection-BdNht7lW.js";
+import { V as ge } from "./VisuallyHiddenInput-BUnpp8eT.js";
+import { P as Y } from "./Primitive-EBuBc72_.js";
+import { useVModel as ye, useMounted as be } from "@vueuse/core";
+import { u as Se } from "./useSize-BJjHwkIQ.js";
+import { g as he } from "./utils-DIEJYj9K.js";
+function we(o = [], n, t) {
+  const a = [...o];
+  return a[t] = n, a.sort((s, d) => s - d);
+}
+function Z(o, n, t) {
+  const d = 100 / (t - n) * (o - n);
+  return J(d, 0, 100);
+}
+function _e(o, n) {
+  return n > 2 ? `Value ${o + 1} of ${n}` : n === 2 ? ["Minimum", "Maximum"][o] : void 0;
+}
+function Ce(o, n) {
+  if (o.length === 1) return 0;
+  const t = o.map((s) => Math.abs(s - n)), a = Math.min(...t);
+  return t.indexOf(a);
+}
+function De(o, n, t) {
+  const a = o / 2, d = j([0, 50], [0, a]);
+  return (a - d(n) * t) * t;
+}
+function Ee(o) {
+  return o.slice(0, -1).map((n, t) => o[t + 1] - n);
+}
+function xe(o, n) {
+  if (n > 0) {
+    const t = Ee(o);
+    return Math.min(...t) >= n;
+  }
+  return !0;
+}
+function j(o, n) {
+  return (t) => {
+    if (o[0] === o[1] || n[0] === n[1]) return n[0];
+    const a = (n[1] - n[0]) / (o[1] - o[0]);
+    return n[0] + a * (t - o[0]);
+  };
+}
+function Ve(o) {
+  return (String(o).split(".")[1] || "").length;
+}
+function Ke(o, n) {
+  const t = 10 ** n;
+  return Math.round(o * t) / t;
+}
+const ee = ["PageUp", "PageDown"], te = [
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight"
+], ne = {
+  "from-left": [
+    "Home",
+    "PageDown",
+    "ArrowDown",
+    "ArrowLeft"
+  ],
+  "from-right": [
+    "Home",
+    "PageDown",
+    "ArrowDown",
+    "ArrowRight"
+  ],
+  "from-bottom": [
+    "Home",
+    "PageDown",
+    "ArrowDown",
+    "ArrowLeft"
+  ],
+  "from-top": [
+    "Home",
+    "PageUp",
+    "ArrowUp",
+    "ArrowLeft"
+  ]
+}, [ae, oe] = Q(["SliderVertical", "SliderHorizontal"]);
+var qe = /* @__PURE__ */ B({
+  __name: "SliderHorizontal",
+  props: {
+    dir: {
+      type: String,
+      required: !1
+    },
+    min: {
+      type: Number,
+      required: !0
+    },
+    max: {
+      type: Number,
+      required: !0
+    },
+    inverted: {
+      type: Boolean,
+      required: !0
+    }
+  },
+  emits: [
+    "slideEnd",
+    "slideStart",
+    "slideMove",
+    "homeKeyDown",
+    "endKeyDown",
+    "stepKeyDown"
+  ],
+  setup(o, { emit: n }) {
+    const t = o, a = n, { max: s, min: d, dir: i, inverted: l } = U(t), { forwardRef: c, currentElement: g } = I(), h = $(), _ = M(), w = M(), C = p(() => i?.value !== "rtl" && !l.value || i?.value !== "ltr" && l.value);
+    function y(u, r) {
+      const m = w.value || g.value.getBoundingClientRect(), S = [...h.thumbElements.value][h.valueIndexToChangeRef.value], A = h.thumbAlignment.value === "contain" ? S.clientWidth : 0;
+      !_.value && !r && h.thumbAlignment.value === "contain" && (_.value = u.clientX - S.getBoundingClientRect().left);
+      const H = [0, m.width - A], q = C.value ? [d.value, s.value] : [s.value, d.value], k = j(H, q);
+      w.value = m;
+      const f = r ? u.clientX - m.left - A / 2 : u.clientX - m.left - (_.value ?? 0);
+      return k(f);
+    }
+    const K = p(() => C.value ? "left" : "right"), T = p(() => C.value ? "right" : "left"), b = p(() => C.value ? 1 : -1);
+    return oe({
+      startEdge: K,
+      endEdge: T,
+      direction: b,
+      size: "width"
+    }), (u, r) => (V(), x(le, {
+      ref: e(c),
+      dir: e(i),
+      "data-orientation": "horizontal",
+      style: X({ "--reka-slider-thumb-transform": !C.value && e(h).thumbAlignment.value === "overflow" ? "translateX(50%)" : "translateX(-50%)" }),
+      onSlideStart: r[0] || (r[0] = (m) => {
+        const S = y(m, !0);
+        a("slideStart", S);
+      }),
+      onSlideMove: r[1] || (r[1] = (m) => {
+        const S = y(m);
+        a("slideMove", S);
+      }),
+      onSlideEnd: r[2] || (r[2] = () => {
+        w.value = void 0, _.value = void 0, a("slideEnd");
+      }),
+      onStepKeyDown: r[3] || (r[3] = (m) => {
+        const S = C.value ? "from-left" : "from-right", A = e(ne)[S].includes(m.key);
+        a("stepKeyDown", m, A ? -1 : 1);
+      }),
+      onEndKeyDown: r[4] || (r[4] = (m) => a("endKeyDown", m)),
+      onHomeKeyDown: r[5] || (r[5] = (m) => a("homeKeyDown", m))
+    }, {
+      default: E(() => [P(u.$slots, "default")]),
+      _: 3
+    }, 8, ["dir", "style"]));
+  }
+}), Be = qe, Ae = /* @__PURE__ */ B({
+  __name: "SliderVertical",
+  props: {
+    min: {
+      type: Number,
+      required: !0
+    },
+    max: {
+      type: Number,
+      required: !0
+    },
+    inverted: {
+      type: Boolean,
+      required: !0
+    }
+  },
+  emits: [
+    "slideEnd",
+    "slideStart",
+    "slideMove",
+    "homeKeyDown",
+    "endKeyDown",
+    "stepKeyDown"
+  ],
+  setup(o, { emit: n }) {
+    const t = o, a = n, { max: s, min: d, inverted: i } = U(t), l = $(), { forwardRef: c, currentElement: g } = I(), h = M(), _ = M(), w = p(() => !i.value);
+    function C(b, u) {
+      const r = _.value || g.value.getBoundingClientRect(), m = [...l.thumbElements.value][l.valueIndexToChangeRef.value], S = l.thumbAlignment.value === "contain" ? m.clientHeight : 0;
+      !h.value && !u && l.thumbAlignment.value === "contain" && (h.value = b.clientY - m.getBoundingClientRect().top);
+      const A = [0, r.height - S], H = w.value ? [s.value, d.value] : [d.value, s.value], q = j(A, H), k = u ? b.clientY - r.top - S / 2 : b.clientY - r.top - (h.value ?? 0);
+      return _.value = r, q(k);
+    }
+    const y = p(() => w.value ? "bottom" : "top"), K = p(() => w.value ? "top" : "bottom"), T = p(() => w.value ? 1 : -1);
+    return oe({
+      startEdge: y,
+      endEdge: K,
+      direction: T,
+      size: "height"
+    }), (b, u) => (V(), x(le, {
+      ref: e(c),
+      "data-orientation": "vertical",
+      style: X({ "--reka-slider-thumb-transform": !w.value && e(l).thumbAlignment.value === "overflow" ? "translateY(-50%)" : "translateY(50%)" }),
+      onSlideStart: u[0] || (u[0] = (r) => {
+        const m = C(r, !0);
+        a("slideStart", m);
+      }),
+      onSlideMove: u[1] || (u[1] = (r) => {
+        const m = C(r);
+        a("slideMove", m);
+      }),
+      onSlideEnd: u[2] || (u[2] = () => {
+        _.value = void 0, h.value = void 0, a("slideEnd");
+      }),
+      onStepKeyDown: u[3] || (u[3] = (r) => {
+        const m = w.value ? "from-bottom" : "from-top", S = e(ne)[m].includes(r.key);
+        a("stepKeyDown", r, S ? -1 : 1);
+      }),
+      onEndKeyDown: u[4] || (u[4] = (r) => a("endKeyDown", r)),
+      onHomeKeyDown: u[5] || (u[5] = (r) => a("homeKeyDown", r))
+    }, {
+      default: E(() => [P(b.$slots, "default")]),
+      _: 3
+    }, 8, ["style"]));
+  }
+}), Pe = Ae;
+const [$, Re] = Q("SliderRoot");
+var Me = /* @__PURE__ */ B({
+  inheritAttrs: !1,
+  __name: "SliderRoot",
+  props: {
+    defaultValue: {
+      type: Array,
+      required: !1,
+      default: () => [0]
+    },
+    modelValue: {
+      type: [Array, null],
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    orientation: {
+      type: String,
+      required: !1,
+      default: "horizontal"
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    inverted: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    min: {
+      type: Number,
+      required: !1,
+      default: 0
+    },
+    max: {
+      type: Number,
+      required: !1,
+      default: 100
+    },
+    step: {
+      type: Number,
+      required: !1,
+      default: 1
+    },
+    minStepsBetweenThumbs: {
+      type: Number,
+      required: !1,
+      default: 0
+    },
+    thumbAlignment: {
+      type: String,
+      required: !1,
+      default: "contain"
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    },
+    name: {
+      type: String,
+      required: !1
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    }
+  },
+  emits: ["update:modelValue", "valueCommit"],
+  setup(o, { emit: n }) {
+    const t = o, a = n, { min: s, max: d, step: i, minStepsBetweenThumbs: l, orientation: c, disabled: g, thumbAlignment: h, dir: _ } = U(t), w = pe(_), { forwardRef: C, currentElement: y } = I(), K = ce(y), { CollectionSlot: T } = W({ isProvider: !0 }), b = ye(t, "modelValue", a, {
+      defaultValue: t.defaultValue,
+      passive: t.modelValue === void 0
+    }), u = p(() => Array.isArray(b.value) ? [...b.value] : []), r = M(0), m = M(u.value);
+    function S(f) {
+      const v = Ce(u.value, f);
+      q(f, v);
+    }
+    function A(f) {
+      q(f, r.value);
+    }
+    function H() {
+      const f = m.value[r.value];
+      u.value[r.value] !== f && a("valueCommit", de(u.value));
+    }
+    function q(f, v, { commit: D } = { commit: !1 }) {
+      const O = Ve(i.value), G = Ke(Math.round((f - s.value) / i.value) * i.value + s.value, O), L = J(G, s.value, d.value), R = we(u.value, L, v);
+      if (xe(R, l.value * i.value)) {
+        r.value = R.indexOf(L);
+        const z = String(R) !== String(b.value);
+        z && D && a("valueCommit", R), z && (k.value[r.value]?.focus(), b.value = R);
+      }
+    }
+    const k = M([]);
+    return Re({
+      modelValue: b,
+      currentModelValue: u,
+      valueIndexToChangeRef: r,
+      thumbElements: k,
+      orientation: c,
+      min: s,
+      max: d,
+      disabled: g,
+      thumbAlignment: h
+    }), (f, v) => (V(), x(e(T), null, {
+      default: E(() => [(V(), x(ue(e(c) === "horizontal" ? Be : Pe), N(f.$attrs, {
+        ref: e(C),
+        "as-child": f.asChild,
+        as: f.as,
+        min: e(s),
+        max: e(d),
+        dir: e(w),
+        inverted: f.inverted,
+        "aria-disabled": e(g),
+        "data-disabled": e(g) ? "" : void 0,
+        onPointerdown: v[0] || (v[0] = () => {
+          e(g) || (m.value = u.value);
+        }),
+        onSlideStart: v[1] || (v[1] = (D) => !e(g) && S(D)),
+        onSlideMove: v[2] || (v[2] = (D) => !e(g) && A(D)),
+        onSlideEnd: v[3] || (v[3] = (D) => !e(g) && H()),
+        onHomeKeyDown: v[4] || (v[4] = (D) => !e(g) && q(e(s), 0, { commit: !0 })),
+        onEndKeyDown: v[5] || (v[5] = (D) => !e(g) && q(e(d), u.value.length - 1, { commit: !0 })),
+        onStepKeyDown: v[6] || (v[6] = (D, O) => {
+          if (!e(g)) {
+            const R = e(ee).includes(D.key) || D.shiftKey && e(te).includes(D.key) ? 10 : 1, z = r.value, re = u.value[z], ie = e(i) * R * O;
+            q(re + ie, z, { commit: !0 });
+          }
+        })
+      }), {
+        default: E(() => [P(f.$slots, "default", { modelValue: e(b) }), e(K) && f.name ? (V(), x(e(ge), {
+          key: 0,
+          type: "number",
+          value: e(b),
+          name: f.name,
+          required: f.required,
+          disabled: e(g),
+          step: e(i)
+        }, null, 8, [
+          "value",
+          "name",
+          "required",
+          "disabled",
+          "step"
+        ])) : se("v-if", !0)]),
+        _: 3
+      }, 16, [
+        "as-child",
+        "as",
+        "min",
+        "max",
+        "dir",
+        "inverted",
+        "aria-disabled",
+        "data-disabled"
+      ]))]),
+      _: 3
+    }));
+  }
+}), Ie = Me, ke = /* @__PURE__ */ B({
+  __name: "SliderImpl",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  emits: [
+    "slideStart",
+    "slideMove",
+    "slideEnd",
+    "homeKeyDown",
+    "endKeyDown",
+    "stepKeyDown"
+  ],
+  setup(o, { emit: n }) {
+    const t = o, a = n, s = $();
+    return (d, i) => (V(), x(e(Y), N({ "data-slider-impl": "" }, t, {
+      onKeydown: i[0] || (i[0] = (l) => {
+        l.key === "Home" ? (a("homeKeyDown", l), l.preventDefault()) : l.key === "End" ? (a("endKeyDown", l), l.preventDefault()) : e(ee).concat(e(te)).includes(l.key) && (a("stepKeyDown", l), l.preventDefault());
+      }),
+      onPointerdown: i[1] || (i[1] = (l) => {
+        const c = l.target;
+        c.setPointerCapture(l.pointerId), l.preventDefault(), e(s).thumbElements.value.includes(c) ? c.focus() : a("slideStart", l);
+      }),
+      onPointermove: i[2] || (i[2] = (l) => {
+        l.target.hasPointerCapture(l.pointerId) && a("slideMove", l);
+      }),
+      onPointerup: i[3] || (i[3] = (l) => {
+        const c = l.target;
+        c.hasPointerCapture(l.pointerId) && (c.releasePointerCapture(l.pointerId), a("slideEnd", l));
+      })
+    }), {
+      default: E(() => [P(d.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), le = ke, $e = /* @__PURE__ */ B({
+  __name: "SliderRange",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(o) {
+    const n = $(), t = ae();
+    I();
+    const a = p(() => n.currentModelValue.value.map((i) => Z(i, n.min.value, n.max.value))), s = p(() => n.currentModelValue.value.length > 1 ? Math.min(...a.value) : 0), d = p(() => 100 - Math.max(...a.value, 0));
+    return (i, l) => (V(), x(e(Y), {
+      "data-disabled": e(n).disabled.value ? "" : void 0,
+      "data-orientation": e(n).orientation.value,
+      "as-child": i.asChild,
+      as: i.as,
+      style: X({
+        [e(t).startEdge.value]: `${s.value}%`,
+        [e(t).endEdge.value]: `${d.value}%`
+      })
+    }, {
+      default: E(() => [P(i.$slots, "default")]),
+      _: 3
+    }, 8, [
+      "data-disabled",
+      "data-orientation",
+      "as-child",
+      "as",
+      "style"
+    ]));
+  }
+}), Te = $e, He = /* @__PURE__ */ B({
+  inheritAttrs: !1,
+  __name: "SliderThumbImpl",
+  props: {
+    index: {
+      type: Number,
+      required: !0
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(o) {
+    const n = o, t = $(), a = ae(), { forwardRef: s, currentElement: d } = I(), { CollectionItem: i } = W(), l = p(() => t.modelValue?.value?.[n.index]), c = p(() => l.value === void 0 ? 0 : Z(l.value, t.min.value ?? 0, t.max.value ?? 100)), g = p(() => _e(n.index, t.modelValue?.value?.length ?? 0)), h = Se(d), _ = p(() => h[a.size].value), w = p(() => t.thumbAlignment.value === "overflow" || !_.value ? 0 : De(_.value, c.value, a.direction.value)), C = be();
+    return me(() => {
+      t.thumbElements.value.push(d.value);
+    }), fe(() => {
+      const y = t.thumbElements.value.findIndex((K) => K === d.value) ?? -1;
+      t.thumbElements.value.splice(y, 1);
+    }), (y, K) => (V(), x(e(i), null, {
+      default: E(() => [F(e(Y), N(y.$attrs, {
+        ref: e(s),
+        role: "slider",
+        tabindex: e(t).disabled.value ? void 0 : 0,
+        "aria-label": y.$attrs["aria-label"] || g.value,
+        "data-disabled": e(t).disabled.value ? "" : void 0,
+        "data-orientation": e(t).orientation.value,
+        "aria-valuenow": l.value,
+        "aria-valuemin": e(t).min.value,
+        "aria-valuemax": e(t).max.value,
+        "aria-orientation": e(t).orientation.value,
+        "as-child": y.asChild,
+        as: y.as,
+        style: {
+          transform: "var(--reka-slider-thumb-transform)",
+          position: "absolute",
+          [e(a).startEdge.value]: `calc(${c.value}% + ${w.value}px)`,
+          display: !e(C) && l.value === void 0 ? "none" : void 0
+        },
+        onFocus: K[0] || (K[0] = () => {
+          e(t).valueIndexToChangeRef.value = y.index;
+        })
+      }), {
+        default: E(() => [P(y.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "tabindex",
+        "aria-label",
+        "data-disabled",
+        "data-orientation",
+        "aria-valuenow",
+        "aria-valuemin",
+        "aria-valuemax",
+        "aria-orientation",
+        "as-child",
+        "as",
+        "style"
+      ])]),
+      _: 3
+    }));
+  }
+}), ze = He, Ne = /* @__PURE__ */ B({
+  __name: "SliderThumb",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(o) {
+    const n = o, { getItems: t } = W(), { forwardRef: a, currentElement: s } = I(), d = p(() => s.value ? t(!0).findIndex((i) => i.ref === s.value) : -1);
+    return (i, l) => (V(), x(ze, N({ ref: e(a) }, n, { index: d.value }), {
+      default: E(() => [P(i.$slots, "default")]),
+      _: 3
+    }, 16, ["index"]));
+  }
+}), Fe = Ne, Ye = /* @__PURE__ */ B({
+  __name: "SliderTrack",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(o) {
+    const n = $();
+    return I(), (t, a) => (V(), x(e(Y), {
+      "as-child": t.asChild,
+      as: t.as,
+      "data-disabled": e(n).disabled.value ? "" : void 0,
+      "data-orientation": e(n).orientation.value
+    }, {
+      default: E(() => [P(t.$slots, "default")]),
+      _: 3
+    }, 8, [
+      "as-child",
+      "as",
+      "data-disabled",
+      "data-orientation"
+    ]));
+  }
+}), Oe = Ye;
+const ot = /* @__PURE__ */ B({
+  __name: "BuiSlider",
+  props: {
+    defaultValue: {},
+    modelValue: {},
+    disabled: { type: Boolean },
+    orientation: {},
+    dir: {},
+    inverted: { type: Boolean },
+    min: {},
+    max: {},
+    step: {},
+    minStepsBetweenThumbs: {},
+    thumbAlignment: {},
+    asChild: { type: Boolean },
+    as: {},
+    name: {},
+    required: { type: Boolean }
+  },
+  emits: ["update:modelValue", "valueCommit"],
+  setup(o, { emit: n }) {
+    const t = o, s = ve(n);
+    return (d, i) => (V(), x(e(Ie), N({
+      class: e(he)("relative flex w-full touch-none select-none items-center", d.$attrs.class ?? "")
+    }, { ...t, ...e(s) }), {
+      default: E(() => [
+        F(e(Oe), { class: "relative h-2 w-full grow overflow-hidden rounded-full bg-secondary" }, {
+          default: E(() => [
+            F(e(Te), { class: "absolute h-full bg-primary" })
+          ]),
+          _: 1
+        }),
+        F(e(Fe), { class: "block h-5 w-5 rounded-full border border-border bg-background ring-offset-background transition-colors focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50" })
+      ]),
+      _: 1
+    }, 16, ["class"]));
+  }
+});
+export {
+  ot as _
+};

package/dist/BuiStepper.vue_vue_type_script_setup_true_lang-BK8shmbx.js

@@ -0,0 +1,35 @@
+import { defineComponent as d, computed as m, createBlock as i, openBlock as u, unref as e, mergeProps as f, withCtx as _, renderSlot as g, normalizeProps as B, guardReactiveProps as P } from "vue";
+import { g as S } from "./utils-DIEJYj9K.js";
+import { u as h } from "./useForwardPropsEmits-DriEAzTI.js";
+import { S as w } from "./StepperRoot-DTKGD-ar.js";
+const y = /* @__PURE__ */ d({
+  __name: "BuiStepper",
+  props: {
+    defaultValue: {},
+    orientation: {},
+    dir: {},
+    modelValue: {},
+    linear: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  emits: ["update:modelValue"],
+  setup(s, { emit: a }) {
+    const o = s, l = a, p = m(() => {
+      const { class: t, ...r } = o;
+      return r;
+    }), n = h(p, l);
+    return (t, r) => (u(), i(e(w), f({
+      class: e(S)("flex gap-2", o.class)
+    }, e(n)), {
+      default: _((c) => [
+        g(t.$slots, "default", B(P(c)))
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+});
+export {
+  y as _
+};