@ledgerhq/lumen-ui-react 0.1.14 → 0.1.15

package/dist/node_modules/@base-ui/react/esm/utils/useRenderElement.js

@@ -0,0 +1,71 @@
+import b from "../../../utils/esm/formatErrorMessage.js";
+import * as c from "react";
+import { createElement as p } from "react";
+import { useMergedRefs as y, useMergedRefsN as g } from "../../../utils/esm/useMergedRefs.js";
+import { getReactElementRef as h } from "../../../utils/esm/getReactElementRef.js";
+import { mergeObjects as E } from "../../../utils/esm/mergeObjects.js";
+import { warn as P } from "../../../utils/esm/warn.js";
+import { getStateAttributesProps as w } from "./getStateAttributesProps.js";
+import { resolveClassName as v } from "./resolveClassName.js";
+import { resolveStyle as C } from "./resolveStyle.js";
+import { EMPTY_OBJECT as a } from "../../../utils/esm/empty.js";
+import { mergePropsN as A, mergeClassNames as k, mergeProps as T } from "../merge-props/mergeProps.js";
+function J(r, e, t = {}) {
+  const l = e.render, s = _(e, t);
+  if (t.enabled === !1)
+    return null;
+  const n = t.state ?? a;
+  return M(r, l, s, n);
+}
+function _(r, e = {}) {
+  const {
+    className: t,
+    style: l,
+    render: s
+  } = r, {
+    state: n = a,
+    ref: f,
+    props: m,
+    stateAttributesMapping: N,
+    enabled: i = !0
+  } = e, d = i ? v(t, n) : void 0, u = i ? C(l, n) : void 0, R = i ? w(n, N) : a, o = i ? E(R, Array.isArray(m) ? A(m) : m) ?? a : a;
+  return typeof document < "u" && (i ? Array.isArray(f) ? o.ref = g([o.ref, h(s), ...f]) : o.ref = y(o.ref, h(s), f) : y(null, null)), i ? (d !== void 0 && (o.className = k(o.className, d)), u !== void 0 && (o.style = E(o.style, u)), o) : a;
+}
+const I = /* @__PURE__ */ Symbol.for("react.lazy");
+function M(r, e, t, l) {
+  if (e) {
+    if (typeof e == "function")
+      return process.env.NODE_ENV !== "production" && O(e), e(t, l);
+    const s = T(t, e.props);
+    s.ref = t.ref;
+    let n = e;
+    if (n?.$$typeof === I && (n = c.Children.toArray(e)[0]), process.env.NODE_ENV !== "production" && !/* @__PURE__ */ c.isValidElement(n))
+      throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join(`
+`));
+    return /* @__PURE__ */ c.cloneElement(n, s);
+  }
+  if (r && typeof r == "string")
+    return V(r, t);
+  throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : b(8));
+}
+function O(r) {
+  const e = r.name;
+  if (e.length === 0)
+    return;
+  const t = e.charCodeAt(0);
+  t < 65 || t > 90 || P(`The \`render\` prop received a function named \`${e}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
+}
+function V(r, e) {
+  return r === "button" ? /* @__PURE__ */ p("button", {
+    type: "button",
+    ...e,
+    key: e.key
+  }) : r === "img" ? /* @__PURE__ */ p("img", {
+    alt: "",
+    ...e,
+    key: e.key
+  }) : /* @__PURE__ */ c.createElement(r, e);
+}
+export {
+  J as useRenderElement
+};

package/dist/node_modules/@base-ui/react/esm/utils/useTransitionStatus.js

@@ -0,0 +1,42 @@
+import * as c from "react";
+import { useIsoLayoutEffect as d } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { AnimationFrame as u } from "../../../utils/esm/useAnimationFrame.js";
+function g(t, s = !1, f = !1) {
+  const [n, r] = c.useState(t && s ? "idle" : void 0), [i, a] = c.useState(t);
+  return t && !i && (a(!0), r("starting")), !t && i && n !== "ending" && !f && r("ending"), !t && !i && n === "ending" && r(void 0), d(() => {
+    if (!t && i && n !== "ending" && f) {
+      const e = u.request(() => {
+        r("ending");
+      });
+      return () => {
+        u.cancel(e);
+      };
+    }
+  }, [t, i, n, f]), d(() => {
+    if (!t || s)
+      return;
+    const e = u.request(() => {
+      r(void 0);
+    });
+    return () => {
+      u.cancel(e);
+    };
+  }, [s, t]), d(() => {
+    if (!t || !s)
+      return;
+    t && i && n !== "idle" && r("starting");
+    const e = u.request(() => {
+      r("idle");
+    });
+    return () => {
+      u.cancel(e);
+    };
+  }, [s, t, i, r, n]), c.useMemo(() => ({
+    mounted: i,
+    setMounted: a,
+    transitionStatus: n
+  }), [i, n]);
+}
+export {
+  g as useTransitionStatus
+};

package/dist/node_modules/@base-ui/react/esm/utils/useValueChanged.js

@@ -0,0 +1,14 @@
+import * as c from "react";
+import { useIsoLayoutEffect as o } from "../../../utils/esm/useIsoLayoutEffect.js";
+import { useStableCallback as f } from "../../../utils/esm/useStableCallback.js";
+function u(r, n) {
+  const t = c.useRef(r), e = f(n);
+  o(() => {
+    t.current !== r && e(t.current);
+  }, [r, e]), o(() => {
+    t.current = r;
+  }, [r]);
+}
+export {
+  u as useValueChanged
+};

package/dist/node_modules/@base-ui/utils/esm/detectBrowser.js

@@ -0,0 +1,43 @@
+const a = typeof navigator < "u", o = s(), r = f(), n = u(), c = typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter:none"), m = (
+  // iPads can claim to be MacIntel
+  o.platform === "MacIntel" && o.maxTouchPoints > 1 ? !0 : /iP(hone|ad|od)|iOS/.test(o.platform)
+), p = a && /apple/i.test(navigator.vendor), g = a && /android/i.test(r) || /android/i.test(n);
+a && r.toLowerCase().startsWith("mac") && navigator.maxTouchPoints;
+const d = n.includes("jsdom/");
+function s() {
+  if (!a)
+    return {
+      platform: "",
+      maxTouchPoints: -1
+    };
+  const t = navigator.userAgentData;
+  return t?.platform ? {
+    platform: t.platform,
+    maxTouchPoints: navigator.maxTouchPoints
+  } : {
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? -1
+  };
+}
+function u() {
+  if (!a)
+    return "";
+  const t = navigator.userAgentData;
+  return t && Array.isArray(t.brands) ? t.brands.map(({
+    brand: i,
+    version: e
+  }) => `${i}/${e}`).join(" ") : navigator.userAgent;
+}
+function f() {
+  if (!a)
+    return "";
+  const t = navigator.userAgentData;
+  return t?.platform ? t.platform : navigator.platform ?? "";
+}
+export {
+  g as isAndroid,
+  m as isIOS,
+  d as isJSDOM,
+  p as isSafari,
+  c as isWebKit
+};

package/dist/node_modules/@base-ui/utils/esm/empty.js

@@ -0,0 +1,7 @@
+function e() {
+}
+const t = Object.freeze({});
+export {
+  t as EMPTY_OBJECT,
+  e as NOOP
+};

package/dist/node_modules/@base-ui/utils/esm/error.js

@@ -0,0 +1,11 @@
+let o;
+process.env.NODE_ENV !== "production" && (o = /* @__PURE__ */ new Set());
+function s(...r) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = r.join(" ");
+    o.has(e) || (o.add(e), console.error(`Base UI: ${e}`));
+  }
+}
+export {
+  s as error
+};

package/dist/node_modules/@base-ui/utils/esm/formatErrorMessage.js

@@ -0,0 +1,11 @@
+function n(a, s) {
+  return function(e, ...t) {
+    const r = new URL(a);
+    return r.searchParams.set("code", e.toString()), t.forEach((o) => r.searchParams.append("args[]", o)), `${s} error #${e}; visit ${r} for the full message.`;
+  };
+}
+const u = n("https://base-ui.com/production-error", "Base UI");
+export {
+  n as createFormatErrorMessage,
+  u as default
+};

