@pibit.ai/cure-design-system 0.3.8 → 0.3.10

package/dist/node_modules/@react-aria/ssr/dist/SSRProvider.js

@@ -0,0 +1,49 @@
+import a, { useContext as s, useState as l, useRef as f } from "react";
+const c = {
+  prefix: String(Math.round(Math.random() * 1e10)),
+  current: 0
+}, $ = /* @__PURE__ */ a.createContext(c), p = /* @__PURE__ */ a.createContext(!1);
+let v = !!(typeof window < "u" && window.document && window.document.createElement), d = /* @__PURE__ */ new WeakMap();
+function S(t = !1) {
+  let e = s($), r = f(null);
+  if (r.current === null && !t) {
+    var n, u;
+    let o = (u = a.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || u === void 0 || (n = u.ReactCurrentOwner) === null || n === void 0 ? void 0 : n.current;
+    if (o) {
+      let i = d.get(o);
+      i == null ? d.set(o, {
+        id: e.current,
+        state: o.memoizedState
+      }) : o.memoizedState !== i.state && (e.current = i.id, d.delete(o));
+    }
+    r.current = ++e.current;
+  }
+  return r.current;
+}
+function x(t) {
+  let e = s($);
+  e === c && !v && process.env.NODE_ENV !== "production" && console.warn("When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.");
+  let r = S(!!t), n = e === c && process.env.NODE_ENV === "test" ? "react-aria" : `react-aria${e.prefix}`;
+  return t || `${n}-${r}`;
+}
+function b(t) {
+  let e = a.useId(), [r] = l(y()), n = r || process.env.NODE_ENV === "test" ? "react-aria" : `react-aria${c.prefix}`;
+  return t || `${n}-${e}`;
+}
+a.useId;
+function m() {
+  return !1;
+}
+function w() {
+  return !0;
+}
+function g(t) {
+  return () => {
+  };
+}
+function y() {
+  return typeof a.useSyncExternalStore == "function" ? a.useSyncExternalStore(g, m, w) : s(p);
+}
+export {
+  y as useIsSSR
+};

package/dist/node_modules/@react-aria/utils/dist/DOMFunctions.js

@@ -0,0 +1,27 @@
+import { isShadowRoot as f } from "./domHelpers.js";
+import { shadowDOM as o } from "../../../@react-stately/flags/dist/import.js";
+function n(t, a) {
+  if (!o()) return a && t ? t.contains(a) : !1;
+  if (!t || !a) return !1;
+  let e = a;
+  for (; e !== null; ) {
+    if (e === t) return !0;
+    e.tagName === "SLOT" && e.assignedSlot ? e = e.assignedSlot.parentNode : f(e) ? e = e.host : e = e.parentNode;
+  }
+  return !1;
+}
+const s = (t = document) => {
+  var a;
+  if (!o()) return t.activeElement;
+  let e = t.activeElement;
+  for (; e && "shadowRoot" in e && (!((a = e.shadowRoot) === null || a === void 0) && a.activeElement); ) e = e.shadowRoot.activeElement;
+  return e;
+};
+function d(t) {
+  return o() && t.target.shadowRoot && t.composedPath ? t.composedPath()[0] : t.target;
+}
+export {
+  s as getActiveElement,
+  d as getEventTarget,
+  n as nodeContains
+};

package/dist/node_modules/@react-aria/utils/dist/ShadowTreeWalker.js

@@ -0,0 +1,130 @@
+import { nodeContains as l } from "./DOMFunctions.js";
+import { shadowDOM as h } from "../../../@react-stately/flags/dist/import.js";
+class u {
+  get currentNode() {
+    return this._currentNode;
+  }
+  set currentNode(t) {
+    if (!l(this.root, t)) throw new Error("Cannot set currentNode to a node that is not contained by the root node.");
+    const e = [];
+    let r = t, o = t;
+    for (this._currentNode = t; r && r !== this.root; ) if (r.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+      const s = r, n = this._doc.createTreeWalker(s, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      e.push(n), n.currentNode = o, this._currentSetFor.add(n), r = o = s.host;
+    } else r = r.parentNode;
+    const i = this._doc.createTreeWalker(this.root, this.whatToShow, {
+      acceptNode: this._acceptNode
+    });
+    e.push(i), i.currentNode = o, this._currentSetFor.add(i), this._walkerStack = e;
+  }
+  get doc() {
+    return this._doc;
+  }
+  firstChild() {
+    let t = this.currentNode, e = this.nextNode();
+    return l(t, e) ? (e && (this.currentNode = e), e) : (this.currentNode = t, null);
+  }
+  lastChild() {
+    let e = this._walkerStack[0].lastChild();
+    return e && (this.currentNode = e), e;
+  }
+  nextNode() {
+    const t = this._walkerStack[0].nextNode();
+    if (t) {
+      if (t.shadowRoot) {
+        var e;
+        let o;
+        if (typeof this.filter == "function" ? o = this.filter(t) : !((e = this.filter) === null || e === void 0) && e.acceptNode && (o = this.filter.acceptNode(t)), o === NodeFilter.FILTER_ACCEPT)
+          return this.currentNode = t, t;
+        let i = this.nextNode();
+        return i && (this.currentNode = i), i;
+      }
+      return t && (this.currentNode = t), t;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let r = this.nextNode();
+      return r && (this.currentNode = r), r;
+    } else return null;
+  }
+  previousNode() {
+    const t = this._walkerStack[0];
+    if (t.currentNode === t.root) {
+      if (this._currentSetFor.has(t))
+        if (this._currentSetFor.delete(t), this._walkerStack.length > 1) {
+          this._walkerStack.shift();
+          let o = this.previousNode();
+          return o && (this.currentNode = o), o;
+        } else return null;
+      return null;
+    }
+    const e = t.previousNode();
+    if (e) {
+      if (e.shadowRoot) {
+        var r;
+        let i;
+        if (typeof this.filter == "function" ? i = this.filter(e) : !((r = this.filter) === null || r === void 0) && r.acceptNode && (i = this.filter.acceptNode(e)), i === NodeFilter.FILTER_ACCEPT)
+          return e && (this.currentNode = e), e;
+        let s = this.lastChild();
+        return s && (this.currentNode = s), s;
+      }
+      return e && (this.currentNode = e), e;
+    } else if (this._walkerStack.length > 1) {
+      this._walkerStack.shift();
+      let o = this.previousNode();
+      return o && (this.currentNode = o), o;
+    } else return null;
+  }
+  /**
+   * @deprecated
+   */
+  nextSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  previousSibling() {
+    return null;
+  }
+  /**
+   * @deprecated
+   */
+  parentNode() {
+    return null;
+  }
+  constructor(t, e, r, o) {
+    this._walkerStack = [], this._currentSetFor = /* @__PURE__ */ new Set(), this._acceptNode = (s) => {
+      if (s.nodeType === Node.ELEMENT_NODE) {
+        const d = s.shadowRoot;
+        if (d) {
+          const a = this._doc.createTreeWalker(d, this.whatToShow, {
+            acceptNode: this._acceptNode
+          });
+          return this._walkerStack.unshift(a), NodeFilter.FILTER_ACCEPT;
+        } else {
+          var n;
+          if (typeof this.filter == "function") return this.filter(s);
+          if (!((n = this.filter) === null || n === void 0) && n.acceptNode) return this.filter.acceptNode(s);
+          if (this.filter === null) return NodeFilter.FILTER_ACCEPT;
+        }
+      }
+      return NodeFilter.FILTER_SKIP;
+    }, this._doc = t, this.root = e, this.filter = o ?? null, this.whatToShow = r ?? NodeFilter.SHOW_ALL, this._currentNode = e, this._walkerStack.unshift(t.createTreeWalker(e, r, this._acceptNode));
+    const i = e.shadowRoot;
+    if (i) {
+      const s = this._doc.createTreeWalker(i, this.whatToShow, {
+        acceptNode: this._acceptNode
+      });
+      this._walkerStack.unshift(s);
+    }
+  }
+}
+function w(c, t, e, r) {
+  return h() ? new u(c, t, e, r) : c.createTreeWalker(t, e, r);
+}
+export {
+  u as ShadowTreeWalker,
+  w as createShadowTreeWalker
+};

package/dist/node_modules/@react-aria/utils/dist/domHelpers.js

@@ -0,0 +1,15 @@
+const t = (o) => {
+  var n;
+  return (n = o == null ? void 0 : o.ownerDocument) !== null && n !== void 0 ? n : document;
+}, e = (o) => o && "window" in o && o.window === o ? o : t(o).defaultView || window;
+function d(o) {
+  return o !== null && typeof o == "object" && "nodeType" in o && typeof o.nodeType == "number";
+}
+function c(o) {
+  return d(o) && o.nodeType === Node.DOCUMENT_FRAGMENT_NODE && "host" in o;
+}
+export {
+  t as getOwnerDocument,
+  e as getOwnerWindow,
+  c as isShadowRoot
+};

package/dist/node_modules/@react-aria/utils/dist/focusWithoutScrolling.js

@@ -0,0 +1,45 @@
+function f(l) {
+  if (c()) l.focus({
+    preventScroll: !0
+  });
+  else {
+    let e = n(l);
+    l.focus(), s(e);
+  }
+}
+let r = null;
+function c() {
+  if (r == null) {
+    r = !1;
+    try {
+      document.createElement("div").focus({
+        get preventScroll() {
+          return r = !0, !0;
+        }
+      });
+    } catch {
+    }
+  }
+  return r;
+}
+function n(l) {
+  let e = l.parentNode, o = [], t = document.scrollingElement || document.documentElement;
+  for (; e instanceof HTMLElement && e !== t; )
+    (e.offsetHeight < e.scrollHeight || e.offsetWidth < e.scrollWidth) && o.push({
+      element: e,
+      scrollTop: e.scrollTop,
+      scrollLeft: e.scrollLeft
+    }), e = e.parentNode;
+  return t instanceof HTMLElement && o.push({
+    element: t,
+    scrollTop: t.scrollTop,
+    scrollLeft: t.scrollLeft
+  }), o;
+}
+function s(l) {
+  for (let { element: e, scrollTop: o, scrollLeft: t } of l)
+    e.scrollTop = o, e.scrollLeft = t;
+}
+export {
+  f as focusWithoutScrolling
+};

package/dist/node_modules/@react-aria/utils/dist/isElementVisible.js

@@ -0,0 +1,25 @@
+import { getOwnerWindow as d } from "./domHelpers.js";
+const c = typeof Element < "u" && "checkVisibility" in Element.prototype;
+function p(i) {
+  const t = d(i);
+  if (!(i instanceof t.HTMLElement) && !(i instanceof t.SVGElement)) return !1;
+  let { display: o, visibility: e } = i.style, a = o !== "none" && e !== "hidden" && e !== "collapse";
+  if (a) {
+    const { getComputedStyle: r } = i.ownerDocument.defaultView;
+    let { display: n, visibility: s } = r(i);
+    a = n !== "none" && s !== "hidden" && s !== "collapse";
+  }
+  return a;
+}
+function u(i, t) {
+  return !i.hasAttribute("hidden") && // Ignore HiddenSelect when tree walking.
+  !i.hasAttribute("data-react-aria-prevent-focus") && (i.nodeName === "DETAILS" && t && t.nodeName !== "SUMMARY" ? i.hasAttribute("open") : !0);
+}
+function f(i, t) {
+  return c ? i.checkVisibility({
+    visibilityProperty: !0
+  }) && !i.closest("[data-react-aria-prevent-focus]") : i.nodeName !== "#comment" && p(i) && u(i, t) && (!i.parentElement || f(i.parentElement, i));
+}
+export {
+  f as isElementVisible
+};

package/dist/node_modules/@react-aria/utils/dist/isFocusable.js

@@ -0,0 +1,37 @@
+import { isElementVisible as n } from "./isElementVisible.js";
+const t = [
+  "input:not([disabled]):not([type=hidden])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "button:not([disabled])",
+  "a[href]",
+  "area[href]",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "audio[controls]",
+  "video[controls]",
+  '[contenteditable]:not([contenteditable^="false"])',
+  "permission"
+], o = t.join(":not([hidden]),") + ",[tabindex]:not([disabled]):not([hidden])";
+t.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
+const i = t.join(':not([hidden]):not([tabindex="-1"]),');
+function r(b) {
+  return b.matches(o) && n(b) && !a(b);
+}
+function s(b) {
+  return b.matches(i) && n(b) && !a(b);
+}
+function a(b) {
+  let e = b;
+  for (; e != null; ) {
+    if (e instanceof e.ownerDocument.defaultView.HTMLElement && e.inert) return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+export {
+  r as isFocusable,
+  s as isTabbable
+};

package/dist/node_modules/@react-aria/utils/dist/isVirtualEvent.js

@@ -0,0 +1,7 @@
+import { isAndroid as i } from "./platform.js";
+function o(r) {
+  return r.pointerType === "" && r.isTrusted ? !0 : i() && r.pointerType ? r.type === "click" && r.buttons === 1 : r.detail === 0 && !r.pointerType;
+}
+export {
+  o as isVirtualClick
+};

package/dist/node_modules/@react-aria/utils/dist/openLink.js

@@ -0,0 +1,28 @@
+import { focusWithoutScrolling as f } from "./focusWithoutScrolling.js";
+import { isFirefox as p, isWebKit as K, isMac as l, isIPad as $ } from "./platform.js";
+import "react";
+function o(e, c, d = !0) {
+  var t, a;
+  let { metaKey: i, ctrlKey: n, altKey: s, shiftKey: r } = c;
+  p() && (!((a = window.event) === null || a === void 0 || (t = a.type) === null || t === void 0) && t.startsWith("key")) && e.target === "_blank" && (l() ? i = !0 : n = !0);
+  let y = K() && l() && !$() && process.env.NODE_ENV !== "test" ? new KeyboardEvent("keydown", {
+    keyIdentifier: "Enter",
+    metaKey: i,
+    ctrlKey: n,
+    altKey: s,
+    shiftKey: r
+  }) : new MouseEvent("click", {
+    metaKey: i,
+    ctrlKey: n,
+    altKey: s,
+    shiftKey: r,
+    detail: 1,
+    bubbles: !0,
+    cancelable: !0
+  });
+  o.isOpening = d, f(e), e.dispatchEvent(y), o.isOpening = !1;
+}
+o.isOpening = !1;
+export {
+  o as openLink
+};

package/dist/node_modules/@react-aria/utils/dist/platform.js

@@ -0,0 +1,47 @@
+function a(t) {
+  var n;
+  if (typeof window > "u" || window.navigator == null) return !1;
+  let o = (n = window.navigator.userAgentData) === null || n === void 0 ? void 0 : n.brands;
+  return Array.isArray(o) && o.some((s) => t.test(s.brand)) || t.test(window.navigator.userAgent);
+}
+function r(t) {
+  var n;
+  return typeof window < "u" && window.navigator != null ? t.test(((n = window.navigator.userAgentData) === null || n === void 0 ? void 0 : n.platform) || window.navigator.platform) : !1;
+}
+function e(t) {
+  if (process.env.NODE_ENV === "test") return t;
+  let n = null;
+  return () => (n == null && (n = t()), n);
+}
+const i = e(function() {
+  return r(/^Mac/i);
+}), c = e(function() {
+  return r(/^iPhone/i);
+}), u = e(function() {
+  return r(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  i() && navigator.maxTouchPoints > 1;
+}), d = e(function() {
+  return c() || u();
+});
+e(function() {
+  return i() || d();
+});
+const f = e(function() {
+  return a(/AppleWebKit/i) && !$();
+}), $ = e(function() {
+  return a(/Chrome/i);
+}), l = e(function() {
+  return a(/Android/i);
+}), w = e(function() {
+  return a(/Firefox/i);
+});
+export {
+  l as isAndroid,
+  $ as isChrome,
+  w as isFirefox,
+  d as isIOS,
+  u as isIPad,
+  c as isIPhone,
+  i as isMac,
+  f as isWebKit
+};

package/dist/node_modules/@react-aria/utils/dist/runAfterTransition.js

@@ -0,0 +1,35 @@
+let r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set();
+function o() {
+  if (typeof window > "u") return;
+  function t(e) {
+    return "propertyName" in e;
+  }
+  let d = (e) => {
+    if (!t(e) || !e.target) return;
+    let n = r.get(e.target);
+    n || (n = /* @__PURE__ */ new Set(), r.set(e.target, n), e.target.addEventListener("transitioncancel", i, {
+      once: !0
+    })), n.add(e.propertyName);
+  }, i = (e) => {
+    if (!t(e) || !e.target) return;
+    let n = r.get(e.target);
+    if (n && (n.delete(e.propertyName), n.size === 0 && (e.target.removeEventListener("transitioncancel", i), r.delete(e.target)), r.size === 0)) {
+      for (let s of a) s();
+      a.clear();
+    }
+  };
+  document.body.addEventListener("transitionrun", d), document.body.addEventListener("transitionend", i);
+}
+typeof document < "u" && (document.readyState !== "loading" ? o() : document.addEventListener("DOMContentLoaded", o));
+function c() {
+  for (const [t] of r)
+    "isConnected" in t && !t.isConnected && r.delete(t);
+}
+function f(t) {
+  requestAnimationFrame(() => {
+    c(), r.size === 0 ? t() : a.add(t);
+  });
+}
+export {
+  f as runAfterTransition
+};

package/dist/node_modules/@react-aria/utils/dist/useLayoutEffect.js

@@ -0,0 +1,6 @@
+import e from "react";
+const f = typeof document < "u" ? e.useLayoutEffect : () => {
+};
+export {
+  f as useLayoutEffect
+};

package/dist/node_modules/@react-stately/data/dist/useListData.js

@@ -0,0 +1,212 @@
+import { useState as K, useMemo as x } from "react";
+function g(s) {
+  let { initialItems: f = [], initialSelectedKeys: d, getKey: r = (o) => {
+    var m;
+    return (m = o.id) !== null && m !== void 0 ? m : o.key;
+  }, filter: t, initialFilterText: e = "" } = s, [l, i] = K({
+    items: f,
+    selectedKeys: d === "all" ? "all" : new Set(d || []),
+    filterText: e
+  }), n = x(() => t ? l.items.filter((o) => t(o, l.filterText)) : l.items, [
+    l.items,
+    l.filterText,
+    t
+  ]);
+  return {
+    ...l,
+    items: n,
+    ...S({
+      getKey: r
+    }, i),
+    getItem(o) {
+      return l.items.find((m) => r(m) === o);
+    }
+  };
+}
+function S(s, f) {
+  let { cursor: d, getKey: r } = s;
+  return {
+    setSelectedKeys(t) {
+      f((e) => ({
+        ...e,
+        selectedKeys: t
+      }));
+    },
+    addKeysToSelection(t) {
+      f((e) => e.selectedKeys === "all" ? e : t === "all" ? {
+        ...e,
+        selectedKeys: "all"
+      } : {
+        ...e,
+        selectedKeys: /* @__PURE__ */ new Set([
+          ...e.selectedKeys,
+          ...t
+        ])
+      });
+    },
+    removeKeysFromSelection(t) {
+      f((e) => {
+        if (t === "all") return {
+          ...e,
+          selectedKeys: /* @__PURE__ */ new Set()
+        };
+        let l = e.selectedKeys === "all" ? new Set(e.items.map(r)) : new Set(e.selectedKeys);
+        for (let i of t) l.delete(i);
+        return {
+          ...e,
+          selectedKeys: l
+        };
+      });
+    },
+    setFilterText(t) {
+      f((e) => ({
+        ...e,
+        filterText: t
+      }));
+    },
+    insert(t, ...e) {
+      f((l) => u(l, t, ...e));
+    },
+    insertBefore(t, ...e) {
+      f((l) => {
+        let i = l.items.findIndex((n) => (r == null ? void 0 : r(n)) === t);
+        if (i === -1)
+          if (l.items.length === 0) i = 0;
+          else return l;
+        return u(l, i, ...e);
+      });
+    },
+    insertAfter(t, ...e) {
+      f((l) => {
+        let i = l.items.findIndex((n) => (r == null ? void 0 : r(n)) === t);
+        if (i === -1)
+          if (l.items.length === 0) i = 0;
+          else return l;
+        return u(l, i + 1, ...e);
+      });
+    },
+    prepend(...t) {
+      f((e) => u(e, 0, ...t));
+    },
+    append(...t) {
+      f((e) => u(e, e.items.length, ...t));
+    },
+    remove(...t) {
+      f((e) => {
+        let l = new Set(t), i = e.items.filter((o) => !l.has(r(o))), n = "all";
+        if (e.selectedKeys !== "all") {
+          n = new Set(e.selectedKeys);
+          for (let o of t) n.delete(o);
+        }
+        return d == null && i.length === 0 && (n = /* @__PURE__ */ new Set()), {
+          ...e,
+          items: i,
+          selectedKeys: n
+        };
+      });
+    },
+    removeSelectedItems() {
+      f((t) => {
+        if (t.selectedKeys === "all") return {
+          ...t,
+          items: [],
+          selectedKeys: /* @__PURE__ */ new Set()
+        };
+        let e = t.selectedKeys, l = t.items.filter((i) => !e.has(r(i)));
+        return {
+          ...t,
+          items: l,
+          selectedKeys: /* @__PURE__ */ new Set()
+        };
+      });
+    },
+    move(t, e) {
+      f((l) => {
+        let i = l.items.findIndex((m) => r(m) === t);
+        if (i === -1) return l;
+        let n = l.items.slice(), [o] = n.splice(i, 1);
+        return n.splice(e, 0, o), {
+          ...l,
+          items: n
+        };
+      });
+    },
+    moveBefore(t, e) {
+      f((l) => {
+        let i = l.items.findIndex((m) => r(m) === t);
+        if (i === -1) return l;
+        let o = (Array.isArray(e) ? e : [
+          ...e
+        ]).map((m) => l.items.findIndex((c) => r(c) === m)).sort((m, c) => m - c);
+        return y(l, o, i);
+      });
+    },
+    moveAfter(t, e) {
+      f((l) => {
+        let i = l.items.findIndex((m) => r(m) === t);
+        if (i === -1) return l;
+        let o = (Array.isArray(e) ? e : [
+          ...e
+        ]).map((m) => l.items.findIndex((c) => r(c) === m)).sort((m, c) => m - c);
+        return y(l, o, i + 1);
+      });
+    },
+    update(t, e) {
+      f((l) => {
+        let i = l.items.findIndex((o) => r(o) === t);
+        if (i === -1) return l;
+        let n;
+        return typeof e == "function" ? n = e(l.items[i]) : n = e, {
+          ...l,
+          items: [
+            ...l.items.slice(0, i),
+            n,
+            ...l.items.slice(i + 1)
+          ]
+        };
+      });
+    }
+  };
+}
+function u(s, f, ...d) {
+  return {
+    ...s,
+    items: [
+      ...s.items.slice(0, f),
+      ...d,
+      ...s.items.slice(f)
+    ]
+  };
+}
+function y(s, f, d) {
+  d -= f.filter((e) => e < d).length;
+  let r = f.map((e) => ({
+    from: e,
+    to: d++
+  }));
+  for (let e = 0; e < r.length; e++) {
+    let l = r[e].from;
+    for (let i = e; i < r.length; i++)
+      r[i].from > l && r[i].from--;
+  }
+  for (let e = 0; e < r.length; e++) {
+    let l = r[e];
+    for (let i = r.length - 1; i > e; i--) {
+      let n = r[i];
+      n.from < l.to ? l.to++ : n.from++;
+    }
+  }
+  let t = s.items.slice();
+  for (let e of r) {
+    let [l] = t.splice(e.from, 1);
+    t.splice(e.to, 0, l);
+  }
+  return {
+    ...s,
+    items: t
+  };
+}
+export {
+  S as createListActions,
+  g as useListData
+};

package/dist/node_modules/@react-stately/flags/dist/import.js

@@ -0,0 +1,7 @@
+let e = !1;
+function f() {
+  return e;
+}
+export {
+  f as shadowDOM
+};