@synopackageland/ui 0.25.20 → 0.25.22

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxContentImpl.js

@@ -0,0 +1,234 @@
+import { createContext as D } from "../shared/createContext.js";
+import { getActiveElement as v } from "../shared/getActiveElement.js";
+import { useBodyScrollLock as F } from "../shared/useBodyScrollLock.js";
+import { useFocusGuards as I } from "../shared/useFocusGuards.js";
+import { useForwardExpose as L } from "../shared/useForwardExpose.js";
+import { useForwardProps as A } from "../shared/useForwardProps.js";
+import { useHideOthers as N } from "../shared/useHideOthers.js";
+import { Primitive as W } from "../Primitive/Primitive.js";
+import { DismissableLayer_default as U } from "../DismissableLayer/DismissableLayer.js";
+import { FocusScope_default as _ } from "../FocusScope/FocusScope.js";
+import { ListboxContent_default as $ } from "../Listbox/ListboxContent.js";
+import { PopperContent_default as j } from "../Popper/PopperContent.js";
+import { injectComboboxRootContext as z } from "./ComboboxRoot.js";
+import { defineComponent as H, toRefs as K, watch as d, computed as f, ref as M, onMounted as R, nextTick as T, onUnmounted as G, openBlock as g, createBlock as C, unref as r, withCtx as l, createVNode as q, withModifiers as x, resolveDynamicComponent as V, mergeProps as J, toHandlers as Q, renderSlot as X } from "vue";
+const [ce, Y] = /* @__PURE__ */ D("ComboboxContent");
+var Z = /* @__PURE__ */ H({
+  __name: "ComboboxContentImpl",
+  props: {
+    position: {
+      type: String,
+      required: !1,
+      default: "inline"
+    },
+    bodyLock: {
+      type: Boolean,
+      required: !1
+    },
+    hideWhenEmpty: {
+      type: Boolean,
+      required: !1
+    },
+    memoDependencies: {
+      type: Array,
+      required: !1
+    },
+    side: {
+      type: null,
+      required: !1
+    },
+    sideOffset: {
+      type: Number,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    align: {
+      type: null,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1
+    },
+    arrowPadding: {
+      type: Number,
+      required: !1
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    updatePositionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: !1
+    },
+    present: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside"
+  ],
+  setup(m, { emit: h }) {
+    const i = m, s = h, { position: a } = K(i), t = z(), p = /* @__PURE__ */ Symbol("ComboboxContent");
+    d(a, (n) => t.onContentPositionChange(p, n), { immediate: !0 });
+    const c = f(() => t.ignoreFilter.value ? t.allItems.value.size === 0 : t.filterState.value.count === 0), { forwardRef: E, currentElement: b } = L(), w = F(i.present && i.bodyLock);
+    d([() => i.present, () => i.bodyLock], ([n, e]) => w.value = n && e), I();
+    const k = f(() => i.present ? t.parentElement.value : void 0);
+    N(k);
+    const S = f(() => {
+      if (i.position === "popper") {
+        const { present: n, ...e } = i;
+        return e;
+      } else return {};
+    }), O = A(S), B = {
+      boxSizing: "border-box",
+      "--reka-combobox-content-transform-origin": "var(--reka-popper-transform-origin)",
+      "--reka-combobox-content-available-width": "var(--reka-popper-available-width)",
+      "--reka-combobox-content-available-height": "var(--reka-popper-available-height)",
+      "--reka-combobox-trigger-width": "var(--reka-popper-anchor-width)",
+      "--reka-combobox-trigger-height": "var(--reka-popper-anchor-height)"
+    };
+    Y({ position: a });
+    const u = M(!1);
+    R(() => {
+      t.inputElement.value && (u.value = b.value.contains(t.inputElement.value), i.present && u.value && t.inputElement.value.focus());
+    }), d(() => i.present, async (n, e) => {
+      if (n || !e) return;
+      const o = v();
+      !o || !b.value.contains(o) || (await T(), t.triggerElement.value?.focus());
+    }), G(() => {
+      t.onContentUnmount(p);
+      const n = v();
+      u.value && (!n || n === document.body) && t.triggerElement.value?.focus();
+    });
+    function y(n) {
+      if (t.parentElement.value?.contains(n)) return !0;
+      const o = (n instanceof Element ? n.closest("label") : null)?.control;
+      return !!o && !!t.parentElement.value?.contains(o);
+    }
+    const P = { placed: () => t.onContentPlaced(p) };
+    return (n, e) => (g(), C(r($), { "as-child": "" }, {
+      default: l(() => [q(r(_), {
+        "as-child": "",
+        present: i.present,
+        onMountAutoFocus: e[5] || (e[5] = x(() => {
+        }, ["prevent"])),
+        onUnmountAutoFocus: e[6] || (e[6] = x(() => {
+        }, ["prevent"]))
+      }, {
+        default: l(() => [q(r(U), {
+          "as-child": "",
+          present: i.present,
+          "disable-outside-pointer-events": m.disableOutsidePointerEvents,
+          onDismiss: e[0] || (e[0] = (o) => r(t).onOpenChange(!1)),
+          onFocusOutside: e[1] || (e[1] = (o) => {
+            y(o.target) && o.preventDefault(), s("focusOutside", o);
+          }),
+          onInteractOutside: e[2] || (e[2] = (o) => s("interactOutside", o)),
+          onEscapeKeyDown: e[3] || (e[3] = (o) => s("escapeKeyDown", o)),
+          onPointerDownOutside: e[4] || (e[4] = (o) => {
+            y(o.target) && o.preventDefault(), s("pointerDownOutside", o);
+          })
+        }, {
+          default: l(() => [(g(), C(V(r(a) === "popper" ? r(j) : r(W)), J({
+            ...n.$attrs,
+            ...r(O)
+          }, {
+            id: r(t).contentId,
+            ref: r(E),
+            "memo-dependencies": r(a) === "popper" ? [r(t).filterSearch.value, r(t).filterState.value] : void 0,
+            "data-state": r(t).open.value ? "open" : "closed",
+            "data-empty": c.value ? "" : void 0,
+            style: {
+              display: i.hideWhenEmpty && c.value ? "none" : "flex",
+              flexDirection: "column",
+              outline: "none",
+              ...r(a) === "popper" ? B : {}
+            }
+          }, Q(r(a) === "popper" ? P : {})), {
+            default: l(() => [X(n.$slots, "default")]),
+            _: 3
+          }, 16, [
+            "id",
+            "memo-dependencies",
+            "data-state",
+            "data-empty",
+            "style"
+          ]))]),
+          _: 3
+        }, 8, ["present", "disable-outside-pointer-events"])]),
+        _: 3
+      }, 8, ["present"])]),
+      _: 3
+    }));
+  }
+}), be = Z;
+export {
+  be as ComboboxContentImpl_default,
+  ce as injectComboboxContentContext
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxGroup.js

@@ -0,0 +1,44 @@
+import { createContext as p } from "../shared/createContext.js";
+import { useId as d } from "../shared/useId.js";
+import { ListboxGroup_default as i } from "../Listbox/ListboxGroup.js";
+import { injectComboboxRootContext as s } from "./ComboboxRoot.js";
+import { defineComponent as b, computed as m, onMounted as c, onUnmounted as f, openBlock as x, createBlock as C, unref as t, mergeProps as v, withCtx as _, renderSlot as G } from "vue";
+const [q, h] = /* @__PURE__ */ p("ComboboxGroup");
+var g = /* @__PURE__ */ b({
+  __name: "ComboboxGroup",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(r) {
+    const l = r, o = d(void 0, "reka-combobox-group"), e = s(), u = m(() => e.ignoreFilter.value ? !0 : e.filterSearch.value ? e.filterState.value.groups.has(o) : !0), a = h({
+      id: o,
+      labelId: ""
+    });
+    return c(() => {
+      e.allGroups.value.has(o) || e.allGroups.value.set(o, /* @__PURE__ */ new Set());
+    }), f(() => {
+      e.allGroups.value.delete(o);
+    }), (n, y) => (x(), C(t(i), v({
+      id: t(o),
+      "aria-labelledby": t(a).labelId
+    }, l, { hidden: u.value ? void 0 : !0 }), {
+      default: _(() => [G(n.$slots, "default")]),
+      _: 3
+    }, 16, [
+      "id",
+      "aria-labelledby",
+      "hidden"
+    ]));
+  }
+}), w = g;
+export {
+  w as ComboboxGroup_default,
+  q as injectComboboxGroupContext
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxInput.js

@@ -0,0 +1,131 @@
+import { useComposing as k } from "../shared/useComposing.js";
+import { usePrimitiveElement as q } from "../Primitive/usePrimitiveElement.js";
+import { injectListboxRootContext as w } from "../Listbox/ListboxRoot.js";
+import { ListboxFilter_default as _ } from "../Listbox/ListboxFilter.js";
+import { injectComboboxRootContext as R } from "./ComboboxRoot.js";
+import { defineComponent as T, onMounted as j, watch as c, openBlock as A, createBlock as D, unref as a, withKeys as K, isRef as M, withCtx as U, renderSlot as L, nextTick as f } from "vue";
+import { useVModel as P } from "../../../@vueuse/core/dist/index.js";
+var $ = /* @__PURE__ */ T({
+  __name: "ComboboxInput",
+  props: {
+    displayValue: {
+      type: Function,
+      required: !1
+    },
+    modelValue: {
+      type: String,
+      required: !1
+    },
+    autoFocus: {
+      type: Boolean,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "input"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(l, { emit: v }) {
+    const i = l, C = v, e = R(), r = w(), { primitiveElement: h, currentElement: s } = q(), n = P(i, "modelValue", C, { passive: i.modelValue === void 0 });
+    j(() => {
+      s.value && e.onInputElementChange(s.value);
+    });
+    const { isComposing: g, shouldDeferInput: y, handleCompositionStart: b, handleCompositionUpdate: x, handleCompositionEnd: I } = k((t) => {
+      const o = t.target;
+      o && d(o.value);
+    });
+    function V(t) {
+      g.value || (t.preventDefault(), e.open.value || e.onOpenChange(!0));
+    }
+    function d(t) {
+      e.open.value ? e.filterSearch.value = t : (e.onOpenChange(!0), f(() => {
+        t && (e.filterSearch.value = t, r.highlightFirstItem());
+      }));
+    }
+    function S(t) {
+      y.value || d(t.target.value);
+    }
+    function E() {
+      e.openOnFocus.value && !e.open.value && e.onOpenChange(!0);
+    }
+    function F(t) {
+      if (!e.open.value) return;
+      const o = t.relatedTarget;
+      if (!o) return;
+      const u = e.parentElement.value?.contains(o), B = document.getElementById(e.contentId)?.contains(o);
+      !u && !B && requestAnimationFrame(() => {
+        if (!e.open.value) return;
+        const m = document.activeElement;
+        !e.parentElement.value?.contains(m) && !document.getElementById(e.contentId)?.contains(m) && e.onOpenChange(!1);
+      });
+    }
+    function O() {
+      e.openOnClick.value && !e.open.value && e.onOpenChange(!0);
+    }
+    function p() {
+      const t = e.modelValue.value;
+      i.displayValue ? n.value = i.displayValue(t) : !e.multiple.value && t && !Array.isArray(t) && typeof t != "object" ? n.value = t.toString() : n.value = "", f(() => {
+        n.value = n.value;
+      });
+    }
+    return e.onResetSearchTerm(() => {
+      p();
+    }), c(e.modelValue, async () => {
+      !e.isUserInputted.value && e.resetSearchTermOnSelect.value && p();
+    }, {
+      immediate: !0,
+      deep: !0
+    }), c(e.filterState, (t, o) => {
+      !e.isVirtual.value && o.count === 0 && r.highlightFirstItem();
+    }), (t, o) => (A(), D(a(_), {
+      ref_key: "primitiveElement",
+      ref: h,
+      modelValue: a(n),
+      "onUpdate:modelValue": o[0] || (o[0] = (u) => M(n) ? n.value = u : null),
+      as: l.as,
+      "as-child": l.asChild,
+      "auto-focus": l.autoFocus,
+      disabled: l.disabled,
+      "aria-expanded": a(e).open.value,
+      "aria-controls": a(e).contentId,
+      "aria-autocomplete": "list",
+      role: "combobox",
+      autocomplete: "off",
+      onClick: O,
+      onInput: S,
+      onKeydown: K(V, ["down", "up"]),
+      onFocus: E,
+      onBlur: F,
+      onCompositionstart: a(b),
+      onCompositionupdate: a(x),
+      onCompositionend: a(I)
+    }, {
+      default: U(() => [L(t.$slots, "default")]),
+      _: 3
+    }, 8, [
+      "modelValue",
+      "as",
+      "as-child",
+      "auto-focus",
+      "disabled",
+      "aria-expanded",
+      "aria-controls",
+      "onCompositionstart",
+      "onCompositionupdate",
+      "onCompositionend"
+    ]));
+  }
+}), Y = $;
+export {
+  Y as ComboboxInput_default
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxItem.js

@@ -0,0 +1,73 @@
+import { useId as f } from "../shared/useId.js";
+import { usePrimitiveElement as b } from "../Primitive/usePrimitiveElement.js";
+import { ListboxItem_default as c } from "../Listbox/ListboxItem.js";
+import { injectComboboxRootContext as x } from "./ComboboxRoot.js";
+import { injectComboboxGroupContext as C } from "./ComboboxGroup.js";
+import { defineComponent as h, computed as g, onMounted as y, onUnmounted as I, withMemo as S, unref as t, openBlock as w, createBlock as E, mergeProps as V, withCtx as k, renderSlot as q, normalizeProps as P, guardReactiveProps as B, createTextVNode as G, toDisplayString as j, createCommentVNode as R } from "vue";
+var T = /* @__PURE__ */ h({
+  __name: "ComboboxItem",
+  props: {
+    textValue: {
+      type: String,
+      required: !1
+    },
+    value: {
+      type: null,
+      required: !0
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select"],
+  setup(a, { emit: d }) {
+    const o = a, m = d, r = f(void 0, "reka-combobox-item"), e = x(), v = C(null), { primitiveElement: p, currentElement: n } = b();
+    if (o.value === "") throw new Error("A <ComboboxItem /> must have a value prop that is not an empty string. This is because the Combobox value can be set to an empty string to clear the selection and show the placeholder.");
+    const s = g(() => {
+      if (e.isVirtual.value || e.ignoreFilter.value || !e.filterSearch.value) return !0;
+      {
+        const l = e.filterState.value.items.get(r);
+        return l === void 0 ? !0 : l > 0;
+      }
+    });
+    return y(() => {
+      e.allItems.value.set(r, o.textValue || n.value.textContent || n.value.innerText);
+      const l = v?.id;
+      l && (e.allGroups.value.has(l) ? e.allGroups.value.get(l)?.add(r) : e.allGroups.value.set(l, /* @__PURE__ */ new Set([r])));
+    }), I(() => {
+      e.allItems.value.delete(r);
+    }), (l, i) => s.value ? S([
+      s.value,
+      t(e).filterSearch.value,
+      t(e).disabled.value,
+      a.disabled,
+      o.value,
+      o.as,
+      o.asChild,
+      ...Object.values(l.$attrs)
+    ], () => (w(), E(t(c), V({ key: 0 }, o, {
+      id: t(r),
+      ref_key: "primitiveElement",
+      ref: p,
+      disabled: t(e).disabled.value || a.disabled,
+      onSelect: i[0] || (i[0] = (u) => {
+        m("select", u), !u.defaultPrevented && (!t(e).multiple.value && !a.disabled && !t(e).disabled.value ? (u.preventDefault(), t(e).onOpenChange(!1), t(e).modelValue.value = o.value) : t(e).multiple.value && t(e).inputElement.value?.focus());
+      })
+    }), {
+      default: k((u) => [q(l.$slots, "default", P(B(u)), () => [G(j(a.value), 1)])]),
+      _: 3
+    }, 16, ["id", "disabled"])), i, 1) : R("v-if", !0);
+  }
+}), z = T;
+export {
+  z as ComboboxItem_default
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxItemIndicator.js

@@ -0,0 +1,30 @@
+import { ListboxItemIndicator_default as r } from "../Listbox/ListboxItemIndicator.js";
+import { defineComponent as a, openBlock as n, createBlock as l, unref as u, normalizeProps as p, guardReactiveProps as d, withCtx as s, renderSlot as i } from "vue";
+var f = /* @__PURE__ */ a({
+  __name: "ComboboxItemIndicator",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "span"
+    }
+  },
+  setup(e) {
+    const o = e;
+    return (t, m) => (n(), l(u(r), p(d(o)), {
+      default: s(() => [i(t.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), I = f;
+export {
+  I as ComboboxItemIndicator_default
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxLabel.js

@@ -0,0 +1,38 @@
+import { useForwardExpose as a } from "../shared/useForwardExpose.js";
+import { useId as p } from "../shared/useId.js";
+import { Primitive as i } from "../Primitive/Primitive.js";
+import { injectComboboxGroupContext as u } from "./ComboboxGroup.js";
+import { defineComponent as d, openBlock as m, createBlock as n, unref as o, mergeProps as s, withCtx as b, renderSlot as f } from "vue";
+var _ = /* @__PURE__ */ d({
+  __name: "ComboboxLabel",
+  props: {
+    for: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1,
+      default: "div"
+    }
+  },
+  setup(r) {
+    const t = r;
+    a();
+    const e = u({
+      id: "",
+      labelId: ""
+    });
+    return e.labelId ||= p(void 0, "reka-combobox-group-label"), (l, c) => (m(), n(o(i), s(t, { id: o(e).labelId }), {
+      default: b(() => [f(l.$slots, "default")]),
+      _: 3
+    }, 16, ["id"]));
+  }
+}), I = _;
+export {
+  I as ComboboxLabel_default
+};

package/dist/modules/vendor/reka-ui/dist/Combobox/ComboboxPortal.js

@@ -0,0 +1,33 @@
+import { Teleport_default as t } from "../Teleport/Teleport.js";
+import { defineComponent as a, openBlock as l, createBlock as p, unref as u, normalizeProps as n, guardReactiveProps as d, withCtx as f, renderSlot as s } from "vue";
+var _ = /* @__PURE__ */ a({
+  __name: "ComboboxPortal",
+  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, i) => (l(), p(u(t), n(d(o)), {
+      default: f(() => [s(r.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), b = _;
+export {
+  b as ComboboxPortal_default
+};