package/dist/node_modules/@base-ui/utils/esm/getReactElementRef.js

@@ -0,0 +1,11 @@
+import * as n from "react";
+import { isReactVersionAtLeast as o } from "./reactVersion.js";
+function s(t) {
+  if (!/* @__PURE__ */ n.isValidElement(t))
+    return null;
+  const e = t, r = e.props;
+  return (o(19) ? r?.ref : e.ref) ?? null;
+}
+export {
+  s as getReactElementRef
+};

package/dist/node_modules/@base-ui/utils/esm/inertValue.js

@@ -0,0 +1,7 @@
+import { isReactVersionAtLeast as r } from "./reactVersion.js";
+function n(e) {
+  return r(19) ? e : e ? "true" : void 0;
+}
+export {
+  n as inertValue
+};

package/dist/node_modules/@base-ui/utils/esm/mergeObjects.js

@@ -0,0 +1,14 @@
+function n(e, r) {
+  if (e && !r)
+    return e;
+  if (!e && r)
+    return r;
+  if (e || r)
+    return {
+      ...e,
+      ...r
+    };
+}
+export {
+  n as mergeObjects
+};

package/dist/node_modules/@base-ui/utils/esm/owner.js

@@ -0,0 +1,6 @@
+function e(n) {
+  return n?.ownerDocument || document;
+}
+export {
+  e as ownerDocument
+};

