@synopackageland/ui 0.25.21 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/ToggleGroup/ToggleGroupRoot.js

@@ -0,0 +1,113 @@
+import { createContext as R } from "../shared/createContext.js";
+import { useDirection as h } from "../shared/useDirection.js";
+import { useFormControl as B } from "../shared/useFormControl.js";
+import { useForwardExpose as G } from "../shared/useForwardExpose.js";
+import { Primitive as u } from "../Primitive/Primitive.js";
+import { useSingleOrMultipleValue as S } from "../shared/useSingleOrMultipleValue.js";
+import { VisuallyHiddenInput_default as x } from "../VisuallyHidden/VisuallyHiddenInput.js";
+import { RovingFocusGroup_default as F } from "../RovingFocus/RovingFocusGroup.js";
+import { defineComponent as T, toRefs as _, openBlock as n, createBlock as d, resolveDynamicComponent as k, unref as e, withCtx as s, createVNode as w, renderSlot as D, createCommentVNode as b } from "vue";
+const [K, E] = /* @__PURE__ */ R("ToggleGroupRoot");
+var M = /* @__PURE__ */ T({
+  __name: "ToggleGroupRoot",
+  props: {
+    rovingFocus: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    disabled: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    orientation: {
+      type: String,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    loop: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    name: {
+      type: String,
+      required: !1
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    },
+    type: {
+      type: String,
+      required: !1
+    },
+    modelValue: {
+      type: null,
+      required: !1
+    },
+    defaultValue: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(o, { emit: p }) {
+    const t = o, f = p, { loop: i, rovingFocus: r, disabled: m, dir: c } = _(t), a = h(c), { forwardRef: g, currentElement: y } = G(), { modelValue: l, changeModelValue: q, isSingle: v } = S(t, f), C = B(y);
+    return E({
+      isSingle: v,
+      modelValue: l,
+      changeModelValue: q,
+      dir: a,
+      orientation: t.orientation,
+      loop: i,
+      rovingFocus: r,
+      disabled: m
+    }), (V, N) => (n(), d(k(e(r) ? e(F) : e(u)), {
+      "as-child": "",
+      orientation: e(r) ? o.orientation : void 0,
+      dir: e(a),
+      loop: e(r) ? e(i) : void 0
+    }, {
+      default: s(() => [w(e(u), {
+        ref: e(g),
+        role: "group",
+        "as-child": o.asChild,
+        as: o.as
+      }, {
+        default: s(() => [D(V.$slots, "default", { modelValue: e(l) }), e(C) && o.name ? (n(), d(x, {
+          key: 0,
+          name: o.name,
+          required: o.required,
+          value: e(l)
+        }, null, 8, [
+          "name",
+          "required",
+          "value"
+        ])) : b("v-if", !0)]),
+        _: 3
+      }, 8, ["as-child", "as"])]),
+      _: 3
+    }, 8, [
+      "orientation",
+      "dir",
+      "loop"
+    ]));
+  }
+}), L = M;
+export {
+  L as ToggleGroupRoot_default,
+  K as injectToggleGroupRootContext
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipArrow.js

@@ -0,0 +1,37 @@
+import { useForwardExpose as o } from "../shared/useForwardExpose.js";
+import { PopperArrow_default as p } from "../Popper/PopperArrow.js";
+import { defineComponent as a, openBlock as l, createBlock as u, unref as s, normalizeProps as d, guardReactiveProps as i, withCtx as f, renderSlot as n } from "vue";
+var _ = /* @__PURE__ */ a({
+  __name: "TooltipArrow",
+  props: {
+    width: {
+      type: Number,
+      required: !1,
+      default: 10
+    },
+    height: {
+      type: Number,
+      required: !1,
+      default: 5
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "svg"
+    }
+  },
+  setup(e) {
+    const r = e;
+    return o(), (t, m) => (l(), u(s(p), d(i(r)), {
+      default: f(() => [n(t.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), v = _;
+export {
+  v as TooltipArrow_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipContent.js

@@ -0,0 +1,90 @@
+import { useForwardExpose as f } from "../shared/useForwardExpose.js";
+import { useForwardPropsEmits as m } from "../shared/useForwardPropsEmits.js";
+import { Presence_default as y } from "../Presence/Presence.js";
+import { injectTooltipRootContext as c } from "./TooltipRoot.js";
+import { TooltipContentImpl_default as q } from "./TooltipContentImpl.js";
+import { TooltipContentHoverable_default as _ } from "./TooltipContentHoverable.js";
+import { defineComponent as C, openBlock as o, createBlock as i, unref as e, withCtx as n, resolveDynamicComponent as g, mergeProps as v, renderSlot as b } from "vue";
+var w = /* @__PURE__ */ C({
+  __name: "TooltipContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    ariaLabel: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    }
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside"],
+  setup(t, { emit: l }) {
+    const a = t, s = l, r = c(), p = m(a, s), { forwardRef: u } = f();
+    return (d, B) => (o(), i(e(y), { present: t.forceMount || e(r).open.value }, {
+      default: n(() => [(o(), i(g(e(r).disableHoverableContent.value ? q : _), v({ ref: e(u) }, e(p)), {
+        default: n(() => [b(d.$slots, "default")]),
+        _: 3
+      }, 16))]),
+      _: 3
+    }, 8, ["present"]));
+  }
+}), O = w;
+export {
+  O as TooltipContent_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipContentHoverable.js

@@ -0,0 +1,93 @@
+import { useForwardExpose as m } from "../shared/useForwardExpose.js";
+import { useForwardProps as g } from "../shared/useForwardProps.js";
+import { useGraceArea as y } from "../shared/useGraceArea.js";
+import { injectTooltipProviderContext as q } from "./TooltipProvider.js";
+import { injectTooltipRootContext as v } from "./TooltipRoot.js";
+import { TooltipContentImpl_default as _ } from "./TooltipContentImpl.js";
+import { defineComponent as C, openBlock as T, createBlock as P, mergeProps as b, unref as a, withCtx as h, renderSlot as w } from "vue";
+import { useEventListener as x } from "../../../@vueuse/core/dist/index.js";
+var S = /* @__PURE__ */ C({
+  __name: "TooltipContentHoverable",
+  props: {
+    ariaLabel: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    }
+  },
+  setup(l) {
+    const p = g(l), { forwardRef: u, currentElement: t } = m(), { trigger: o, onClose: i } = v(), d = q(), { isPointerInTransit: f, onPointerExit: c } = y(o, t);
+    return d.isPointerInTransitRef = f, c(() => {
+      i();
+    }), x(t, "pointermove", (e) => {
+      const r = t.value;
+      if (!r || e.pointerType === "touch") return;
+      r.ownerDocument.elementsFromPoint?.(e.clientX, e.clientY).some((n) => {
+        if (r.contains(n)) return !1;
+        const s = n.closest("[data-grace-area-trigger]");
+        return !!s && s !== o.value;
+      }) && i();
+    }), (e, r) => (T(), P(_, b({ ref: a(u) }, a(p)), {
+      default: h(() => [w(e.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), R = S;
+export {
+  R as TooltipContentHoverable_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipContentImpl.js

@@ -0,0 +1,138 @@
+import { injectModalScope as w } from "../../../../lib/localModal.js";
+import { useForwardExpose as b } from "../shared/useForwardExpose.js";
+import { DismissableLayer_default as h } from "../DismissableLayer/DismissableLayer.js";
+import { VisuallyHidden_default as q } from "../VisuallyHidden/VisuallyHidden.js";
+import { PopperContent_default as k } from "../Popper/PopperContent.js";
+import { injectTooltipProviderContext as P } from "./TooltipProvider.js";
+import { TOOLTIP_OPEN as D } from "./utils.js";
+import { injectTooltipRootContext as O } from "./TooltipRoot.js";
+import { defineComponent as _, computed as s, onMounted as S, openBlock as T, createBlock as x, unref as t, withModifiers as B, withCtx as a, createVNode as p, mergeProps as L, renderSlot as N, createTextVNode as E, toDisplayString as I } from "vue";
+import { useEventListener as d } from "../../../@vueuse/core/dist/index.js";
+import j from "../../../defu/dist/defu.js";
+var K = /* @__PURE__ */ _({
+  __name: "TooltipContentImpl",
+  props: {
+    ariaLabel: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    }
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside"],
+  setup(u, { emit: f }) {
+    const n = u, m = w(), l = f, o = O(), g = P(), { forwardRef: c, currentElement: v } = b(), y = s(() => n.ariaLabel || v.value?.textContent), C = s(() => {
+      const { ariaLabel: i, ...e } = n;
+      return j(e, g.content.value ?? {}, {
+        side: "top",
+        sideOffset: 0,
+        align: "center",
+        avoidCollisions: !0,
+        collisionBoundary: [],
+        collisionPadding: 0,
+        arrowPadding: 0,
+        sticky: "partial",
+        hideWhenDetached: !1
+      });
+    });
+    return S(() => {
+      d(window, "scroll", (i) => {
+        i.target?.contains(o.trigger.value) && o.onClose();
+      }, { capture: !0 }), d(m?.eventTarget ?? document, D, o.onClose);
+    }), (i, e) => (T(), x(t(h), {
+      "as-child": "",
+      "disable-outside-pointer-events": !1,
+      onEscapeKeyDown: e[0] || (e[0] = (r) => l("escapeKeyDown", r)),
+      onPointerDownOutside: e[1] || (e[1] = (r) => {
+        t(o).disableClosingTrigger.value && t(o).trigger.value?.contains(r.target) && r.preventDefault(), l("pointerDownOutside", r);
+      }),
+      onFocusOutside: e[2] || (e[2] = B(() => {
+      }, ["prevent"])),
+      onDismiss: e[3] || (e[3] = (r) => t(o).onClose())
+    }, {
+      default: a(() => [p(t(k), L({
+        ref: t(c),
+        "data-state": t(o).stateAttribute.value
+      }, {
+        ...i.$attrs,
+        ...C.value
+      }, { style: {
+        "--reka-tooltip-content-transform-origin": "var(--reka-popper-transform-origin)",
+        "--reka-tooltip-content-available-width": "var(--reka-popper-available-width)",
+        "--reka-tooltip-content-available-height": "var(--reka-popper-available-height)",
+        "--reka-tooltip-trigger-width": "var(--reka-popper-anchor-width)",
+        "--reka-tooltip-trigger-height": "var(--reka-popper-anchor-height)"
+      } }), {
+        default: a(() => [N(i.$slots, "default"), p(t(q), {
+          id: t(o).contentId,
+          role: "tooltip"
+        }, {
+          default: a(() => [E(I(y.value), 1)]),
+          _: 1
+        }, 8, ["id"])]),
+        _: 3
+      }, 16, ["data-state"])]),
+      _: 3
+    }));
+  }
+}), Q = K;
+export {
+  Q as TooltipContentImpl_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipPortal.js

@@ -0,0 +1,33 @@
+import { Teleport_default as t } from "../Teleport/Teleport.js";
+import { defineComponent as l, openBlock as a, createBlock as p, unref as u, normalizeProps as n, guardReactiveProps as d, withCtx as f, renderSlot as i } from "vue";
+var s = /* @__PURE__ */ l({
+  __name: "TooltipPortal",
+  props: {
+    to: {
+      type: null,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    defer: {
+      type: Boolean,
+      required: !1
+    },
+    forceMount: {
+      type: Boolean,
+      required: !1
+    }
+  },
+  setup(e) {
+    const o = e;
+    return (r, _) => (a(), p(u(t), n(d(o)), {
+      default: f(() => [i(r.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), v = s;
+export {
+  v as TooltipPortal_default
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipProvider.js

@@ -0,0 +1,70 @@
+import { createContext as v } from "../shared/createContext.js";
+import { useForwardExpose as y } from "../shared/useForwardExpose.js";
+import { defineComponent as b, toRefs as T, ref as o, renderSlot as _ } from "vue";
+import { useTimeoutFn as g } from "../../../@vueuse/shared/dist/index.js";
+const [N, C] = /* @__PURE__ */ v("TooltipProvider");
+var q = /* @__PURE__ */ b({
+  inheritAttrs: !1,
+  __name: "TooltipProvider",
+  props: {
+    delayDuration: {
+      type: Number,
+      required: !1,
+      default: 700
+    },
+    skipDelayDuration: {
+      type: Number,
+      required: !1,
+      default: 300
+    },
+    disableHoverableContent: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    disableClosingTrigger: {
+      type: Boolean,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    ignoreNonKeyboardFocus: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    content: {
+      type: Object,
+      required: !1
+    }
+  },
+  setup(r) {
+    const t = r, { delayDuration: a, skipDelayDuration: i, disableHoverableContent: l, disableClosingTrigger: s, ignoreNonKeyboardFocus: n, disabled: d, content: u } = T(t);
+    y();
+    const e = o(!0), p = o(!1), { start: f, stop: c } = g(() => {
+      e.value = !0;
+    }, i, { immediate: !1 });
+    return C({
+      isOpenDelayed: e,
+      delayDuration: a,
+      onOpen() {
+        c(), e.value = !1;
+      },
+      onClose() {
+        f();
+      },
+      isPointerInTransitRef: p,
+      disableHoverableContent: l,
+      disableClosingTrigger: s,
+      disabled: d,
+      ignoreNonKeyboardFocus: n,
+      content: u
+    }), (m, D) => _(m.$slots, "default");
+  }
+}), O = q;
+export {
+  O as TooltipProvider_default,
+  N as injectTooltipProviderContext
+};

package/dist/modules/vendor/reka-ui/dist/Tooltip/TooltipRoot.js

@@ -0,0 +1,102 @@
+import { injectModalScope as x } from "../../../../lib/localModal.js";
+import { createContext as B } from "../shared/createContext.js";
+import { useForwardExpose as R } from "../shared/useForwardExpose.js";
+import { PopperRoot_default as q } from "../Popper/PopperRoot.js";
+import { injectTooltipProviderContext as D } from "./TooltipProvider.js";
+import { TOOLTIP_OPEN as F } from "./utils.js";
+import { defineComponent as N, computed as n, watch as w, ref as p, openBlock as E, createBlock as H, unref as f, withCtx as K, renderSlot as P } from "vue";
+import { useVModel as j } from "../../../@vueuse/core/dist/index.js";
+import { useTimeoutFn as S } from "../../../@vueuse/shared/dist/index.js";
+const [W, k] = /* @__PURE__ */ B("TooltipRoot");
+var I = /* @__PURE__ */ N({
+  __name: "TooltipRoot",
+  props: {
+    defaultOpen: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    open: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    delayDuration: {
+      type: Number,
+      required: !1,
+      default: void 0
+    },
+    disableHoverableContent: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    disableClosingTrigger: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    ignoreNonKeyboardFocus: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    }
+  },
+  emits: ["update:open"],
+  setup(c, { emit: v }) {
+    const o = c, m = x(), g = v;
+    R();
+    const e = D(), i = n(() => o.disableHoverableContent ?? e.disableHoverableContent.value), b = n(() => o.disableClosingTrigger ?? e.disableClosingTrigger.value), y = n(() => o.disabled ?? e.disabled.value), C = n(() => o.delayDuration ?? e.delayDuration.value), T = n(() => o.ignoreNonKeyboardFocus ?? e.ignoreNonKeyboardFocus.value), t = j(o, "open", g, {
+      defaultValue: o.defaultOpen,
+      passive: o.open === void 0
+    });
+    w(t, (a) => {
+      e.onClose && (a ? (e.onOpen(), (m?.eventTarget ?? document).dispatchEvent(new CustomEvent(F))) : e.onClose());
+    });
+    const l = p(!1), s = p(), _ = n(() => t.value ? l.value ? "delayed-open" : "instant-open" : "closed"), { start: O, stop: r } = S(() => {
+      l.value = !0, t.value = !0;
+    }, C, { immediate: !1 });
+    function d() {
+      r(), l.value = !1, t.value = !0;
+    }
+    function u() {
+      r(), t.value = !1;
+    }
+    function h() {
+      O();
+    }
+    return k({
+      contentId: "",
+      open: t,
+      stateAttribute: _,
+      trigger: s,
+      onTriggerChange(a) {
+        s.value = a;
+      },
+      onTriggerEnter() {
+        e.isOpenDelayed.value ? h() : d();
+      },
+      onTriggerLeave() {
+        i.value ? u() : r();
+      },
+      onOpen: d,
+      onClose: u,
+      disableHoverableContent: i,
+      disableClosingTrigger: b,
+      disabled: y,
+      ignoreNonKeyboardFocus: T
+    }), (a, L) => (E(), H(f(q), null, {
+      default: K(() => [P(a.$slots, "default", { open: f(t) })]),
+      _: 3
+    }));
+  }
+}), X = I;
+export {
+  X as TooltipRoot_default,
+  W as injectTooltipRootContext
+};