@iress-oss/ids-components 6.0.0-alpha.3 → 6.0.0-alpha.30

package/dist/helpers/dom/getActiveElement.js

@@ -1,8 +1,7 @@
-import { hasShadowDom as t } from "./hasShadowDom.js";
-const i = () => {
-  const e = document.activeElement;
-  return t(e) ? e?.shadowRoot?.activeElement || void 0 : e || void 0;
+const o = (t) => !!t && !!t.shadowRoot && !!t.attachShadow, e = () => {
+  const t = document.activeElement;
+  return o(t) ? t?.shadowRoot?.activeElement || void 0 : t || void 0;
 };
 export {
-  i as getActiveElement
+  e as getActiveElement
 };

package/dist/helpers/formatting/stringReplacer.d.ts

@@ -0,0 +1,6 @@
+interface NameValue {
+    name: string;
+    value: string;
+}
+export declare const stringReplacer: (str: string, replaceArr?: NameValue[]) => string;
+export {};

package/dist/helpers/label-value/getValueFromLabelValues.d.ts

@@ -0,0 +1,5 @@
+import { LabelValue } from '../../interfaces';
+/**
+ * Retrieves value(s) from an array or single LabelValue item.
+ */
+export declare const getValueFromLabelValues: <T extends LabelValue = LabelValue>(items?: T[] | T, array?: boolean) => string | number | boolean | (string | number | boolean)[];

package/dist/helpers/label-value/highlightQueryInLabel.js

@@ -1,6 +1,5 @@
-import { jsx as e } from "react/jsx-runtime";
-import { f as g } from "../../fuzzysort-DKAolWVP.js";
-const f = (r, i, t = "b") => g.single(i, r)?.highlight((h, o) => /* @__PURE__ */ e(t, { children: h }, o)) ?? r;
+import "react/jsx-runtime";
+import { h as i } from "../../highlightQueryInLabel-Cx7nIoII.js";
 export {
-  f as highlightQueryInLabel
+  i as highlightQueryInLabel
 };

package/dist/helpers/label-value/highlightQueryInLabelValue.js

@@ -1,8 +1,8 @@
-import { highlightQueryInLabel as r } from "./highlightQueryInLabel.js";
-const i = (t, m, o) => ({
+import { h as o } from "../../highlightQueryInLabel-Cx7nIoII.js";
+const i = (t, h, m) => ({
   ...t,
-  formattedLabel: r(t.label, m, o),
-  formattedMeta: typeof t.meta == "string" ? r(t.meta, m, o) : t.meta
+  formattedLabel: o(t.label, h, m),
+  formattedMeta: typeof t.meta == "string" ? o(t.meta, h, m) : t.meta
 });
 export {
   i as highlightQueryInLabelValue

package/dist/helpers/label-value/searchLabelValues.d.ts

@@ -0,0 +1,2 @@
+import { FormattedLabelValueMeta, LabelValue } from '../../interfaces';
+export declare const searchLabelValues: (query: string, optionsData: LabelValue[], resultLimit?: number, all?: boolean) => FormattedLabelValueMeta[];

package/dist/helpers/label-value/searchLabelValues.js

@@ -1,10 +1,11 @@
-import { f as o } from "../../fuzzysort-DKAolWVP.js";
-import { highlightQueryInLabelValue as s } from "./highlightQueryInLabelValue.js";
-const m = (e, r, t) => o.go(e, r, {
+import { f as s } from "../../highlightQueryInLabel-Cx7nIoII.js";
+import { highlightQueryInLabelValue as a } from "./highlightQueryInLabelValue.js";
+const m = (e, r, t, l = !0) => s.go(e, r, {
   key: "label",
   limit: t,
-  threshold: -5e3
-}).map((l) => s(l.obj, e));
+  threshold: -5e3,
+  all: l
+}).map((o) => a(o.obj, e));
 export {
   m as searchLabelValues
 };

package/dist/helpers/styling/iressCss.d.ts

@@ -0,0 +1,10 @@
+import { IressCSSProps } from '../../interfaces';
+/**
+ * This creates a combination of utility classes you can use to style native HTML elements using IDS.
+ *
+ * @see https://design.wm.iress.com/?path=/docs/styling-props-reference--docs
+ *
+ * @param stylingProps Supporting properties for styling.
+ * @returns {string} A string of classes that can be applied to an element.
+ */
+export declare const iressCss: (stylingProps: IressCSSProps) => string;

package/dist/helpers/styling/iressCss.js

@@ -1,7 +1,5 @@
-import { c as r } from "../../css-fGu_jDvv.js";
-import { s as t } from "../../factory-oPXoMw9H.js";
-const c = (s) => r(s), i = (s) => t(s);
+import { c as r } from "../../css-DVJ-ALYD.js";
+const t = (s) => r(s);
 export {
-  c as iressCss,
-  i as iressStyled
+  t as iressCss
 };

package/dist/helpers/utility/idsLogger.d.ts

@@ -0,0 +1 @@
+export declare const idsLogger: (msg: string, level?: "log" | "warn" | "error") => void;

package/dist/highlightQueryInLabel-Cx7nIoII.js

@@ -0,0 +1,399 @@
+import { jsx as Le } from "react/jsx-runtime";
+function Ie(z) {
+  return z && z.__esModule && Object.prototype.hasOwnProperty.call(z, "default") ? z.default : z;
+}
+var Z = { exports: {} }, ye = Z.exports, ge;
+function me() {
+  return ge || (ge = 1, (function(z) {
+    ((Y, q) => {
+      z.exports ? z.exports = q() : Y.fuzzysort = q();
+    })(ye, (Y) => {
+      var q = (r, e) => {
+        if (!r || !e) return b;
+        var n = ue(r);
+        P(e) || (e = E(e));
+        var f = n.bitflags;
+        return (f & e._bitflags) !== f ? b : D(n, e);
+      }, U = (r, e, n) => {
+        if (!r) return n?.all ? de(e, n) : ie;
+        var f = ue(r), t = f.bitflags, i = f.containsSpace, a = K(n?.threshold || 0), v = n?.limit || ae, s = 0, c = 0, o = e.length;
+        function y(O) {
+          s < v ? (W.add(O), ++s) : (++c, O._score > W.peek()._score && W.replaceTop(O));
+        }
+        if (n?.key)
+          for (var S = n.key, _ = 0; _ < o; ++_) {
+            var I = e[_], g = J(I, S);
+            if (g && (P(g) || (g = E(g)), (t & g._bitflags) === t)) {
+              var d = D(f, g);
+              d !== b && (d._score < a || (d.obj = I, y(d)));
+            }
+          }
+        else if (n?.keys) {
+          var A = n.keys, C = A.length;
+          e: for (var _ = 0; _ < o; ++_) {
+            var I = e[_];
+            {
+              for (var L = 0, u = 0; u < C; ++u) {
+                var S = A[u], g = J(I, S);
+                if (!g) {
+                  ne[u] = V;
+                  continue;
+                }
+                P(g) || (g = E(g)), ne[u] = g, L |= g._bitflags;
+              }
+              if ((t & L) !== t) continue;
+            }
+            if (i) for (let h = 0; h < f.spaceSearches.length; h++) N[h] = m;
+            for (var u = 0; u < C; ++u) {
+              if (g = ne[u], g === V) {
+                G[u] = V;
+                continue;
+              }
+              if (G[u] = D(
+                f,
+                g,
+                /*allowSpaces=*/
+                !1,
+                /*allowPartialMatch=*/
+                i
+              ), G[u] === b) {
+                G[u] = V;
+                continue;
+              }
+              if (i) for (let x = 0; x < f.spaceSearches.length; x++) {
+                if (M[x] > -1e3 && N[x] > m) {
+                  var p = (N[x] + M[x]) / 4;
+                  p > N[x] && (N[x] = p);
+                }
+                M[x] > N[x] && (N[x] = M[x]);
+              }
+            }
+            if (i) {
+              for (let h = 0; h < f.spaceSearches.length; h++)
+                if (N[h] === m) continue e;
+            } else {
+              var l = !1;
+              for (let h = 0; h < C; h++)
+                if (G[h]._score !== m) {
+                  l = !0;
+                  break;
+                }
+              if (!l) continue;
+            }
+            var B = new se(C);
+            for (let h = 0; h < C; h++)
+              B[h] = G[h];
+            if (i) {
+              var w = 0;
+              for (let h = 0; h < f.spaceSearches.length; h++) w += N[h];
+            } else {
+              var w = m;
+              for (let x = 0; x < C; x++) {
+                var d = B[x];
+                if (d._score > -1e3 && w > m) {
+                  var p = (w + d._score) / 4;
+                  p > w && (w = p);
+                }
+                d._score > w && (w = d._score);
+              }
+            }
+            if (B.obj = I, B._score = w, n?.scoreFn) {
+              if (w = n.scoreFn(B), !w) continue;
+              w = K(w), B._score = w;
+            }
+            w < a || y(B);
+          }
+        } else
+          for (var _ = 0; _ < o; ++_) {
+            var g = e[_];
+            if (g && (P(g) || (g = E(g)), (t & g._bitflags) === t)) {
+              var d = D(f, g);
+              d !== b && (d._score < a || y(d));
+            }
+          }
+        if (s === 0) return ie;
+        for (var T = new Array(s), _ = s - 1; _ >= 0; --_) T[_] = W.poll();
+        return T.total = s + c, T;
+      }, R = (r, e = "<b>", n = "</b>") => {
+        for (var f = typeof e == "function" ? e : void 0, t = r.target, i = t.length, a = r.indexes, v = "", s = 0, c = 0, o = !1, y = [], S = 0; S < i; ++S) {
+          var _ = t[S];
+          if (a[c] === S) {
+            if (++c, o || (o = !0, f ? (y.push(v), v = "") : v += e), c === a.length) {
+              f ? (v += _, y.push(f(v, s++)), v = "", y.push(t.substr(S + 1))) : v += _ + n + t.substr(S + 1);
+              break;
+            }
+          } else
+            o && (o = !1, f ? (y.push(f(v, s++)), v = "") : v += n);
+          v += _;
+        }
+        return f ? y : v;
+      }, $ = (r) => {
+        typeof r == "number" ? r = "" + r : typeof r != "string" && (r = "");
+        var e = j(r);
+        return ve(r, { _targetLower: e._lower, _targetLowerCodes: e.lowerCodes, _bitflags: e.bitflags });
+      }, he = () => {
+        ee.clear(), re.clear();
+      };
+      class te {
+        get indexes() {
+          return this._indexes.slice(0, this._indexes.len).sort((e, n) => e - n);
+        }
+        set indexes(e) {
+          return this._indexes = e;
+        }
+        highlight(e, n) {
+          return R(this, e, n);
+        }
+        get score() {
+          return le(this._score);
+        }
+        set score(e) {
+          this._score = K(e);
+        }
+      }
+      class se extends Array {
+        get score() {
+          return le(this._score);
+        }
+        set score(e) {
+          this._score = K(e);
+        }
+      }
+      var ve = (r, e) => {
+        const n = new te();
+        return n.target = r, n.obj = e.obj ?? b, n._score = e._score ?? m, n._indexes = e._indexes ?? [], n._targetLower = e._targetLower ?? "", n._targetLowerCodes = e._targetLowerCodes ?? b, n._nextBeginningIndexes = e._nextBeginningIndexes ?? b, n._bitflags = e._bitflags ?? 0, n;
+      }, le = (r) => r === m ? 0 : r > 1 ? r : Math.E ** (((-r + 1) ** 0.04307 - 1) * -2), K = (r) => r === 0 ? m : r > 1 ? r : 1 - Math.pow(Math.log(r) / -2 + 1, 1 / 0.04307), oe = (r) => {
+        typeof r == "number" ? r = "" + r : typeof r != "string" && (r = ""), r = r.trim();
+        var e = j(r), n = [];
+        if (e.containsSpace) {
+          var f = r.split(/\s+/);
+          f = [...new Set(f)];
+          for (var t = 0; t < f.length; t++)
+            if (f[t] !== "") {
+              var i = j(f[t]);
+              n.push({ lowerCodes: i.lowerCodes, _lower: f[t].toLowerCase(), containsSpace: !1 });
+            }
+        }
+        return { lowerCodes: e.lowerCodes, _lower: e._lower, containsSpace: e.containsSpace, bitflags: e.bitflags, spaceSearches: n };
+      }, E = (r) => {
+        if (r.length > 999) return $(r);
+        var e = ee.get(r);
+        return e !== void 0 || (e = $(r), ee.set(r, e)), e;
+      }, ue = (r) => {
+        if (r.length > 999) return oe(r);
+        var e = re.get(r);
+        return e !== void 0 || (e = oe(r), re.set(r, e)), e;
+      }, de = (r, e) => {
+        var n = [];
+        n.total = r.length;
+        var f = e?.limit || ae;
+        if (e?.key)
+          for (var t = 0; t < r.length; t++) {
+            var i = r[t], a = J(i, e.key);
+            if (a != b) {
+              P(a) || (a = E(a));
+              var v = ve(a.target, { _score: a._score, obj: i });
+              if (n.push(v), n.length >= f) return n;
+            }
+          }
+        else if (e?.keys)
+          for (var t = 0; t < r.length; t++) {
+            for (var i = r[t], s = new se(e.keys.length), c = e.keys.length - 1; c >= 0; --c) {
+              var a = J(i, e.keys[c]);
+              if (!a) {
+                s[c] = V;
+                continue;
+              }
+              P(a) || (a = E(a)), a._score = m, a._indexes.len = 0, s[c] = a;
+            }
+            if (s.obj = i, s._score = m, n.push(s), n.length >= f) return n;
+          }
+        else
+          for (var t = 0; t < r.length; t++) {
+            var a = r[t];
+            if (a != b && (P(a) || (a = E(a)), a._score = m, a._indexes.len = 0, n.push(a), n.length >= f))
+              return n;
+          }
+        return n;
+      }, D = (r, e, n = !1, f = !1) => {
+        if (n === !1 && r.containsSpace) return xe(r, e, f);
+        for (var t = r._lower, i = r.lowerCodes, a = i[0], v = e._targetLowerCodes, s = i.length, c = v.length, _ = 0, o = 0, y = 0; ; ) {
+          var S = a === v[o];
+          if (S) {
+            if (k[y++] = o, ++_, _ === s) break;
+            a = i[_];
+          }
+          if (++o, o >= c) return b;
+        }
+        var _ = 0, I = !1, g = 0, d = e._nextBeginningIndexes;
+        d === b && (d = e._nextBeginningIndexes = be(e.target)), o = k[0] === 0 ? 0 : d[k[0] - 1];
+        var A = 0;
+        if (o !== c) for (; ; )
+          if (o >= c) {
+            if (_ <= 0 || (++A, A > 200)) break;
+            --_;
+            var C = Q[--g];
+            o = d[C];
+          } else {
+            var S = i[_] === v[o];
+            if (S) {
+              if (Q[g++] = o, ++_, _ === s) {
+                I = !0;
+                break;
+              }
+              ++o;
+            } else
+              o = d[o];
+          }
+        var L = s <= 1 ? -1 : e._targetLower.indexOf(t, k[0]), u = !!~L, p = u ? L === 0 || e._nextBeginningIndexes[L - 1] === L : !1;
+        if (u && !p) {
+          for (var l = 0; l < d.length; l = d[l])
+            if (!(l <= L)) {
+              for (var B = 0; B < s && i[B] === e._targetLowerCodes[l + B]; B++) ;
+              if (B === s) {
+                L = l, p = !0;
+                break;
+              }
+            }
+        }
+        var w = (h) => {
+          for (var x = 0, _e = 0, F = 1; F < s; ++F)
+            h[F] - h[F - 1] !== 1 && (x -= h[F], ++_e);
+          var Se = h[s - 1] - h[0] - (s - 1);
+          if (x -= (12 + Se) * _e, h[0] !== 0 && (x -= h[0] * h[0] * 0.2), !I)
+            x *= 1e3;
+          else {
+            for (var fe = 1, F = d[0]; F < c; F = d[F]) ++fe;
+            fe > 24 && (x *= (fe - 24) * 10);
+          }
+          return x -= (c - s) / 2, u && (x /= 1 + s * s * 1), p && (x /= 1 + s * s * 1), x -= (c - s) / 2, x;
+        };
+        if (I)
+          if (p) {
+            for (var l = 0; l < s; ++l) k[l] = L + l;
+            var T = k, O = w(k);
+          } else
+            var T = Q, O = w(Q);
+        else {
+          if (u) for (var l = 0; l < s; ++l) k[l] = L + l;
+          var T = k, O = w(T);
+        }
+        e._score = O;
+        for (var l = 0; l < s; ++l) e._indexes[l] = T[l];
+        e._indexes.len = s;
+        const X = new te();
+        return X.target = e.target, X._score = e._score, X._indexes = e._indexes, X;
+      }, xe = (r, e, n) => {
+        for (var f = /* @__PURE__ */ new Set(), t = 0, i = b, a = 0, v = r.spaceSearches, s = v.length, c = 0, o = () => {
+          for (let p = c - 1; p >= 0; p--) e._nextBeginningIndexes[H[p * 2 + 0]] = H[p * 2 + 1];
+        }, y = !1, u = 0; u < s; ++u) {
+          M[u] = m;
+          var S = v[u];
+          if (i = D(S, e), n) {
+            if (i === b) continue;
+            y = !0;
+          } else if (i === b)
+            return o(), b;
+          var _ = u === s - 1;
+          if (!_) {
+            var I = i._indexes, g = !0;
+            for (let l = 0; l < I.len - 1; l++)
+              if (I[l + 1] - I[l] !== 1) {
+                g = !1;
+                break;
+              }
+            if (g) {
+              var d = I[I.len - 1] + 1, A = e._nextBeginningIndexes[d - 1];
+              for (let l = d - 1; l >= 0 && A === e._nextBeginningIndexes[l]; l--)
+                e._nextBeginningIndexes[l] = d, H[c * 2 + 0] = l, H[c * 2 + 1] = A, c++;
+            }
+          }
+          t += i._score / s, M[u] = i._score / s, i._indexes[0] < a && (t -= (a - i._indexes[0]) * 2), a = i._indexes[0];
+          for (var C = 0; C < i._indexes.len; ++C) f.add(i._indexes[C]);
+        }
+        if (n && !y) return b;
+        o();
+        var L = D(
+          r,
+          e,
+          /*allowSpaces=*/
+          !0
+        );
+        if (L !== b && L._score > t) {
+          if (n)
+            for (var u = 0; u < s; ++u)
+              M[u] = L._score / s;
+          return L;
+        }
+        n && (i = e), i._score = t;
+        var u = 0;
+        for (let p of f) i._indexes[u++] = p;
+        return i._indexes.len = u, i;
+      }, ce = (r) => r.replace(new RegExp("\\p{Script=Latin}+", "gu"), (e) => e.normalize("NFD")).replace(/[\u0300-\u036f]/g, ""), j = (r) => {
+        r = ce(r);
+        for (var e = r.length, n = r.toLowerCase(), f = [], t = 0, i = !1, a = 0; a < e; ++a) {
+          var v = f[a] = n.charCodeAt(a);
+          if (v === 32) {
+            i = !0;
+            continue;
+          }
+          var s = v >= 97 && v <= 122 ? v - 97 : v >= 48 && v <= 57 ? 26 : v <= 127 ? 30 : 31;
+          t |= 1 << s;
+        }
+        return { lowerCodes: f, bitflags: t, containsSpace: i, _lower: n };
+      }, we = (r) => {
+        for (var e = r.length, n = [], f = 0, t = !1, i = !1, a = 0; a < e; ++a) {
+          var v = r.charCodeAt(a), s = v >= 65 && v <= 90, c = s || v >= 97 && v <= 122 || v >= 48 && v <= 57, o = s && !t || !i || !c;
+          t = s, i = c, o && (n[f++] = a);
+        }
+        return n;
+      }, be = (r) => {
+        r = ce(r);
+        for (var e = r.length, n = we(r), f = [], t = n[0], i = 0, a = 0; a < e; ++a)
+          t > a ? f[a] = t : (t = n[++i], f[a] = t === void 0 ? e : t);
+        return f;
+      }, ee = /* @__PURE__ */ new Map(), re = /* @__PURE__ */ new Map(), k = [], Q = [], H = [], N = [], M = [], ne = [], G = [], J = (r, e) => {
+        var n = r[e];
+        if (n !== void 0) return n;
+        if (typeof e == "function") return e(r);
+        var f = e;
+        Array.isArray(e) || (f = e.split("."));
+        for (var t = f.length, i = -1; r && ++i < t; ) r = r[f[i]];
+        return r;
+      }, P = (r) => typeof r == "object" && typeof r._bitflags == "number", ae = 1 / 0, m = -ae, ie = [];
+      ie.total = 0;
+      var b = null, V = $(""), pe = (r) => {
+        var e = [], n = 0, f = {}, t = (i) => {
+          for (var a = 0, v = e[a], s = 1; s < n; ) {
+            var c = s + 1;
+            a = s, c < n && e[c]._score < e[s]._score && (a = c), e[a - 1 >> 1] = e[a], s = 1 + (a << 1);
+          }
+          for (var o = a - 1 >> 1; a > 0 && v._score < e[o]._score; o = (a = o) - 1 >> 1) e[a] = e[o];
+          e[a] = v;
+        };
+        return f.add = ((i) => {
+          var a = n;
+          e[n++] = i;
+          for (var v = a - 1 >> 1; a > 0 && i._score < e[v]._score; v = (a = v) - 1 >> 1) e[a] = e[v];
+          e[a] = i;
+        }), f.poll = ((i) => {
+          if (n !== 0) {
+            var a = e[0];
+            return e[0] = e[--n], t(), a;
+          }
+        }), f.peek = ((i) => {
+          if (n !== 0) return e[0];
+        }), f.replaceTop = ((i) => {
+          e[0] = i, t();
+        }), f;
+      }, W = pe();
+      return { single: q, go: U, prepare: $, cleanup: he };
+    });
+  })(Z)), Z.exports;
+}
+var Be = me();
+const Ce = /* @__PURE__ */ Ie(Be), ke = (z, Y, q = "b") => Ce.single(Y, z)?.highlight((U, R) => /* @__PURE__ */ Le(q, { children: U }, R)) ?? z;
+export {
+  Ce as f,
+  ke as h
+};

package/dist/hooks/useBreakpoint.d.ts

@@ -0,0 +1,19 @@
+import { BreakpointDetail } from '../interfaces';
+import { Breakpoints } from '../types';
+interface BreakpointResult {
+    breakpoint: Breakpoints;
+    detail: BreakpointDetail;
+}
+interface UseBreakpointOptions {
+    /**
+     * Disables the hook from running any side effects.
+     * When disabled, the hook returns the initial breakpoint without listening to resize events.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/**
+ * Retrieve the current breakpoint and its detail based on the window size
+ */
+export declare const useBreakpoint: (options?: UseBreakpointOptions) => BreakpointResult;
+export {};

package/dist/hooks/useBreakpoint.js

@@ -1,17 +1,18 @@
-import { BREAKPOINTS as n, BREAKPOINT_DETAILS as a } from "../constants.js";
-import { useState as s, useCallback as c, useLayoutEffect as u } from "react";
-const o = () => n.find((e) => window.matchMedia(a[e].mediaQuery)?.matches) ?? n[0], m = () => {
-  const [e, i] = s(o()), r = c(() => {
-    i(o());
+import { BREAKPOINT_DETAILS as s, BREAKPOINTS as a } from "../constants.js";
+import { useState as d, useCallback as u, useLayoutEffect as p } from "react";
+const i = () => a.find((e) => window.matchMedia(s[e].mediaQuery)?.matches) ?? a[0], k = (e = {}) => {
+  const { disabled: r = !1 } = e, [n, c] = d(i()), o = u(() => {
+    c(i());
   }, []);
-  return u(() => {
-    const t = r;
+  return p(() => {
+    if (r) return;
+    const t = o;
     return window.addEventListener("resize", t), t(), () => window.removeEventListener("resize", t);
-  }, [r]), {
-    breakpoint: e,
-    detail: a[e]
+  }, [r, o]), {
+    breakpoint: n,
+    detail: s[n]
   };
 };
 export {
-  m as useBreakpoint
+  k as useBreakpoint
 };

package/dist/hooks/useResponsiveProps.d.ts

@@ -0,0 +1,25 @@
+import { Breakpoints, ResponsiveProp } from '../types';
+export interface UseResponsivePropsOptions {
+    /**
+     * Whether to inherit the previous breakpoint value, if none was found for the current one.
+     * @default true
+     */
+    inheritPrevious?: boolean;
+    /**
+     * Disables the hook from running any side effects.
+     * When disabled, the hook returns the initial breakpoint without listening to resize events.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/**
+ * Allows you to pluck a value from an object with breakpoint keys.
+ * Note: Where possible, we recommend using media queries in CSS instead of JS, as that will reduce the load for the user. However, sometimes it's necessary to change a prop based on the user's breakpoint, hence why this hook is provided.
+ * @param {ResponsiveProp<T>} values A set of values, separated by breakpoint and ready for plucking.
+ * @param {UseResponsivePropsOptions} options Configuration options for the hook.
+ * @returns { breakpoint: Breakpoints; value?: T | null } The current user's breakpoint, along with a matching value if one was found.
+ */
+export declare const useResponsiveProps: <T>(prop?: ResponsiveProp<T>, options?: UseResponsivePropsOptions) => {
+    breakpoint: Breakpoints;
+    value?: T;
+};

package/dist/hooks/useResponsiveProps.js

@@ -1,29 +1,29 @@
-import { useMemo as u } from "react";
-import { useBreakpoint as c } from "./useBreakpoint.js";
-import { BREAKPOINTS as i } from "../constants.js";
-const v = (e, o = !0) => {
-  const { breakpoint: t } = c(), f = u(() => {
+import { useMemo as m } from "react";
+import { useBreakpoint as a } from "./useBreakpoint.js";
+import { BREAKPOINTS as n } from "../constants.js";
+const O = (e, f = {}) => {
+  const { inheritPrevious: o = !0, disabled: u = !1 } = f, { breakpoint: i } = a({ disabled: u }), c = m(() => {
     if (!e)
       return;
-    if (!(typeof e == "object") || !i.some((s) => s in e))
+    if (!(typeof e == "object") || !n.some((r) => r in e))
       return e;
-    const r = e;
-    if (t in e)
-      return r[t];
+    const s = e;
+    if (i in e)
+      return s[i];
     if (o) {
-      const s = i.indexOf(t);
-      for (let n = s; n >= 0; n--)
-        if (i[n] in e)
-          return r[i[n]];
+      const r = n.indexOf(i);
+      for (let t = r; t >= 0; t--)
+        if (n[t] in e)
+          return s[n[t]];
     }
     if ("base" in e)
-      return r.base;
-  }, [t, o, e]);
+      return s.base;
+  }, [i, o, e]);
   return {
-    breakpoint: t,
-    value: f
+    breakpoint: i,
+    value: c
   };
 };
 export {
-  v as useResponsiveProps
+  O as useResponsiveProps
 };