package/dist/node_modules/@base-ui/utils/esm/reactVersion.js

@@ -0,0 +1,8 @@
+import * as t from "react";
+const e = parseInt(t.version, 10);
+function o(r) {
+  return e >= r;
+}
+export {
+  o as isReactVersionAtLeast
+};

package/dist/node_modules/@base-ui/utils/esm/safeReact.js

@@ -0,0 +1,7 @@
+import * as t from "react";
+const a = {
+  ...t
+};
+export {
+  a as SafeReact
+};

package/dist/node_modules/@base-ui/utils/esm/store/ReactStore.js

@@ -0,0 +1,145 @@
+import * as u from "react";
+import { Store as l } from "./Store.js";
+import { useStore as a } from "./useStore.js";
+import { useStableCallback as f } from "../useStableCallback.js";
+import { useIsoLayoutEffect as c } from "../useIsoLayoutEffect.js";
+import { NOOP as h } from "../empty.js";
+class g extends l {
+  /**
+   * Creates a new ReactStore instance.
+   *
+   * @param state Initial state of the store.
+   * @param context Non-reactive context values.
+   * @param selectors Optional selectors for use with `useState`.
+   */
+  constructor(e, t = {}, s) {
+    super(e), this.context = t, this.selectors = s;
+  }
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  /**
+   * Synchronizes a single external value into the store.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValue(e, t) {
+    u.useDebugValue(e), c(() => {
+      this.state[e] !== t && this.set(e, t);
+    }, [e, t]);
+  }
+  /**
+   * Synchronizes a single external value into the store and
+   * cleans it up (sets to `undefined`) on unmount.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValueWithCleanup(e, t) {
+    const s = this;
+    c(() => (s.state[e] !== t && s.set(e, t), () => {
+      s.set(e, void 0);
+    }), [s, e, t]);
+  }
+  /**
+   * Synchronizes multiple external values into the store.
+   *
+   * Note that the while the values in `state` are updated immediately, the values returned
+   * by `useState` are updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValues(e) {
+    const t = this;
+    if (process.env.NODE_ENV !== "production") {
+      u.useDebugValue(e, (r) => Object.keys(r));
+      const o = u.useRef(Object.keys(e)).current, n = Object.keys(e);
+      (o.length !== n.length || o.some((r, i) => r !== n[i])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const s = Object.values(e);
+    c(() => {
+      t.update(e);
+    }, [t, ...s]);
+  }
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+   * is non-undefined, the store's state at `key` is updated to match `controlled`.
+   */
+  useControlledProp(e, t) {
+    u.useDebugValue(e);
+    const s = t !== void 0;
+    if (c(() => {
+      s && !Object.is(this.state[e], t) && super.setState({
+        ...this.state,
+        [e]: t
+      });
+    }, [e, t, s]), process.env.NODE_ENV !== "production") {
+      const o = this.controlledValues ??= /* @__PURE__ */ new Map();
+      o.has(e) || o.set(e, s);
+      const n = o.get(e);
+      n !== void 0 && n !== s && console.error(`A component is changing the ${s ? "" : "un"}controlled state of ${e.toString()} to be ${s ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+  }
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select(e, t, s, o) {
+    const n = this.selectors[e];
+    return n(this.state, t, s, o);
+  }
+  /**
+   * Returns a value from the store's state using a selector function.
+   * Used to subscribe to specific parts of the state.
+   * This methods causes a rerender whenever the selected state changes.
+   *
+   * @param key Key of the selector to use.
+   */
+  useState(e, t, s, o) {
+    return u.useDebugValue(e), a(this, this.selectors[e], t, s, o);
+  }
+  /**
+   * Wraps a function with `useStableCallback` to ensure it has a stable reference
+   * and assigns it to the context.
+   *
+   * @param key Key of the event callback. Must be a function in the context.
+   * @param fn Function to assign.
+   */
+  useContextCallback(e, t) {
+    u.useDebugValue(e);
+    const s = f(t ?? h);
+    this.context[e] = s;
+  }
+  /**
+   * Returns a stable setter function for a specific key in the store's state.
+   * It's commonly used to pass as a ref callback to React elements.
+   *
+   * @param key Key of the state to set.
+   */
+  useStateSetter(e) {
+    const t = u.useRef(void 0);
+    return t.current === void 0 && (t.current = (s) => {
+      this.set(e, s);
+    }), t.current;
+  }
+  /**
+   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+   *
+   * @param key Key of the selector to observe.
+   * @param listener Listener function called when the selector result changes.
+   */
+  observe(e, t) {
+    let s;
+    typeof e == "function" ? s = e : s = this.selectors[e];
+    let o = s(this.state);
+    return t(o, o, this), this.subscribe((n) => {
+      const r = s(n);
+      if (!Object.is(o, r)) {
+        const i = o;
+        o = r, t(r, i, this);
+      }
+    });
+  }
+}
+export {
+  g as ReactStore
+};

package/dist/node_modules/@base-ui/utils/esm/store/Store.js

@@ -0,0 +1,86 @@
+import { useStore as r } from "./useStore.js";
+class n {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+   *
+   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+   */
+  // Internal state to handle recursive `setState()` calls
+  constructor(t) {
+    this.state = t, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  /**
+   * Registers a listener that will be called whenever the store's state changes.
+   *
+   * @param fn The listener function to be called on state changes.
+   * @returns A function to unsubscribe the listener.
+   */
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  /**
+   * Returns the current state of the store.
+   */
+  getSnapshot = () => this.state;
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(t) {
+    if (this.state === t)
+      return;
+    this.state = t, this.updateTick += 1;
+    const s = this.updateTick;
+    for (const e of this.listeners) {
+      if (s !== this.updateTick)
+        return;
+      e(t);
+    }
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   *
+   * @param changes An object containing the changes to apply to the current state.
+   */
+  update(t) {
+    for (const s in t)
+      if (!Object.is(this.state[s], t[s])) {
+        this.setState({
+          ...this.state,
+          ...t
+        });
+        return;
+      }
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   *
+   * @param key The key in the store's state to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(t, s) {
+    Object.is(this.state[t], s) || this.setState({
+      ...this.state,
+      [t]: s
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const t = {
+      ...this.state
+    };
+    this.setState(t);
+  }
+  use(t, s, e, i) {
+    return r(this, t, s, e, i);
+  }
+}
+export {
+  n as Store
+};

package/dist/node_modules/@base-ui/utils/esm/store/createSelector.js

@@ -0,0 +1,25 @@
+import t from "../formatErrorMessage.js";
+import { createSelectorCreator as s, lruMemoize as i } from "../../../../reselect/dist/reselect.js";
+s({
+  memoize: i,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const u = (e, m, c, n, l, p, ...o) => {
+  if (o.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : t(1));
+  let r;
+  if (e)
+    r = e;
+  else
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  return r;
+};
+export {
+  u as createSelector
+};

package/dist/node_modules/@base-ui/utils/esm/store/useStore.js

@@ -0,0 +1,21 @@
+import * as c from "react";
+import { s as u } from "../../../../../_virtual/index.js";
+import { w as i } from "../../../../../_virtual/with-selector.js";
+import { isReactVersionAtLeast as S } from "../reactVersion.js";
+const a = S(19), m = a ? f : l;
+function g(t, e, r, n, o) {
+  return m(t, e, r, n, o);
+}
+function p(t, e, r, n, o) {
+  const s = c.useCallback(() => e(t.getSnapshot(), r, n, o), [t, e, r, n, o]);
+  return u.useSyncExternalStore(t.subscribe, s, s);
+}
+function f(t, e, r, n, o) {
+  return p(t, e, r, n, o);
+}
+function l(t, e, r, n, o) {
+  return i.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, (s) => e(s, r, n, o));
+}
+export {
+  g as useStore
+};

package/dist/node_modules/@base-ui/utils/esm/useAnimationFrame.js

@@ -0,0 +1,68 @@
+import { useRefWithInit as u } from "./useRefWithInit.js";
+import { useOnMount as h } from "./useOnMount.js";
+const s = null;
+let l = globalThis.requestAnimationFrame;
+class o {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (t) => {
+    this.isScheduled = !1;
+    const e = this.callbacks, r = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, r > 0)
+      for (let i = 0; i < e.length; i += 1)
+        e[i]?.(t);
+  };
+  request(t) {
+    const e = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const r = process.env.NODE_ENV !== "production" && l !== requestAnimationFrame && (l = requestAnimationFrame, !0);
+    return (!this.isScheduled || r) && (requestAnimationFrame(this.tick), this.isScheduled = !0), e;
+  }
+  cancel(t) {
+    const e = t - this.startId;
+    e < 0 || e >= this.callbacks.length || (this.callbacks[e] = null, this.callbacksCount -= 1);
+  }
+}
+const c = new o();
+class a {
+  static create() {
+    return new a();
+  }
+  static request(t) {
+    return c.request(t);
+  }
+  static cancel(t) {
+    return c.cancel(t);
+  }
+  currentId = s;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = c.request(() => {
+      this.currentId = s, t();
+    });
+  }
+  cancel = () => {
+    this.currentId !== s && (c.cancel(this.currentId), this.currentId = s);
+  };
+  disposeEffect = () => this.cancel;
+}
+function k() {
+  const n = u(a.create).current;
+  return h(n.disposeEffect), n;
+}
+export {
+  a as AnimationFrame,
+  k as useAnimationFrame
+};

package/dist/node_modules/@base-ui/utils/esm/useEnhancedClickHandler.js

@@ -0,0 +1,19 @@
+import * as e from "react";
+function t(i) {
+  const o = e.useRef(""), n = e.useCallback((r) => {
+    r.defaultPrevented || (o.current = r.pointerType, i(r, r.pointerType));
+  }, [i]);
+  return {
+    onClick: e.useCallback((r) => {
+      if (r.detail === 0) {
+        i(r, "keyboard");
+        return;
+      }
+      "pointerType" in r ? i(r, r.pointerType) : i(r, o.current), o.current = "";
+    }, [i]),
+    onPointerDown: n
+  };
+}
+export {
+  t as useEnhancedClickHandler
+};

package/dist/node_modules/@base-ui/utils/esm/useId.js

@@ -0,0 +1,20 @@
+import * as n from "react";
+import { SafeReact as f } from "./safeReact.js";
+let o = 0;
+function l(u, t = "mui") {
+  const [e, s] = n.useState(u), c = u || e;
+  return n.useEffect(() => {
+    e == null && (o += 1, s(`${t}-${o}`));
+  }, [e, t]), c;
+}
+const a = f.useId;
+function I(u, t) {
+  if (a !== void 0) {
+    const e = a();
+    return u ?? (t ? `${t}-${e}` : e);
+  }
+  return l(u, t);
+}
+export {
+  I as useId
+};

package/dist/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js

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