@synopackageland/ui 0.25.21 → 0.25.22

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

@@ -0,0 +1,231 @@
+import { createContext as J } from "../shared/createContext.js";
+import { useDirection as K } from "../shared/useDirection.js";
+import { useFilter as Q } from "../shared/useFilter.js";
+import { usePrimitiveElement as W } from "../Primitive/usePrimitiveElement.js";
+import { ListboxRoot_default as X } from "../Listbox/ListboxRoot.js";
+import { PopperRoot_default as Y } from "../Popper/PopperRoot.js";
+import { useComboboxContentPositioning as Z } from "./useComboboxContentPositioning.js";
+import { defineComponent as ee, toRefs as te, ref as n, computed as E, getCurrentInstance as oe, onMounted as le, openBlock as ie, createBlock as re, unref as t, withCtx as F, createVNode as ne, mergeProps as ae, isRef as ue, renderSlot as se, nextTick as de } from "vue";
+import { useVModel as R } from "../../../@vueuse/core/dist/index.js";
+import { createEventHook as pe } from "../../../@vueuse/shared/dist/index.js";
+const [xe, me] = /* @__PURE__ */ J("ComboboxRoot");
+var fe = /* @__PURE__ */ ee({
+  __name: "ComboboxRoot",
+  props: {
+    open: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    defaultOpen: {
+      type: Boolean,
+      required: !1
+    },
+    resetSearchTermOnBlur: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    resetSearchTermOnSelect: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    openOnFocus: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    openOnClick: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    ignoreFilter: {
+      type: Boolean,
+      required: !1
+    },
+    resetModelValueOnClear: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    unmountOnHide: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    modelValue: {
+      type: null,
+      required: !1
+    },
+    defaultValue: {
+      type: null,
+      required: !1
+    },
+    multiple: {
+      type: Boolean,
+      required: !1
+    },
+    dir: {
+      type: String,
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    highlightOnHover: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    by: {
+      type: [String, Function],
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    },
+    name: {
+      type: String,
+      required: !1
+    },
+    required: {
+      type: Boolean,
+      required: !1
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "highlight",
+    "update:open"
+  ],
+  setup(a, { expose: k, emit: T }) {
+    const o = a, f = T, { primitiveElement: l, currentElement: w } = W(), { multiple: h, disabled: C, ignoreFilter: M, resetSearchTermOnSelect: H, openOnFocus: P, openOnClick: _, dir: D, resetModelValueOnClear: G, highlightOnHover: U, loop: $, unmountOnHide: j } = te(o), z = K(D), u = R(o, "modelValue", f, {
+      defaultValue: o.defaultValue ?? (h.value ? [] : void 0),
+      passive: o.modelValue === void 0,
+      deep: !0
+    }), s = R(o, "open", f, {
+      defaultValue: o.defaultOpen,
+      passive: o.open === void 0
+    });
+    async function L(e) {
+      s.value = e, d.value = "", e ? (await de(), l.value?.highlightSelected(), g.value = !0, c.value?.focus()) : (g.value = !1, setTimeout(() => {
+        !e && o.resetSearchTermOnBlur && S.trigger();
+      }, 1));
+    }
+    const S = pe(), g = n(!1), B = n(!1), c = n(), x = n(), O = E(() => l.value?.highlightedElement ?? void 0), N = Z(s), v = n(/* @__PURE__ */ new Map()), y = n(/* @__PURE__ */ new Map()), { contains: A } = Q({ sensitivity: "base" }), d = n(""), V = E((e) => {
+      if (!d.value || o.ignoreFilter || B.value) return {
+        count: v.value.size,
+        items: e?.items ?? /* @__PURE__ */ new Map(),
+        groups: e?.groups ?? new Set(y.value.keys())
+      };
+      let i = 0;
+      const r = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Set();
+      for (const [b, q] of v.value) {
+        const m = A(q, d.value);
+        r.set(b, m ? 1 : 0), m && i++;
+      }
+      for (const [b, q] of y.value) for (const m of q) if (r.get(m) > 0) {
+        I.add(b);
+        break;
+      }
+      return {
+        count: i,
+        items: r,
+        groups: I
+      };
+    }), p = oe();
+    return le(() => {
+      p?.exposed && (p.exposed.highlightItem = l.value?.highlightItem, p.exposed.highlightFirstItem = l.value?.highlightFirstItem, p.exposed.highlightSelected = l.value?.highlightSelected);
+    }), k({
+      filtered: V,
+      highlightedElement: O,
+      highlightItem: l.value?.highlightItem,
+      highlightFirstItem: l.value?.highlightFirstItem,
+      highlightSelected: l.value?.highlightSelected
+    }), me({
+      modelValue: u,
+      multiple: h,
+      disabled: C,
+      open: s,
+      onOpenChange: L,
+      ...N,
+      contentId: "",
+      isUserInputted: g,
+      isVirtual: B,
+      inputElement: c,
+      highlightedElement: O,
+      onInputElementChange: (e) => c.value = e,
+      triggerElement: x,
+      onTriggerElementChange: (e) => x.value = e,
+      parentElement: w,
+      resetSearchTermOnSelect: H,
+      onResetSearchTerm: S.on,
+      allItems: v,
+      allGroups: y,
+      filterSearch: d,
+      filterState: V,
+      ignoreFilter: M,
+      openOnFocus: P,
+      openOnClick: _,
+      resetModelValueOnClear: G,
+      unmountOnHide: j
+    }), (e, i) => (ie(), re(t(Y), null, {
+      default: F(() => [ne(t(X), ae({
+        ref_key: "primitiveElement",
+        ref: l
+      }, e.$attrs, {
+        modelValue: t(u),
+        "onUpdate:modelValue": i[0] || (i[0] = (r) => ue(u) ? u.value = r : null),
+        style: { pointerEvents: t(s) ? "auto" : void 0 },
+        as: a.as,
+        "as-child": a.asChild,
+        dir: t(z),
+        multiple: t(h),
+        name: a.name,
+        required: a.required,
+        disabled: t(C),
+        "highlight-on-hover": t(U),
+        loop: t($),
+        by: o.by,
+        onHighlight: i[1] || (i[1] = (r) => f("highlight", r))
+      }), {
+        default: F(() => [se(e.$slots, "default", {
+          open: t(s),
+          modelValue: t(u)
+        })]),
+        _: 3
+      }, 16, [
+        "modelValue",
+        "style",
+        "as",
+        "as-child",
+        "dir",
+        "multiple",
+        "name",
+        "required",
+        "disabled",
+        "highlight-on-hover",
+        "loop",
+        "by"
+      ])]),
+      _: 3
+    }));
+  }
+}), Oe = fe;
+export {
+  Oe as ComboboxRoot_default,
+  xe as injectComboboxRootContext,
+  me as provideComboboxRootContext
+};

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

@@ -0,0 +1,50 @@
+import { useForwardExpose as u } from "../shared/useForwardExpose.js";
+import { Primitive as n } from "../Primitive/Primitive.js";
+import { injectComboboxRootContext as d } from "./ComboboxRoot.js";
+import { useNonce as f } from "../shared/useNonce.js";
+import { defineComponent as b, toRefs as w, openBlock as v, createElementBlock as x, Fragment as _, createVNode as l, unref as o, mergeProps as y, withCtx as s, renderSlot as C, createTextVNode as k } from "vue";
+var V = /* @__PURE__ */ b({
+  __name: "ComboboxViewport",
+  props: {
+    nonce: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  setup(a) {
+    const e = a, { forwardRef: i } = u(), { nonce: p } = w(e), c = f(p), m = d();
+    return (r, t) => (v(), x(_, null, [l(o(n), y({
+      ...r.$attrs,
+      ...e
+    }, {
+      ref: o(i),
+      "data-reka-combobox-viewport": "",
+      role: "presentation",
+      style: {
+        position: "relative",
+        flex: o(m).isVirtual.value ? void 0 : 1,
+        overflow: "auto"
+      }
+    }), {
+      default: s(() => [C(r.$slots, "default")]),
+      _: 3
+    }, 16, ["style"]), l(o(n), {
+      as: "style",
+      nonce: o(c)
+    }, {
+      default: s(() => [...t[0] || (t[0] = [k(" /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-combobox-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-combobox-viewport]::-webkit-scrollbar { display: none; } ", -1)])]),
+      _: 1
+    }, 8, ["nonce"])], 64));
+  }
+}), R = V;
+export {
+  R as ComboboxViewport_default
+};

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

@@ -0,0 +1,32 @@
+import { provideListboxHighlightScrollContext as f } from "../Listbox/ListboxRoot.js";
+import { ref as u, computed as p } from "vue";
+function h(r) {
+  const o = u("inline"), n = u(!1), t = u(), a = p(() => o.value === "popper" && !n.value);
+  let l;
+  f({
+    suppressHighlightScroll: a,
+    onHighlightScrollRequest(e) {
+      l = e;
+    }
+  });
+  function v(e, i) {
+    (t.value !== e || o.value !== i) && (n.value = !1, l = void 0), t.value = e, o.value = i;
+  }
+  function c(e) {
+    if (t.value !== e || o.value !== "popper" || n.value) return;
+    n.value = !0;
+    const i = l;
+    l = void 0, r.value && i?.();
+  }
+  function s(e) {
+    t.value === e && (t.value = void 0, o.value = "inline", n.value = !1, l = void 0);
+  }
+  return {
+    onContentPositionChange: v,
+    onContentPlaced: c,
+    onContentUnmount: s
+  };
+}
+export {
+  h as useComboboxContentPositioning
+};

package/dist/modules/vendor/reka-ui/dist/ConfigProvider/ConfigProvider.js

@@ -0,0 +1,54 @@
+import { createContext as u } from "../shared/createContext.js";
+import { defineComponent as f, toRefs as a, renderSlot as s } from "vue";
+const [C, p] = /* @__PURE__ */ u("ConfigProvider");
+var c = /* @__PURE__ */ f({
+  inheritAttrs: !1,
+  __name: "ConfigProvider",
+  props: {
+    dir: {
+      type: String,
+      required: !1,
+      default: "ltr"
+    },
+    locale: {
+      type: String,
+      required: !1,
+      default: "en"
+    },
+    scrollBody: {
+      type: [Boolean, Object],
+      required: !1,
+      default: !0
+    },
+    nonce: {
+      type: String,
+      required: !1,
+      default: void 0
+    },
+    teleportTo: {
+      type: null,
+      required: !1,
+      default: void 0
+    },
+    useId: {
+      type: Function,
+      required: !1,
+      default: void 0
+    }
+  },
+  setup(r) {
+    const e = r, { dir: t, locale: o, scrollBody: i, nonce: d, teleportTo: n } = a(e);
+    return p({
+      dir: t,
+      locale: o,
+      scrollBody: i,
+      nonce: d,
+      teleportTo: n,
+      useId: e.useId
+    }), (l, v) => s(l.$slots, "default");
+  }
+}), y = c;
+export {
+  y as ConfigProvider_default,
+  C as injectConfigProviderContext
+};

package/dist/modules/vendor/reka-ui/dist/ContextMenu/ContextMenuCheckboxItem.js

@@ -0,0 +1,43 @@
+import { useEmitAsProps as p } from "../shared/useEmitAsProps.js";
+import { useForwardExpose as i } from "../shared/useForwardExpose.js";
+import { MenuCheckboxItem_default as m } from "../Menu/MenuCheckboxItem.js";
+import { defineComponent as d, openBlock as f, createBlock as c, unref as e, normalizeProps as t, guardReactiveProps as o, withCtx as _, renderSlot as x } from "vue";
+var C = /* @__PURE__ */ d({
+  __name: "ContextMenuCheckboxItem",
+  props: {
+    modelValue: {
+      type: [Boolean, String],
+      required: !1
+    },
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select", "update:modelValue"],
+  setup(r, { emit: s }) {
+    const a = r, u = p(s);
+    return i(), (l, k) => (f(), c(e(m), t(o({
+      ...a,
+      ...e(u)
+    })), {
+      default: _((n) => [x(l.$slots, "default", t(o(n)))]),
+      _: 3
+    }, 16));
+  }
+}), B = C;
+export {
+  B as ContextMenuCheckboxItem_default
+};

package/dist/modules/vendor/reka-ui/dist/ContextMenu/ContextMenuContent.js

@@ -0,0 +1,132 @@
+import { useForwardExpose as u } from "../shared/useForwardExpose.js";
+import { useForwardPropsEmits as p } from "../shared/useForwardPropsEmits.js";
+import { omitEntryFocusListener as d } from "../Menu/utils.js";
+import { MenuContent_default as f } from "../Menu/MenuContent.js";
+import { injectContextMenuRootContext as m } from "./ContextMenuRoot.js";
+import { defineComponent as c, ref as y, openBlock as g, createBlock as h, unref as t, mergeProps as v, withCtx as q, renderSlot as C } from "vue";
+var k = /* @__PURE__ */ c({
+  inheritAttrs: !1,
+  __name: "ContextMenuContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: !1
+    },
+    loop: {
+      type: Boolean,
+      required: !1
+    },
+    memoDependencies: {
+      type: Array,
+      required: !1
+    },
+    sideFlip: {
+      type: Boolean,
+      required: !1
+    },
+    alignOffset: {
+      type: Number,
+      required: !1,
+      default: 0
+    },
+    alignFlip: {
+      type: Boolean,
+      required: !1
+    },
+    avoidCollisions: {
+      type: Boolean,
+      required: !1,
+      default: !0
+    },
+    collisionBoundary: {
+      type: null,
+      required: !1,
+      default: () => []
+    },
+    collisionPadding: {
+      type: [Number, Object],
+      required: !1,
+      default: 0
+    },
+    hideShiftedArrow: {
+      type: Boolean,
+      required: !1
+    },
+    sticky: {
+      type: String,
+      required: !1,
+      default: "partial"
+    },
+    hideWhenDetached: {
+      type: Boolean,
+      required: !1,
+      default: !1
+    },
+    positionStrategy: {
+      type: String,
+      required: !1
+    },
+    disableUpdateOnLayoutShift: {
+      type: Boolean,
+      required: !1
+    },
+    prioritizePosition: {
+      type: Boolean,
+      required: !1
+    },
+    reference: {
+      type: null,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(n, { emit: l }) {
+    const s = p(n, l);
+    u();
+    const a = m(), o = y(!1);
+    return (i, r) => (g(), h(t(f), v({
+      side: "right",
+      "side-offset": 2,
+      align: "start",
+      "update-position-strategy": "always",
+      style: {
+        "--reka-context-menu-content-transform-origin": "var(--reka-popper-transform-origin)",
+        "--reka-context-menu-content-available-width": "var(--reka-popper-available-width)",
+        "--reka-context-menu-content-available-height": "var(--reka-popper-available-height)",
+        "--reka-context-menu-trigger-width": "var(--reka-popper-anchor-width)",
+        "--reka-context-menu-trigger-height": "var(--reka-popper-anchor-height)"
+      }
+    }, {
+      ...t(s),
+      ...t(d)(i.$attrs)
+    }, {
+      onCloseAutoFocus: r[0] || (r[0] = (e) => {
+        !e.defaultPrevented && o.value && e.preventDefault(), o.value = !1;
+      }),
+      onInteractOutside: r[1] || (r[1] = (e) => {
+        e.detail.originalEvent.button === 2 && e.target === t(a).triggerElement.value && e.preventDefault(), !e.defaultPrevented && !t(a).modal.value && (o.value = !0);
+      })
+    }), {
+      default: q(() => [C(i.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), D = k;
+export {
+  D as ContextMenuContent_default
+};

package/dist/modules/vendor/reka-ui/dist/ContextMenu/ContextMenuItem.js

@@ -0,0 +1,39 @@
+import { useEmitAsProps as a } from "../shared/useEmitAsProps.js";
+import { useForwardExpose as n } from "../shared/useForwardExpose.js";
+import { MenuItem_default as p } from "../Menu/MenuItem.js";
+import { defineComponent as l, openBlock as i, createBlock as m, unref as e, normalizeProps as d, guardReactiveProps as f, withCtx as _, renderSlot as c } from "vue";
+var x = /* @__PURE__ */ l({
+  __name: "ContextMenuItem",
+  props: {
+    disabled: {
+      type: Boolean,
+      required: !1
+    },
+    textValue: {
+      type: String,
+      required: !1
+    },
+    asChild: {
+      type: Boolean,
+      required: !1
+    },
+    as: {
+      type: null,
+      required: !1
+    }
+  },
+  emits: ["select"],
+  setup(t, { emit: r }) {
+    const o = t, s = a(r);
+    return n(), (u, v) => (i(), m(e(p), d(f({
+      ...o,
+      ...e(s)
+    })), {
+      default: _(() => [c(u.$slots, "default")]),
+      _: 3
+    }, 16));
+  }
+}), M = x;
+export {
+  M as ContextMenuItem_default
+};

package/dist/modules/vendor/reka-ui/dist/ContextMenu/ContextMenuItemIndicator.js

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

package/dist/modules/vendor/reka-ui/dist/ContextMenu/ContextMenuPortal.js

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