@cube-dev/ui-kit 0.197.0 → 0.198.1

package/dist/utils/react/useBufferedValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBufferedValue.js","names":["useCallback","useRef","useState","useLayoutEffect","NOTHING_PENDING","UseBufferedValueOptions","getKey","value","T","isDisabled","isReadOnly","isBuffered","UseBufferedValueResult","onChange","next","reset","useBufferedValue","options","isActive","undefined","keyOf","valueKey","draft","setDraft","pendingRef","seenKeyRef","latestRef","pending","current","propMoved","echoAt","indexOf","isExternal","isAhead","length","rendered","slice","handleChange","latestOnChange","latestKeyOf","latestIsActive","latestValue"],"sources":["../../../src/utils/react/useBufferedValue.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport { useLayoutEffect } from './useLayoutEffect';\n\nconst NOTHING_PENDING: unknown[] = [];\n\nexport interface UseBufferedValueOptions<T> {\n  /**\n   * Identity of a value, for values `Object.is` doesn't compare usefully — an array of colour\n   * stops, a settings object. Defaults to the value itself, which is what strings want.\n   */\n  getKey?: (value: T) => unknown;\n  /** Nothing can be typed into a disabled control, so there is nothing to protect. */\n  isDisabled?: boolean;\n  /** Same for a read-only one. */\n  isReadOnly?: boolean;\n  /** Escape hatch: `false` makes the hook inert and passes `value`/`onChange` straight through. */\n  isBuffered?: boolean;\n}\n\nexport interface UseBufferedValueResult<T> {\n  /** Render this instead of `value`. `undefined` passes through, meaning uncontrolled. */\n  value: T | undefined;\n  /** Call this instead of `onChange`. Still emits once per call, in the same tick. */\n  onChange: (next: T) => void;\n  /** Drop the buffer and let `value` win again. The text fields call it on blur. */\n  reset: () => void;\n}\n\n/**\n * Holds a controlled value locally so a parent that echoes the new value back *late* cannot\n * overwrite what the user is doing.\n *\n * **Why any of this is needed.** A controlled `<input>` renders whatever string its parent hands\n * it. If the parent hands back the pre-keystroke string — because its state reaches the component\n * through a store that publishes a render late, or through a debounce, or a deferred update —\n * React writes that stale string into the DOM node, and a native `value` assignment collapses the\n * selection to the end. Typing in the middle of a field throws the caret to the end. The value\n * eventually lands, so it looks like a caret bug rather than a data-flow one.\n *\n * The buffer keeps the typed text on screen until the parent catches up, while still emitting\n * `onChange` once per keystroke — so nothing downstream changes: no debouncing, no commit-on-blur,\n * no swallowed calls.\n *\n * Generic on purpose. The same lateness affects values that aren't strings (a colour scale's array\n * of stops emitted through a chart-spec pipeline), and `getKey` is where those pass the signature\n * function they already have.\n *\n * ```tsx\n * const buffered = useBufferedValue(value, onChange, { isReadOnly, isDisabled });\n *\n * <input value={buffered.value} onChange={buffered.onChange} onBlur={buffered.reset} />\n * ```\n *\n * One case it cannot resolve: an external change that lands *between* an emit and its echo, and\n * happens to equal a value still in flight, is read as our own echo. Telling those apart needs a\n * sequence number from the store rather than value matching.\n */\nexport function useBufferedValue<T>(\n  value: T | undefined,\n  onChange?: (next: T) => void,\n  options: UseBufferedValueOptions<T> = {},\n): UseBufferedValueResult<T> {\n  const { getKey, isDisabled, isReadOnly, isBuffered = true } = options;\n\n  // An `undefined` value means the control is uncontrolled — it already owns its text.\n  const isActive =\n    isBuffered && value !== undefined && !isDisabled && !isReadOnly;\n\n  const keyOf = (next: T | undefined): unknown =>\n    getKey && next != null ? getKey(next) : next;\n  const valueKey = keyOf(value);\n\n  // The only state, and the only thing that can force a render: what the user typed. It is rendered\n  // *while we are ahead of the parent* and ignored otherwise — which is what makes adopting an\n  // external value free, since there is nothing to write.\n  const [draft, setDraft] = useState(value);\n  // Keys we have emitted that the parent hasn't echoed back yet. A queue rather than one slot: the\n  // user can type again before the first echo returns, and each echo has to be recognised as ours\n  // or applying it would swallow everything typed after it.\n  const pendingRef = useRef<unknown[]>(NOTHING_PENDING);\n  // The last value we accepted as the parent's opinion — not the last one we rendered.\n  const seenKeyRef = useRef<unknown>(valueKey);\n  const latestRef = useRef({ value, onChange, keyOf, isActive });\n\n  // These three refs are read during render but written *only* in an event handler or after commit,\n  // never during a render. That is what keeps them honest under concurrent rendering: React may\n  // discard a render (an interrupted pass, a StrictMode double-invoke), and a discarded render runs\n  // no effects, so it cannot leave the bookkeeping describing a pass that never committed.\n  const pending = pendingRef.current;\n  const propMoved = valueKey !== seenKeyRef.current;\n  // Our own echo, a render or more late — possibly an earlier emit a later one superseded.\n  const echoAt = propMoved ? pending.indexOf(valueKey) : -1;\n  // A real change from the parent: undo/redo, a reset, a transformed value, another record.\n  const isExternal = propMoved && echoAt < 0;\n  const isAhead = isActive && !isExternal && pending.length > 0;\n  // Not being ahead is the whole of \"the parent wins\", so an external change needs no state write\n  // and costs no extra render. Being ahead — including when the value is the stale one the parent\n  // held *before* the keystroke — is what stops React writing that string back and collapsing the\n  // selection.\n  const rendered = isAhead ? draft : value;\n\n  useLayoutEffect(() => {\n    latestRef.current = { value, onChange, keyOf, isActive };\n    seenKeyRef.current = valueKey;\n\n    if (!isActive || isExternal) {\n      pendingRef.current = NOTHING_PENDING;\n    } else if (echoAt >= 0) {\n      pendingRef.current = pending.slice(echoAt + 1);\n    }\n  });\n\n  const handleChange = useCallback((next: T) => {\n    const {\n      onChange: latestOnChange,\n      keyOf: latestKeyOf,\n      isActive: latestIsActive,\n    } = latestRef.current;\n\n    if (latestIsActive) {\n      // A ref write in an event handler, which runs after a commit — never mid-render.\n      pendingRef.current = [...pendingRef.current, latestKeyOf(next)];\n      setDraft(next);\n    }\n\n    latestOnChange?.(next);\n  }, []);\n\n  const reset = useCallback(() => {\n    const { value: latestValue } = latestRef.current;\n\n    // Emptying the queue is what hands control back: with nothing in flight we are no longer ahead,\n    // so the parent's value is rendered again. `setDraft` is only here to schedule that render.\n    pendingRef.current = NOTHING_PENDING;\n    setDraft(latestValue);\n  }, []);\n\n  return { value: rendered, onChange: handleChange, reset };\n}\n"],"mappings":";;;;;AAIA,MAAMI,kBAA6B,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDrC,SAAgBY,iBACdT,OACAM,UACAI,UAAsC,EAAE,EACb;CAC3B,MAAM,EAAEX,QAAQG,YAAYC,YAAYC,aAAa,SAASM;CAG9D,MAAMC,WACJP,cAAcJ,UAAUY,UAAa,CAACV,cAAc,CAACC;CAEvD,MAAMU,SAASN,SACbR,UAAUQ,QAAQ,OAAOR,OAAOQ,KAAK,GAAGA;CAC1C,MAAMO,WAAWD,MAAMb,MAAM;CAK7B,MAAM,CAACe,OAAOC,YAAYrB,SAASK,MAAM;CAIzC,MAAMiB,aAAavB,OAAkBG,gBAAgB;CAErD,MAAMqB,aAAaxB,OAAgBoB,SAAS;CAC5C,MAAMK,YAAYzB,OAAO;EAAEM;EAAOM;EAAUO;EAAOF;EAAU,CAAC;CAM9D,MAAMS,UAAUH,WAAWI;CAC3B,MAAMC,YAAYR,aAAaI,WAAWG;CAE1C,MAAME,SAASD,YAAYF,QAAQI,QAAQV,SAAS,GAAG;CAEvD,MAAMW,aAAaH,aAAaC,SAAS;CAMzC,MAAMK,WALUjB,YAAY,CAACc,cAAcL,QAAQO,SAAS,IAKjCZ,QAAQf;AAEnCJ,yBAAsB;AACpBuB,YAAUE,UAAU;GAAErB;GAAOM;GAAUO;GAAOF;GAAU;AACxDO,aAAWG,UAAUP;AAErB,MAAI,CAACH,YAAYc,WACfR,YAAWI,UAAUxB;WACZ0B,UAAU,EACnBN,YAAWI,UAAUD,QAAQS,MAAMN,SAAS,EAAE;GAEhD;AA2BF,QAAO;EAAEvB,OAAO4B;EAAUtB,UAzBLb,aAAac,WAAY;GAC5C,MAAM,EACJD,UAAUyB,gBACVlB,OAAOmB,aACPrB,UAAUsB,mBACRd,UAAUE;AAEd,OAAIY,gBAAgB;AAElBhB,eAAWI,UAAU,CAAC,GAAGJ,WAAWI,SAASW,YAAYzB,OAAK,CAAC;AAC/DS,aAAST,OAAK;;AAGhBwB,oBAAiBxB,OAAK;KACrB,EAAE,CAAC;EAW4CC,OATpCf,kBAAkB;GAC9B,MAAM,EAAEO,OAAOkC,gBAAgBf,UAAUE;AAIzCJ,cAAWI,UAAUxB;AACrBmB,YAASkB,YAAY;KACpB,EAAE,CAAC;EAEmD"}
+{"version":3,"file":"useBufferedValue.js","names":["useCallback","useRef","useState","useLayoutEffect","NOTHING_PENDING","UseBufferedValueOptions","getKey","value","T","isDisabled","isReadOnly","isBuffered","UseBufferedValueResult","onChange","next","reset","useBufferedValue","options","isActive","undefined","keyOf","valueKey","draft","setDraft","pendingRef","seenKeyRef","latestRef","pending","current","propMoved","echoAt","indexOf","isExternal","isAhead","length","rendered","slice","handleChange","latestOnChange","latestKeyOf","latestIsActive","latestValue"],"sources":["../../../src/utils/react/useBufferedValue.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'react';\n\nimport { useLayoutEffect } from './useLayoutEffect';\n\nconst NOTHING_PENDING: unknown[] = [];\n\nexport interface UseBufferedValueOptions<T> {\n  /**\n   * Identity of a value, for values `Object.is` doesn't compare usefully — an array of colour\n   * stops, a settings object. Defaults to the value itself, which is what strings want.\n   */\n  getKey?: (value: T) => unknown;\n  /** Nothing can be typed into a disabled control, so there is nothing to protect. */\n  isDisabled?: boolean;\n  /** Same for a read-only one. */\n  isReadOnly?: boolean;\n  /** Escape hatch: `false` makes the hook inert and passes `value`/`onChange` straight through. */\n  isBuffered?: boolean;\n}\n\nexport interface UseBufferedValueResult<T> {\n  /** Render this instead of `value`. `undefined` passes through, meaning uncontrolled. */\n  value: T | undefined;\n  /** Call this instead of `onChange`. Still emits once per call, in the same tick. */\n  onChange: (next: T) => void;\n  /** Drop the buffer and let `value` win again. The text fields call it on blur. */\n  reset: () => void;\n}\n\n/**\n * Holds a controlled value locally so a parent that echoes the new value back *late* cannot\n * overwrite what the user is doing.\n *\n * **Why any of this is needed.** A controlled `<input>` renders whatever string its parent hands\n * it. If the parent hands back the pre-keystroke string — because its state reaches the component\n * through a store that publishes a render late, or through a debounce, or a deferred update —\n * React writes that stale string into the DOM node, and a native `value` assignment collapses the\n * selection to the end. Typing in the middle of a field throws the caret to the end. The value\n * eventually lands, so it looks like a caret bug rather than a data-flow one.\n *\n * The buffer keeps the typed text on screen until the parent catches up, while still emitting\n * `onChange` once per keystroke — so nothing downstream changes: no debouncing, no commit-on-blur,\n * no swallowed calls.\n *\n * Generic on purpose. The same lateness affects values that aren't strings (a colour scale's array\n * of stops emitted through a chart-spec pipeline), and `getKey` is where those pass the signature\n * function they already have.\n *\n * ```tsx\n * const buffered = useBufferedValue(value, onChange, { isReadOnly, isDisabled });\n *\n * <input value={buffered.value} onChange={buffered.onChange} onBlur={buffered.reset} />\n * ```\n *\n * One case it cannot resolve: an external change that lands *between* an emit and its echo, and\n * happens to equal a value still in flight, is read as our own echo. Telling those apart needs a\n * sequence number from the store rather than value matching.\n */\nexport function useBufferedValue<T>(\n  value: T | undefined,\n  onChange?: (next: T) => void,\n  options: UseBufferedValueOptions<T> = {},\n): UseBufferedValueResult<T> {\n  const { getKey, isDisabled, isReadOnly, isBuffered = true } = options;\n\n  // An `undefined` value means the control is uncontrolled — it already owns its text.\n  const isActive =\n    isBuffered && value !== undefined && !isDisabled && !isReadOnly;\n\n  const keyOf = (next: T | undefined): unknown =>\n    getKey && next != null ? getKey(next) : next;\n  const valueKey = keyOf(value);\n\n  // The only state, and the only thing that can force a render: what the user typed. It is rendered\n  // *while we are ahead of the parent* and ignored otherwise — which is what makes adopting an\n  // external value free, since there is nothing to write.\n  const [draft, setDraft] = useState(value);\n  // Keys we have emitted that the parent hasn't echoed back yet. A queue rather than one slot: the\n  // user can type again before the first echo returns, and each echo has to be recognised as ours\n  // or applying it would swallow everything typed after it.\n  const pendingRef = useRef<unknown[]>(NOTHING_PENDING);\n  // The last value we accepted as the parent's opinion — not the last one we rendered.\n  const seenKeyRef = useRef<unknown>(valueKey);\n  const latestRef = useRef({ value, onChange, keyOf, isActive });\n\n  // These three refs are read during render but written *only* in an event handler or after commit,\n  // never during a render. That is what keeps them honest under concurrent rendering: React may\n  // discard a render (an interrupted pass, a StrictMode double-invoke), and a discarded render runs\n  // no effects, so it cannot leave the bookkeeping describing a pass that never committed.\n  const pending = pendingRef.current;\n  const propMoved = valueKey !== seenKeyRef.current;\n  // Our own echo, a render or more late — possibly an earlier emit a later one superseded.\n  const echoAt = propMoved ? pending.indexOf(valueKey) : -1;\n  // A real change from the parent: undo/redo, a reset, a transformed value, another record.\n  const isExternal = propMoved && echoAt < 0;\n  const isAhead = isActive && !isExternal && pending.length > 0;\n  // Not being ahead is the whole of \"the parent wins\", so an external change needs no state write\n  // and costs no extra render. Being ahead — including when the value is the stale one the parent\n  // held *before* the keystroke — is what stops React writing that string back and collapsing the\n  // selection.\n  const rendered = isAhead ? draft : value;\n\n  useLayoutEffect(() => {\n    latestRef.current = { value, onChange, keyOf, isActive };\n    seenKeyRef.current = valueKey;\n\n    if (!isActive || isExternal) {\n      pendingRef.current = NOTHING_PENDING;\n    } else if (echoAt >= 0) {\n      pendingRef.current = pending.slice(echoAt + 1);\n    }\n  });\n\n  const handleChange = useCallback((next: T) => {\n    const {\n      onChange: latestOnChange,\n      keyOf: latestKeyOf,\n      isActive: latestIsActive,\n    } = latestRef.current;\n\n    if (latestIsActive) {\n      // A ref write in an event handler, which runs after a commit — never mid-render.\n      pendingRef.current = [...pendingRef.current, latestKeyOf(next)];\n      setDraft(next);\n    }\n\n    latestOnChange?.(next);\n  }, []);\n\n  const reset = useCallback(() => {\n    const { value: latestValue } = latestRef.current;\n\n    // Emptying the queue is what hands control back: with nothing in flight we are no longer ahead,\n    // so the parent's value is rendered again. `setDraft` is only here to schedule that render.\n    pendingRef.current = NOTHING_PENDING;\n    setDraft(latestValue);\n  }, []);\n\n  return { value: rendered, onChange: handleChange, reset };\n}\n"],"mappings":";;;;AAIA,MAAMI,kBAA6B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDnC,SAAgBY,iBACdT,OACAM,UACAI,UAAsC,CAAC,GACZ;CAC3B,MAAM,EAAEX,QAAQG,YAAYC,YAAYC,aAAa,SAASM;CAG9D,MAAMC,WACJP,cAAcJ,UAAUY,KAAAA,KAAa,CAACV,cAAc,CAACC;CAEvD,MAAMU,SAASN,SACbR,UAAUQ,QAAQ,OAAOR,OAAOQ,IAAI,IAAIA;CAC1C,MAAMO,WAAWD,MAAMb,KAAK;CAK5B,MAAM,CAACe,OAAOC,YAAYrB,SAASK,KAAK;CAIxC,MAAMiB,aAAavB,OAAkBG,eAAe;CAEpD,MAAMqB,aAAaxB,OAAgBoB,QAAQ;CAC3C,MAAMK,YAAYzB,OAAO;EAAEM;EAAOM;EAAUO;EAAOF;CAAS,CAAC;CAM7D,MAAMS,UAAUH,WAAWI;CAC3B,MAAMC,YAAYR,aAAaI,WAAWG;CAE1C,MAAME,SAASD,YAAYF,QAAQI,QAAQV,QAAQ,IAAI;CAEvD,MAAMW,aAAaH,aAAaC,SAAS;CAMzC,MAAMK,WALUjB,YAAY,CAACc,cAAcL,QAAQO,SAAS,IAKjCZ,QAAQf;CAEnCJ,wBAAsB;EACpBuB,UAAUE,UAAU;GAAErB;GAAOM;GAAUO;GAAOF;EAAS;EACvDO,WAAWG,UAAUP;EAErB,IAAI,CAACH,YAAYc,YACfR,WAAWI,UAAUxB;OAChB,IAAI0B,UAAU,GACnBN,WAAWI,UAAUD,QAAQS,MAAMN,SAAS,CAAC;CAEjD,CAAC;CA2BD,OAAO;EAAEvB,OAAO4B;EAAUtB,UAzBLb,aAAac,WAAY;GAC5C,MAAM,EACJD,UAAUyB,gBACVlB,OAAOmB,aACPrB,UAAUsB,mBACRd,UAAUE;GAEd,IAAIY,gBAAgB;IAElBhB,WAAWI,UAAU,CAAC,GAAGJ,WAAWI,SAASW,YAAYzB,MAAI,CAAC;IAC9DS,SAAST,MAAI;GACf;GAEAwB,iBAAiBxB,MAAI;EACvB,GAAG,CAAA,CAWiCuB;EAActB,OATpCf,kBAAkB;GAC9B,MAAM,EAAEO,OAAOkC,gBAAgBf,UAAUE;GAIzCJ,WAAWI,UAAUxB;GACrBmB,SAASkB,WAAW;EACtB,GAAG,CAAA,CAE+C1B;CAAM;AAC1D"}

package/dist/utils/react/useCombinedRefs.d.ts

@@ -1,9 +1,7 @@
 
 import { Ref, RefObject } from "react";
-
 //#region src/utils/react/useCombinedRefs.d.ts
-declare function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): (value: T | null) => void;
-declare function useCombinedRefs<T>(...refs: Array<Ref<T> | undefined>): RefObject<T>;
+export declare function mergeRefs<T>(...refs: Array<Ref<T> | undefined>): (value: T | null) => void;
+export declare function useCombinedRefs<T>(...refs: Array<Ref<T> | undefined>): RefObject<T>;
 //#endregion
-export { mergeRefs, useCombinedRefs };
 //# sourceMappingURL=useCombinedRefs.d.ts.map

package/dist/utils/react/useCombinedRefs.js

@@ -1,7 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 import { useEffect, useRef } from "react";
-
 //#region src/utils/react/useCombinedRefs.ts
 function mergeRefs(...refs) {
 	return (value) => {
@@ -33,7 +32,7 @@ function useCombinedRefs(...t0) {
 	useEffect(t1, t2);
 	return targetRef;
 }
-
 //#endregion
 export { mergeRefs, useCombinedRefs };
+
 //# sourceMappingURL=useCombinedRefs.js.map

package/dist/utils/react/useCombinedRefs.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCombinedRefs.js","names":["Ref","RefObject","useEffect","useRef","AssignableRef","current","T","mergeRefs","refs","Array","value","forEach","ref","useCombinedRefs","t0","$","_c","targetRef","t1","t2"],"sources":["../../../src/utils/react/useCombinedRefs.ts"],"sourcesContent":["import { Ref, RefObject, useEffect, useRef } from 'react';\n\ntype AssignableRef<T> = { current: T | null };\n\nexport function mergeRefs<T>(...refs: Array<Ref<T> | undefined>) {\n  return (value: T | null) => {\n    refs.forEach((ref) => {\n      if (!ref) return;\n\n      if (typeof ref === 'function') {\n        ref(value);\n      } else {\n        (ref as AssignableRef<T>).current = value;\n      }\n    });\n  };\n}\n\nexport function useCombinedRefs<T>(\n  ...refs: Array<Ref<T> | undefined>\n): RefObject<T> {\n  const targetRef = useRef<T>(null) as RefObject<T>;\n\n  useEffect(() => {\n    mergeRefs(...refs)(targetRef.current);\n  }, [refs]);\n\n  return targetRef;\n}\n"],"mappings":";;;;;AAIA,SAAgBO,UAAa,GAAGC,MAAiC;AAC/D,SAAQE,UAAoB;AAC1BF,OAAKG,SAASC,QAAQ;AACpB,OAAI,CAACA,IAAK;AAEV,OAAI,OAAOA,QAAQ,WACjBA,KAAIF,MAAM;OAEV,CAACE,IAAyBP,UAAUK;IAEtC;;;AAIN,SAAOG,gBAAA,GAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CACL,MAAAR,OAAAM;CAEA,MAAAG,YAAkBd,OAAU,KAAK;CAAiB,IAAAe;CAAA,IAAAC;AAAA,KAAAJ,EAAA,OAAAP,MAAA;AAExCU,aAAA;AACRX,aAAS,GAAIC,KAAK,CAACS,UAASZ,QAAS;;AACpCc,OAAA,CAACX,KAAK;AAAAO,IAAA,KAAAP;AAAAO,IAAA,KAAAG;AAAAH,IAAA,KAAAI;QAAA;AAAAD,OAAAH,EAAA;AAAAI,OAAAJ,EAAA;;AAFTb,WAAUgB,IAEPC,GAAO;AAAA,QAEHF"}
+{"version":3,"file":"useCombinedRefs.js","names":["Ref","RefObject","useEffect","useRef","AssignableRef","current","T","mergeRefs","refs","Array","value","forEach","ref","useCombinedRefs","t0","$","_c","targetRef","t1","t2","_c"],"sources":["../../../src/utils/react/useCombinedRefs.ts"],"sourcesContent":["import { Ref, RefObject, useEffect, useRef } from 'react';\n\ntype AssignableRef<T> = { current: T | null };\n\nexport function mergeRefs<T>(...refs: Array<Ref<T> | undefined>) {\n  return (value: T | null) => {\n    refs.forEach((ref) => {\n      if (!ref) return;\n\n      if (typeof ref === 'function') {\n        ref(value);\n      } else {\n        (ref as AssignableRef<T>).current = value;\n      }\n    });\n  };\n}\n\nexport function useCombinedRefs<T>(\n  ...refs: Array<Ref<T> | undefined>\n): RefObject<T> {\n  const targetRef = useRef<T>(null) as RefObject<T>;\n\n  useEffect(() => {\n    mergeRefs(...refs)(targetRef.current);\n  }, [refs]);\n\n  return targetRef;\n}\n"],"mappings":";;;;AAIA,SAAgBO,UAAa,GAAGC,MAAiC;CAC/D,QAAQE,UAAoB;EAC1BF,KAAKG,SAASC,QAAQ;GACpB,IAAI,CAACA,KAAK;GAEV,IAAI,OAAOA,QAAQ,YACjBA,IAAIF,KAAK;QAET,IAA0BL,UAAUK;EAExC,CAAC;CACH;AACF;AAEA,SAAOG,gBAAA,GAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAR,OAAAM;CAEA,MAAAG,YAAkBd,OAAU,IAAI;CAAkB,IAAAe;CAAA,IAAAC;CAAA,IAAAJ,EAAA,OAAAP,MAAA;EAExCU,WAAA;GACRX,UAAS,GAAIC,IAAI,CAAC,CAACS,UAASZ,OAAQ;EAAC;EACpCc,KAAA,CAACX,IAAI;EAACO,EAAA,KAAAP;EAAAO,EAAA,KAAAG;EAAAH,EAAA,KAAAI;CAAA,OAAA;EAAAD,KAAAH,EAAA;EAAAI,KAAAJ,EAAA;CAAA;CAFTb,UAAUgB,IAEPC,EAAM;CAAC,OAEHF;AAAS"}

package/dist/utils/react/useControlledFocusVisible.d.ts

@@ -1,6 +1,6 @@
 
 //#region src/utils/react/useControlledFocusVisible.d.ts
-interface UseControlledFocusVisibleResult {
+export interface UseControlledFocusVisibleResult {
   isFocusVisible: boolean;
   activateFocusVisible: () => void;
 }
@@ -9,7 +9,6 @@ interface UseControlledFocusVisibleResult {
  * but also returns activateFocusVisible function that manually switches the state to true
  * until the original flag is switched to false.
  */
-declare function useControlledFocusVisible(): UseControlledFocusVisibleResult;
+export declare function useControlledFocusVisible(): UseControlledFocusVisibleResult;
 //#endregion
-export { UseControlledFocusVisibleResult, useControlledFocusVisible };
 //# sourceMappingURL=useControlledFocusVisible.d.ts.map

package/dist/utils/react/useControlledFocusVisible.js

@@ -1,9 +1,8 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { createSharedStore } from "./sharedStore.js";
 import { c } from "react/compiler-runtime";
 import { useEffect } from "react";
 import { useFocusVisible } from "react-aria";
-
 //#region src/utils/react/useControlledFocusVisible.ts
 const useControlledFocusVisibleStore = createSharedStore("controlledFocusVisible", { isManuallyActivated: false });
 /**
@@ -64,7 +63,7 @@ function useControlledFocusVisible() {
 	} else t6 = $[10];
 	return t6;
 }
-
 //#endregion
 export { useControlledFocusVisible };
+
 //# sourceMappingURL=useControlledFocusVisible.js.map

package/dist/utils/react/useControlledFocusVisible.js.map

@@ -1 +1 @@
-{"version":3,"file":"useControlledFocusVisible.js","names":["useEffect","useFocusVisible","createSharedStore","ControlledFocusVisibleState","isManuallyActivated","useControlledFocusVisibleStore","UseControlledFocusVisibleResult","isFocusVisible","activateFocusVisible","useControlledFocusVisible","$","_c","t0","Symbol","for","originalIsFocusVisible","t1","setStore","t2","t3","t4","t5","t6"],"sources":["../../../src/utils/react/useControlledFocusVisible.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useFocusVisible } from 'react-aria';\n\nimport { createSharedStore } from './sharedStore';\n\ninterface ControlledFocusVisibleState {\n  isManuallyActivated: boolean;\n}\n\n// Create a shared store for the controlled focus visible state\nconst useControlledFocusVisibleStore =\n  createSharedStore<ControlledFocusVisibleState>('controlledFocusVisible', {\n    isManuallyActivated: false,\n  });\n\nexport interface UseControlledFocusVisibleResult {\n  isFocusVisible: boolean;\n  activateFocusVisible: () => void;\n}\n\n/**\n * A hook that shares its state using sharedStore and works like useFocusVisible from react-aria,\n * but also returns activateFocusVisible function that manually switches the state to true\n * until the original flag is switched to false.\n */\nexport function useControlledFocusVisible(): UseControlledFocusVisibleResult {\n  // Get the original focus visible state from react-aria\n  const { isFocusVisible: originalIsFocusVisible } = useFocusVisible({});\n\n  // Get the shared store state and setter\n  const [{ isManuallyActivated }, setStore] = useControlledFocusVisibleStore();\n\n  // Reset manual activation when original focus visible becomes false\n  useEffect(() => {\n    if (!originalIsFocusVisible && isManuallyActivated) {\n      setStore({ isManuallyActivated: false });\n    }\n  }, [originalIsFocusVisible, isManuallyActivated, setStore]);\n\n  // Function to manually activate focus visible state\n  const activateFocusVisible = () => {\n    setStore({ isManuallyActivated: true });\n  };\n\n  // Return combined state: true if either original is true OR manually activated\n  return {\n    isFocusVisible: originalIsFocusVisible || isManuallyActivated,\n    activateFocusVisible,\n  };\n}\n"],"mappings":";;;;;;;AAUA,MAAMK,iCACJH,kBAA+C,0BAA0B,EACvEE,qBAAqB,OACtB,CAAC;;;;;;AAYJ,SAAOK,4BAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAAA,IAAAC;AAAA,KAAAF,EAAA,OAAAG,OAAAC,IAAA,4BAAA,EAAA;AAE8DF,OAAA,EAAE;AAAAF,IAAA,KAAAE;OAAAA,MAAAF,EAAA;CAArE,MAAA,EAAAH,gBAAAQ,2BAAmDd,gBAAgBW,GAAG;CAGtE,MAAA,CAAAI,IAAAC,YAA4CZ,gCAAgC;CAArE,MAAA,EAAAD,wBAAAY;CAAuB,IAAAE;CAAA,IAAAC;AAAA,KAAAT,EAAA,OAAAN,uBAAAM,EAAA,OAAAK,0BAAAL,EAAA,OAAAO,UAAA;AAGpBC,aAAA;AACR,OAAI,CAACH,0BAADX,oBACFa,UAAS,EAAAb,qBAAuB,OAAO,CAAC;;AAEzCe,OAAA;GAACJ;GAAwBX;GAAqBa;GAAS;AAAAP,IAAA,KAAAN;AAAAM,IAAA,KAAAK;AAAAL,IAAA,KAAAO;AAAAP,IAAA,KAAAQ;AAAAR,IAAA,KAAAS;QAAA;AAAAD,OAAAR,EAAA;AAAAS,OAAAT,EAAA;;AAJ1DV,WAAUkB,IAIPC,GAAwD;CAAA,IAAAC;AAAA,KAAAV,EAAA,OAAAO,UAAA;AAG9BG,aAAA;AAC3BH,YAAS,EAAAb,qBAAuB,MAAM,CAAC;;AACxCM,IAAA,KAAAO;AAAAP,IAAA,KAAAU;OAAAA,MAAAV,EAAA;CAFD,MAAAF,uBAA6BY;CAMX,MAAAC,KAAAN,0BAAAX;CAA6C,IAAAkB;AAAA,KAAAZ,EAAA,OAAAF,wBAAAE,EAAA,OAAAW,IAAA;AADxDC,OAAA;GAAAf,gBACWc;GAA6Cb;GAE9D;AAAAE,IAAA,KAAAF;AAAAE,IAAA,KAAAW;AAAAX,IAAA,MAAAY;OAAAA,MAAAZ,EAAA;AAAA,QAHMY"}
+{"version":3,"file":"useControlledFocusVisible.js","names":["useEffect","useFocusVisible","createSharedStore","ControlledFocusVisibleState","isManuallyActivated","useControlledFocusVisibleStore","UseControlledFocusVisibleResult","isFocusVisible","activateFocusVisible","useControlledFocusVisible","$","_c","t0","Symbol","for","originalIsFocusVisible","t1","setStore","t2","t3","t4","t5","t6","_c"],"sources":["../../../src/utils/react/useControlledFocusVisible.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useFocusVisible } from 'react-aria';\n\nimport { createSharedStore } from './sharedStore';\n\ninterface ControlledFocusVisibleState {\n  isManuallyActivated: boolean;\n}\n\n// Create a shared store for the controlled focus visible state\nconst useControlledFocusVisibleStore =\n  createSharedStore<ControlledFocusVisibleState>('controlledFocusVisible', {\n    isManuallyActivated: false,\n  });\n\nexport interface UseControlledFocusVisibleResult {\n  isFocusVisible: boolean;\n  activateFocusVisible: () => void;\n}\n\n/**\n * A hook that shares its state using sharedStore and works like useFocusVisible from react-aria,\n * but also returns activateFocusVisible function that manually switches the state to true\n * until the original flag is switched to false.\n */\nexport function useControlledFocusVisible(): UseControlledFocusVisibleResult {\n  // Get the original focus visible state from react-aria\n  const { isFocusVisible: originalIsFocusVisible } = useFocusVisible({});\n\n  // Get the shared store state and setter\n  const [{ isManuallyActivated }, setStore] = useControlledFocusVisibleStore();\n\n  // Reset manual activation when original focus visible becomes false\n  useEffect(() => {\n    if (!originalIsFocusVisible && isManuallyActivated) {\n      setStore({ isManuallyActivated: false });\n    }\n  }, [originalIsFocusVisible, isManuallyActivated, setStore]);\n\n  // Function to manually activate focus visible state\n  const activateFocusVisible = () => {\n    setStore({ isManuallyActivated: true });\n  };\n\n  // Return combined state: true if either original is true OR manually activated\n  return {\n    isFocusVisible: originalIsFocusVisible || isManuallyActivated,\n    activateFocusVisible,\n  };\n}\n"],"mappings":";;;;;;AAUA,MAAMK,iCACJH,kBAA+C,0BAA0B,EACvEE,qBAAqB,MACvB,CAAC;;;;;;AAYH,SAAOK,4BAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAG,OAAAC,IAAA,2BAAA,GAAA;EAE8DF,KAAA,CAAC;EAACF,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAArE,MAAA,EAAAH,gBAAAQ,2BAAmDd,gBAAgBW,EAAE;CAGrE,MAAA,CAAAI,IAAAC,YAA4CZ,+BAA+B;CAApE,MAAA,EAAAD,wBAAAY;CAAuB,IAAAE;CAAA,IAAAC;CAAA,IAAAT,EAAA,OAAAN,uBAAAM,EAAA,OAAAK,0BAAAL,EAAA,OAAAO,UAAA;EAGpBC,WAAA;GACR,IAAI,CAACH,0BAADX,qBACFa,SAAS,EAAAb,qBAAuB,MAAM,CAAC;EACxC;EACAe,KAAA;GAACJ;GAAwBX;GAAqBa;EAAQ;EAACP,EAAA,KAAAN;EAAAM,EAAA,KAAAK;EAAAL,EAAA,KAAAO;EAAAP,EAAA,KAAAQ;EAAAR,EAAA,KAAAS;CAAA,OAAA;EAAAD,KAAAR,EAAA;EAAAS,KAAAT,EAAA;CAAA;CAJ1DV,UAAUkB,IAIPC,EAAuD;CAAC,IAAAC;CAAA,IAAAV,EAAA,OAAAO,UAAA;EAG9BG,WAAA;GAC3BH,SAAS,EAAAb,qBAAuB,KAAK,CAAC;EAAC;EACxCM,EAAA,KAAAO;EAAAP,EAAA,KAAAU;CAAA,OAAAA,KAAAV,EAAA;CAFD,MAAAF,uBAA6BY;CAMX,MAAAC,KAAAN,0BAAAX;CAA6C,IAAAkB;CAAA,IAAAZ,EAAA,OAAAF,wBAAAE,EAAA,OAAAW,IAAA;EADxDC,KAAA;GAAAf,gBACWc;GAA6Cb;EAE/D;EAACE,EAAA,KAAAF;EAAAE,EAAA,KAAAW;EAAAX,EAAA,MAAAY;CAAA,OAAAA,KAAAZ,EAAA;CAAA,OAHMY;AAGN"}

package/dist/utils/react/useEventBus.d.ts

@@ -1,15 +1,14 @@
 
 import React, { ReactNode } from "react";
-
 //#region src/utils/react/useEventBus.d.ts
-type EventBusListener<T = any> = (data: T) => void;
-interface EventBusContextValue {
+export type EventBusListener<T = any> = (data: T) => void;
+export interface EventBusContextValue {
   emit: <T = any>(event: string, data?: T) => void;
   emitSync: <T = any>(event: string, data?: T) => void;
   on: <T = any>(event: string, listener: EventBusListener<T>) => () => void;
   off: <T = any>(event: string, listener: EventBusListener<T>) => void;
 }
-interface EventBusProviderProps {
+export interface EventBusProviderProps {
   children: ReactNode;
 }
 /**
@@ -26,9 +25,7 @@ interface EventBusProviderProps {
  * }
  * ```
  */
-declare function EventBusProvider({
-  children
-}: EventBusProviderProps): React.FunctionComponentElement<React.ProviderProps<EventBusContextValue | null>>;
+export declare function EventBusProvider({ children }: EventBusProviderProps): React.FunctionComponentElement<React.ProviderProps<EventBusContextValue | null>>;
 /**
  * Hook to access the event bus functionality.
  * Must be used within an EventBusProvider.
@@ -63,7 +60,7 @@ declare function EventBusProvider({
  * }
  * ```
  */
-declare function useEventBus(): EventBusContextValue;
+export declare function useEventBus(): EventBusContextValue;
 /**
  * Convenience hook for subscribing to events with automatic cleanup.
  * The listener will be automatically unsubscribed when the component unmounts
@@ -86,7 +83,6 @@ declare function useEventBus(): EventBusContextValue;
  * }
  * ```
  */
-declare function useEventListener<T = any>(event: string, listener: EventBusListener<T>, deps?: React.DependencyList): void;
+export declare function useEventListener<T = any>(event: string, listener: EventBusListener<T>, deps?: React.DependencyList): void;
 //#endregion
-export { EventBusContextValue, EventBusListener, EventBusProvider, useEventBus, useEventListener };
 //# sourceMappingURL=useEventBus.d.ts.map

package/dist/utils/react/useEventBus.js

@@ -1,7 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef } from "react";
-
 //#region src/utils/react/useEventBus.ts
 const EventBusContext = createContext(null);
 /**
@@ -153,7 +152,7 @@ function useEventListener(event, listener, t0) {
 	} else t3 = $[9];
 	useEffect(t2, t3);
 }
-
 //#endregion
 export { EventBusContext, EventBusProvider, useEventBus, useEventListener };
+
 //# sourceMappingURL=useEventBus.js.map

package/dist/utils/react/useEventBus.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEventBus.js","names":["React","createContext","ReactNode","useCallback","useContext","useEffect","useMemo","useRef","EventBusListener","data","T","EventBusContextValue","emit","event","emitSync","on","listener","off","EventBusContext","EventBusProviderProps","children","EventBusProvider","parentBus","listeners","Record","eventListeners","current","filter","l","length","forEach","setTimeout","push","localContextValue","contextValue","createElement","Provider","value","useEventBus","context","Error","useEventListener","t0","$","_c","t1","undefined","deps","t2","unsubscribe","t3"],"sources":["../../../src/utils/react/useEventBus.ts"],"sourcesContent":["import React, {\n  createContext,\n  ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n} from 'react';\n\nexport type EventBusListener<T = any> = (data: T) => void;\n\nexport interface EventBusContextValue {\n  emit: <T = any>(event: string, data?: T) => void;\n  emitSync: <T = any>(event: string, data?: T) => void;\n  on: <T = any>(event: string, listener: EventBusListener<T>) => () => void;\n  off: <T = any>(event: string, listener: EventBusListener<T>) => void;\n}\n\nexport const EventBusContext = createContext<EventBusContextValue | null>(null);\n\nexport interface EventBusProviderProps {\n  children: ReactNode;\n}\n\n/**\n * EventBusProvider provides a global event system for the application.\n *\n * @example\n * ```tsx\n * function App() {\n *   return (\n *     <EventBusProvider>\n *       <YourComponents />\n *     </EventBusProvider>\n *   );\n * }\n * ```\n */\nexport function EventBusProvider({ children }: EventBusProviderProps) {\n  // If we're already inside a parent EventBusProvider (e.g. the global Root\n  // one), DO NOT create a fresh bus — that would isolate listeners and\n  // emitters across the boundary. This matters because overlays (Popover,\n  // Modal, Tray) re-wrap their content with our `Provider` from\n  // `provider.tsx`, which transparently nests an EventBusProvider. Cross-\n  // overlay events such as `popover:dismiss-ancestor` (a Button inside a\n  // popover footer dismissing the popover host) only work when both sides\n  // share the same bus.\n  const parentBus = useContext(EventBusContext);\n\n  const listeners = useRef<Record<string, EventBusListener[]>>({});\n\n  const off = useCallback(\n    <T = any>(event: string, listener: EventBusListener<T>) => {\n      const eventListeners = listeners.current[event];\n      if (eventListeners) {\n        listeners.current[event] = eventListeners.filter((l) => l !== listener);\n\n        // Clean up empty event arrays\n        if (listeners.current[event].length === 0) {\n          delete listeners.current[event];\n        }\n      }\n    },\n    [],\n  );\n\n  const emitSync = useCallback(<T = any>(event: string, data?: T) => {\n    const eventListeners = listeners.current[event];\n    if (eventListeners) {\n      eventListeners.forEach((listener) => listener(data));\n    }\n  }, []);\n\n  const emit = useCallback(\n    <T = any>(event: string, data?: T) => {\n      setTimeout(() => {\n        emitSync(event, data);\n      }, 0);\n    },\n    [emitSync],\n  );\n\n  const on = useCallback(\n    <T = any>(event: string, listener: EventBusListener<T>) => {\n      if (!listeners.current[event]) {\n        listeners.current[event] = [];\n      }\n      listeners.current[event].push(listener);\n\n      // Return cleanup function\n      return () => {\n        off(event, listener);\n      };\n    },\n    [off],\n  );\n\n  // Always compute the local contextValue so hook order stays stable, then\n  // pick parent OR local. `useMemo` keeps the local value referentially\n  // stable across renders — every consumer of `EventBusContext` (notably\n  // `useDismissParentPopover` inside every `Button` / `ItemButton`) would\n  // otherwise re-render on every render of this provider.\n  const localContextValue = useMemo<EventBusContextValue>(\n    () => ({ emit, emitSync, on, off }),\n    [emit, emitSync, on, off],\n  );\n\n  const contextValue = parentBus ?? localContextValue;\n\n  return React.createElement(\n    EventBusContext.Provider,\n    { value: contextValue },\n    children,\n  );\n}\n\n/**\n * Hook to access the event bus functionality.\n * Must be used within an EventBusProvider.\n *\n * @example\n * ```tsx\n * function Component() {\n *   const { emit, emitSync, on } = useEventBus();\n *\n *   const handleClick = () => {\n *     emit('user-action', { type: 'click', target: 'button' });\n *   };\n *\n *   const handleSyncAction = () => {\n *     emitSync('sync-action', { immediate: true });\n *   };\n *\n *   useEffect(() => {\n *     const unsubscribe = on('data-updated', (data) => {\n *       console.log('Data updated:', data);\n *     });\n *\n *     return unsubscribe;\n *   }, [on]);\n *\n *   return (\n *     <div>\n *       <button onClick={handleClick}>Async Event</button>\n *       <button onClick={handleSyncAction}>Sync Event</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useEventBus(): EventBusContextValue {\n  const context = useContext(EventBusContext);\n\n  if (!context) {\n    throw new Error('useEventBus must be used within an EventBusProvider');\n  }\n\n  return context;\n}\n\n/**\n * Convenience hook for subscribing to events with automatic cleanup.\n * The listener will be automatically unsubscribed when the component unmounts\n * or when the dependencies change.\n *\n * @param event - The event name to listen for\n * @param listener - The callback function to execute when the event is emitted\n * @param deps - Dependency array for the effect (similar to useEffect)\n *\n * @example\n * ```tsx\n * function NotificationComponent() {\n *   const [message, setMessage] = useState('');\n *\n *   useEventListener('notification', (data) => {\n *     setMessage(data.message);\n *   }, []);\n *\n *   return <div>{message}</div>;\n * }\n * ```\n */\nexport function useEventListener<T = any>(\n  event: string,\n  listener: EventBusListener<T>,\n  deps: React.DependencyList = [],\n) {\n  const { on } = useEventBus();\n\n  useEffect(() => {\n    const unsubscribe = on(event, listener);\n    return unsubscribe;\n  }, [event, on, ...deps]);\n}\n"],"mappings":";;;;;AAmBA,MAAakB,kBAAkBjB,cAA2C,KAAK;;;;;;;;;;;;;;;AAoB/E,SAAgBoB,iBAAiB,EAAED,YAAmC;CASpE,MAAME,YAAYlB,WAAWc,gBAAgB;CAE7C,MAAMK,YAAYhB,OAA2C,EAAE,CAAC;CAEhE,MAAMU,MAAMd,aACAU,OAAeG,aAAkC;EACzD,MAAMS,iBAAiBF,UAAUG,QAAQb;AACzC,MAAIY,gBAAgB;AAClBF,aAAUG,QAAQb,SAASY,eAAeE,QAAQC,MAAMA,MAAMZ,SAAS;AAGvE,OAAIO,UAAUG,QAAQb,OAAOgB,WAAW,EACtC,QAAON,UAAUG,QAAQb;;IAI/B,EACF,CAAC;CAED,MAAMC,WAAWX,aAAsBU,SAAeJ,SAAa;EACjE,MAAMgB,mBAAiBF,UAAUG,QAAQb;AACzC,MAAIY,iBACFA,kBAAeK,SAASd,eAAaA,WAASP,KAAK,CAAC;IAErD,EAAE,CAAC;CAEN,MAAMG,OAAOT,aACDU,SAAeJ,WAAa;AACpCsB,mBAAiB;AACfjB,YAASD,SAAOJ,OAAK;KACpB,EAAE;IAEP,CAACK,SACH,CAAC;CAED,MAAMC,KAAKZ,aACCU,SAAeG,eAAkC;AACzD,MAAI,CAACO,UAAUG,QAAQb,SACrBU,WAAUG,QAAQb,WAAS,EAAE;AAE/BU,YAAUG,QAAQb,SAAOmB,KAAKhB,WAAS;AAGvC,eAAa;AACXC,OAAIJ,SAAOG,WAAS;;IAGxB,CAACC,IACH,CAAC;CAOD,MAAMgB,oBAAoB3B,eACjB;EAAEM;EAAME;EAAUC;EAAIE;EAAK,GAClC;EAACL;EAAME;EAAUC;EAAIE;EACvB,CAAC;CAED,MAAMiB,eAAeZ,aAAaW;AAElC,QAAOjC,MAAMmC,cACXjB,gBAAgBkB,UAChB,EAAEC,OAAOH,cAAc,EACvBd,SACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCH,SAAOkB,cAAA;CACL,MAAAC,UAAgBnC,WAAWc,gBAAgB;AAE3C,KAAI,CAACqB,QACH,OAAM,IAAIC,MAAM,sDAAsD;AACvE,QAEMD;;;;;;;;;;;;;;;;;;;;;;;;AAyBT,SAAOE,iBAAA5B,OAAAG,UAAA0B,IAAA;CAAA,MAAAC,IAAAC,EAAA,GAAA;CAAA,IAAAC;AAAA,KAAAF,EAAA,OAAAD,IAAA;AAGLG,OAAAH,OAAAI,SAAA,EAA+B,GAA/BJ;AAA+BC,IAAA,KAAAD;AAAAC,IAAA,KAAAE;OAAAA,MAAAF,EAAA;CAA/B,MAAAI,OAAAF;CAEA,MAAA,EAAA9B,OAAeuB,aAAa;CAAC,IAAAU;AAAA,KAAAL,EAAA,OAAA9B,SAAA8B,EAAA,OAAA3B,YAAA2B,EAAA,OAAA5B,IAAA;AAEnBiC,aAAA;AACgC,UAApBjC,GAAGF,OAAOG,SAAS;;AAExC2B,IAAA,KAAA9B;AAAA8B,IAAA,KAAA3B;AAAA2B,IAAA,KAAA5B;AAAA4B,IAAA,KAAAK;OAAAA,MAAAL,EAAA;CAAA,IAAAO;AAAA,KAAAP,EAAA,OAAAI,QAAAJ,EAAA,OAAA9B,SAAA8B,EAAA,OAAA5B,IAAA;AAAEmC,OAAA;GAACrC;GAAOE;GAAE,GAAKgC;GAAK;AAAAJ,IAAA,KAAAI;AAAAJ,IAAA,KAAA9B;AAAA8B,IAAA,KAAA5B;AAAA4B,IAAA,KAAAO;OAAAA,MAAAP,EAAA;AAHvBtC,WAAU2C,IAGPE,GAAqB"}
+{"version":3,"file":"useEventBus.js","names":["React","createContext","ReactNode","useCallback","useContext","useEffect","useMemo","useRef","EventBusListener","data","T","EventBusContextValue","emit","event","emitSync","on","listener","off","EventBusContext","EventBusProviderProps","children","EventBusProvider","parentBus","listeners","Record","eventListeners","current","filter","l","length","forEach","setTimeout","push","localContextValue","contextValue","createElement","Provider","value","useEventBus","context","Error","useEventListener","t0","$","_c","t1","undefined","deps","t2","unsubscribe","t3","_c"],"sources":["../../../src/utils/react/useEventBus.ts"],"sourcesContent":["import React, {\n  createContext,\n  ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n} from 'react';\n\nexport type EventBusListener<T = any> = (data: T) => void;\n\nexport interface EventBusContextValue {\n  emit: <T = any>(event: string, data?: T) => void;\n  emitSync: <T = any>(event: string, data?: T) => void;\n  on: <T = any>(event: string, listener: EventBusListener<T>) => () => void;\n  off: <T = any>(event: string, listener: EventBusListener<T>) => void;\n}\n\nexport const EventBusContext = createContext<EventBusContextValue | null>(null);\n\nexport interface EventBusProviderProps {\n  children: ReactNode;\n}\n\n/**\n * EventBusProvider provides a global event system for the application.\n *\n * @example\n * ```tsx\n * function App() {\n *   return (\n *     <EventBusProvider>\n *       <YourComponents />\n *     </EventBusProvider>\n *   );\n * }\n * ```\n */\nexport function EventBusProvider({ children }: EventBusProviderProps) {\n  // If we're already inside a parent EventBusProvider (e.g. the global Root\n  // one), DO NOT create a fresh bus — that would isolate listeners and\n  // emitters across the boundary. This matters because overlays (Popover,\n  // Modal, Tray) re-wrap their content with our `Provider` from\n  // `provider.tsx`, which transparently nests an EventBusProvider. Cross-\n  // overlay events such as `popover:dismiss-ancestor` (a Button inside a\n  // popover footer dismissing the popover host) only work when both sides\n  // share the same bus.\n  const parentBus = useContext(EventBusContext);\n\n  const listeners = useRef<Record<string, EventBusListener[]>>({});\n\n  const off = useCallback(\n    <T = any>(event: string, listener: EventBusListener<T>) => {\n      const eventListeners = listeners.current[event];\n      if (eventListeners) {\n        listeners.current[event] = eventListeners.filter((l) => l !== listener);\n\n        // Clean up empty event arrays\n        if (listeners.current[event].length === 0) {\n          delete listeners.current[event];\n        }\n      }\n    },\n    [],\n  );\n\n  const emitSync = useCallback(<T = any>(event: string, data?: T) => {\n    const eventListeners = listeners.current[event];\n    if (eventListeners) {\n      eventListeners.forEach((listener) => listener(data));\n    }\n  }, []);\n\n  const emit = useCallback(\n    <T = any>(event: string, data?: T) => {\n      setTimeout(() => {\n        emitSync(event, data);\n      }, 0);\n    },\n    [emitSync],\n  );\n\n  const on = useCallback(\n    <T = any>(event: string, listener: EventBusListener<T>) => {\n      if (!listeners.current[event]) {\n        listeners.current[event] = [];\n      }\n      listeners.current[event].push(listener);\n\n      // Return cleanup function\n      return () => {\n        off(event, listener);\n      };\n    },\n    [off],\n  );\n\n  // Always compute the local contextValue so hook order stays stable, then\n  // pick parent OR local. `useMemo` keeps the local value referentially\n  // stable across renders — every consumer of `EventBusContext` (notably\n  // `useDismissParentPopover` inside every `Button` / `ItemButton`) would\n  // otherwise re-render on every render of this provider.\n  const localContextValue = useMemo<EventBusContextValue>(\n    () => ({ emit, emitSync, on, off }),\n    [emit, emitSync, on, off],\n  );\n\n  const contextValue = parentBus ?? localContextValue;\n\n  return React.createElement(\n    EventBusContext.Provider,\n    { value: contextValue },\n    children,\n  );\n}\n\n/**\n * Hook to access the event bus functionality.\n * Must be used within an EventBusProvider.\n *\n * @example\n * ```tsx\n * function Component() {\n *   const { emit, emitSync, on } = useEventBus();\n *\n *   const handleClick = () => {\n *     emit('user-action', { type: 'click', target: 'button' });\n *   };\n *\n *   const handleSyncAction = () => {\n *     emitSync('sync-action', { immediate: true });\n *   };\n *\n *   useEffect(() => {\n *     const unsubscribe = on('data-updated', (data) => {\n *       console.log('Data updated:', data);\n *     });\n *\n *     return unsubscribe;\n *   }, [on]);\n *\n *   return (\n *     <div>\n *       <button onClick={handleClick}>Async Event</button>\n *       <button onClick={handleSyncAction}>Sync Event</button>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useEventBus(): EventBusContextValue {\n  const context = useContext(EventBusContext);\n\n  if (!context) {\n    throw new Error('useEventBus must be used within an EventBusProvider');\n  }\n\n  return context;\n}\n\n/**\n * Convenience hook for subscribing to events with automatic cleanup.\n * The listener will be automatically unsubscribed when the component unmounts\n * or when the dependencies change.\n *\n * @param event - The event name to listen for\n * @param listener - The callback function to execute when the event is emitted\n * @param deps - Dependency array for the effect (similar to useEffect)\n *\n * @example\n * ```tsx\n * function NotificationComponent() {\n *   const [message, setMessage] = useState('');\n *\n *   useEventListener('notification', (data) => {\n *     setMessage(data.message);\n *   }, []);\n *\n *   return <div>{message}</div>;\n * }\n * ```\n */\nexport function useEventListener<T = any>(\n  event: string,\n  listener: EventBusListener<T>,\n  deps: React.DependencyList = [],\n) {\n  const { on } = useEventBus();\n\n  useEffect(() => {\n    const unsubscribe = on(event, listener);\n    return unsubscribe;\n  }, [event, on, ...deps]);\n}\n"],"mappings":";;;;AAmBA,MAAakB,kBAAkBjB,cAA2C,IAAI;;;;;;;;;;;;;;;AAoB9E,SAAgBoB,iBAAiB,EAAED,YAAmC;CASpE,MAAME,YAAYlB,WAAWc,eAAe;CAE5C,MAAMK,YAAYhB,OAA2C,CAAC,CAAC;CAE/D,MAAMU,MAAMd,aACAU,OAAeG,aAAkC;EACzD,MAAMS,iBAAiBF,UAAUG,QAAQb;EACzC,IAAIY,gBAAgB;GAClBF,UAAUG,QAAQb,SAASY,eAAeE,QAAQC,MAAMA,MAAMZ,QAAQ;GAGtE,IAAIO,UAAUG,QAAQb,MAAM,CAACgB,WAAW,GACtC,OAAON,UAAUG,QAAQb;EAE7B;CACF,GACA,CAAA,CACF;CAEA,MAAMC,WAAWX,aAAsBU,SAAeJ,SAAa;EACjE,MAAMgB,mBAAiBF,UAAUG,QAAQb;EACzC,IAAIY,kBACFA,iBAAeK,SAASd,eAAaA,WAASP,IAAI,CAAC;CAEvD,GAAG,CAAA,CAAE;CAEL,MAAMG,OAAOT,aACDU,SAAeJ,WAAa;EACpCsB,iBAAiB;GACfjB,SAASD,SAAOJ,MAAI;EACtB,GAAG,CAAC;CACN,GACA,CAACK,QAAQ,CACX;CAEA,MAAMC,KAAKZ,aACCU,SAAeG,eAAkC;EACzD,IAAI,CAACO,UAAUG,QAAQb,UACrBU,UAAUG,QAAQb,WAAS,CAAA;EAE7BU,UAAUG,QAAQb,QAAM,CAACmB,KAAKhB,UAAQ;EAGtC,aAAa;GACXC,IAAIJ,SAAOG,UAAQ;EACrB;CACF,GACA,CAACC,GAAG,CACN;CAOA,MAAMgB,oBAAoB3B,eACjB;EAAEM;EAAME;EAAUC;EAAIE;CAAI,IACjC;EAACL;EAAME;EAAUC;EAAIE;CAAG,CAC1B;CAEA,MAAMiB,eAAeZ,aAAaW;CAElC,OAAOjC,MAAMmC,cACXjB,gBAAgBkB,UAChB,EAAEC,OAAOH,aAAa,GACtBd,QACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAOkB,cAAA;CACL,MAAAC,UAAgBnC,WAAWc,eAAe;CAE1C,IAAI,CAACqB,SACH,MAAM,IAAIC,MAAM,qDAAqD;CACtE,OAEMD;AAAO;;;;;;;;;;;;;;;;;;;;;;;AAyBhB,SAAOE,iBAAA5B,OAAAG,UAAA0B,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAD,IAAA;EAGLG,KAAAH,OAAAI,KAAAA,IAAA,CAAA,IAAAJ;EAA+BC,EAAA,KAAAD;EAAAC,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAA/B,MAAAI,OAAAF;CAEA,MAAA,EAAA9B,OAAeuB,YAAY;CAAE,IAAAU;CAAA,IAAAL,EAAA,OAAA9B,SAAA8B,EAAA,OAAA3B,YAAA2B,EAAA,OAAA5B,IAAA;EAEnBiC,WAAA;GACgC,OAApBjC,GAAGF,OAAOG,QACvBiC;EAAW;EACnBN,EAAA,KAAA9B;EAAA8B,EAAA,KAAA3B;EAAA2B,EAAA,KAAA5B;EAAA4B,EAAA,KAAAK;CAAA,OAAAA,KAAAL,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAI,QAAAJ,EAAA,OAAA9B,SAAA8B,EAAA,OAAA5B,IAAA;EAAEmC,KAAA;GAACrC;GAAOE;GAAE,GAAKgC;EAAI;EAACJ,EAAA,KAAAI;EAAAJ,EAAA,KAAA9B;EAAA8B,EAAA,KAAA5B;EAAA4B,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAHvBtC,UAAU2C,IAGPE,EAAoB;AAAC"}

package/dist/utils/react/useId.js

@@ -1,9 +1,8 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useLayoutEffect as useLayoutEffect$1 } from "./useLayoutEffect.js";
-import { c } from "react/compiler-runtime";
+import "react/compiler-runtime";
 import { useEffect, useRef, useState } from "react";
 import { useSSRSafeId } from "@react-aria/ssr";
-
 //#region src/utils/react/useId.tsx
 let idsUpdaterMap = /* @__PURE__ */ new Map();
 /**
@@ -51,7 +50,7 @@ function mergeIds(idA, idB) {
 	}
 	return idB;
 }
-
 //#endregion
 export { mergeIds, useId$1 as useId };
+
 //# sourceMappingURL=useId.js.map

package/dist/utils/react/useId.js.map

@@ -1 +1 @@
-{"version":3,"file":"useId.js","names":["useSSRSafeId","useEffect","useRef","useState","useLayoutEffect","idsUpdaterMap","Map","useId","defaultId","isRendering","current","value","setValue","nextId","updateValue","val","newId","res","set","mergeIds","idA","idB","setIdA","get","setIdB","useSlotId","$","_c","id","setId","t0","t1","setCurr","document","getElementById"],"sources":["../../../src/utils/react/useId.tsx"],"sourcesContent":["import { useSSRSafeId } from '@react-aria/ssr';\nimport { useEffect, useRef, useState } from 'react';\n\nimport { useLayoutEffect } from './useLayoutEffect';\n\nlet idsUpdaterMap = new Map();\n\n/**\n * If a default is not provided, generate an id.\n * @param defaultId - Default component id.\n */\nexport function useId(defaultId?) {\n  let isRendering = useRef(true);\n\n  isRendering.current = true;\n\n  let [value, setValue] = useState(defaultId);\n  let nextId = useRef(null);\n\n  // don't memo this, we want it new each render so that the Effects always run\n\n  let updateValue = (val) => {\n    if (!isRendering.current) {\n      setValue(val);\n    } else {\n      nextId.current = val;\n    }\n  };\n\n  useLayoutEffect(() => {\n    isRendering.current = false;\n  });\n\n  useEffect(() => {\n    let newId = nextId.current;\n    if (newId) {\n      setValue(newId);\n      nextId.current = null;\n    }\n  }, [setValue, updateValue]);\n\n  let res = useSSRSafeId(value);\n  idsUpdaterMap.set(res, updateValue);\n  return res;\n}\n\n/**\n * Merges two ids.\n * Different ids will trigger a side-effect and re-render components hooked up with `useId`.\n */\nexport function mergeIds(idA, idB) {\n  if (idA === idB) {\n    return idA;\n  }\n\n  let setIdA = idsUpdaterMap.get(idA);\n  if (setIdA) {\n    setIdA(idB);\n    return idB;\n  }\n\n  let setIdB = idsUpdaterMap.get(idB);\n  if (setIdB) {\n    setIdB(idA);\n    return idA;\n  }\n\n  return idB;\n}\n\n/**\n * Used to generate an id, and after render, check if that id is rendered so we know\n * if we can use it in places such as labelledby.\n */\nexport function useSlotId() {\n  let [id, setId] = useState<string | null>(useId());\n  useLayoutEffect(() => {\n    if (id) {\n      let setCurr = idsUpdaterMap.get(id);\n      if (setCurr && !document.getElementById(id)) {\n        setId(null);\n      }\n    }\n  }, [id]);\n\n  return id;\n}\n"],"mappings":";;;;;;;AAKA,IAAIK,gCAAgB,IAAIC,KAAK;;;;;AAM7B,SAAgBC,QAAMC,WAAY;CAChC,IAAIC,cAAcP,OAAO,KAAK;AAE9BO,aAAYC,UAAU;CAEtB,IAAI,CAACC,OAAOC,YAAYT,SAASK,UAAU;CAC3C,IAAIK,SAASX,OAAO,KAAK;CAIzB,IAAIY,eAAeC,QAAQ;AACzB,MAAI,CAACN,YAAYC,QACfE,UAASG,IAAI;MAEbF,QAAOH,UAAUK;;AAIrBX,yBAAsB;AACpBK,cAAYC,UAAU;GACtB;AAEFT,iBAAgB;EACd,IAAIe,QAAQH,OAAOH;AACnB,MAAIM,OAAO;AACTJ,YAASI,MAAM;AACfH,UAAOH,UAAU;;IAElB,CAACE,UAAUE,YAAY,CAAC;CAE3B,IAAIG,MAAMjB,aAAaW,MAAM;AAC7BN,eAAca,IAAID,KAAKH,YAAY;AACnC,QAAOG;;;;;;AAOT,SAAgBE,SAASC,KAAKC,KAAK;AACjC,KAAID,QAAQC,IACV,QAAOD;CAGT,IAAIE,SAASjB,cAAckB,IAAIH,IAAI;AACnC,KAAIE,QAAQ;AACVA,SAAOD,IAAI;AACX,SAAOA;;CAGT,IAAIG,SAASnB,cAAckB,IAAIF,IAAI;AACnC,KAAIG,QAAQ;AACVA,SAAOJ,IAAI;AACX,SAAOA;;AAGT,QAAOC"}
+{"version":3,"file":"useId.js","names":["useSSRSafeId","useEffect","useRef","useState","useLayoutEffect","idsUpdaterMap","Map","useId","defaultId","isRendering","current","value","setValue","nextId","updateValue","val","newId","res","set","mergeIds","idA","idB","setIdA","get","setIdB","useSlotId","$","_c","id","setId","t0","t1","setCurr","document","getElementById","useId"],"sources":["../../../src/utils/react/useId.tsx"],"sourcesContent":["import { useSSRSafeId } from '@react-aria/ssr';\nimport { useEffect, useRef, useState } from 'react';\n\nimport { useLayoutEffect } from './useLayoutEffect';\n\nlet idsUpdaterMap = new Map();\n\n/**\n * If a default is not provided, generate an id.\n * @param defaultId - Default component id.\n */\nexport function useId(defaultId?) {\n  let isRendering = useRef(true);\n\n  isRendering.current = true;\n\n  let [value, setValue] = useState(defaultId);\n  let nextId = useRef(null);\n\n  // don't memo this, we want it new each render so that the Effects always run\n\n  let updateValue = (val) => {\n    if (!isRendering.current) {\n      setValue(val);\n    } else {\n      nextId.current = val;\n    }\n  };\n\n  useLayoutEffect(() => {\n    isRendering.current = false;\n  });\n\n  useEffect(() => {\n    let newId = nextId.current;\n    if (newId) {\n      setValue(newId);\n      nextId.current = null;\n    }\n  }, [setValue, updateValue]);\n\n  let res = useSSRSafeId(value);\n  idsUpdaterMap.set(res, updateValue);\n  return res;\n}\n\n/**\n * Merges two ids.\n * Different ids will trigger a side-effect and re-render components hooked up with `useId`.\n */\nexport function mergeIds(idA, idB) {\n  if (idA === idB) {\n    return idA;\n  }\n\n  let setIdA = idsUpdaterMap.get(idA);\n  if (setIdA) {\n    setIdA(idB);\n    return idB;\n  }\n\n  let setIdB = idsUpdaterMap.get(idB);\n  if (setIdB) {\n    setIdB(idA);\n    return idA;\n  }\n\n  return idB;\n}\n\n/**\n * Used to generate an id, and after render, check if that id is rendered so we know\n * if we can use it in places such as labelledby.\n */\nexport function useSlotId() {\n  let [id, setId] = useState<string | null>(useId());\n  useLayoutEffect(() => {\n    if (id) {\n      let setCurr = idsUpdaterMap.get(id);\n      if (setCurr && !document.getElementById(id)) {\n        setId(null);\n      }\n    }\n  }, [id]);\n\n  return id;\n}\n"],"mappings":";;;;;;AAKA,IAAIK,gCAAgB,IAAIC,IAAI;;;;;AAM5B,SAAgBC,QAAMC,WAAY;CAChC,IAAIC,cAAcP,OAAO,IAAI;CAE7BO,YAAYC,UAAU;CAEtB,IAAI,CAACC,OAAOC,YAAYT,SAASK,SAAS;CAC1C,IAAIK,SAASX,OAAO,IAAI;CAIxB,IAAIY,eAAeC,QAAQ;EACzB,IAAI,CAACN,YAAYC,SACfE,SAASG,GAAG;OAEZF,OAAOH,UAAUK;CAErB;CAEAX,wBAAsB;EACpBK,YAAYC,UAAU;CACxB,CAAC;CAEDT,gBAAgB;EACd,IAAIe,QAAQH,OAAOH;EACnB,IAAIM,OAAO;GACTJ,SAASI,KAAK;GACdH,OAAOH,UAAU;EACnB;CACF,GAAG,CAACE,UAAUE,WAAW,CAAC;CAE1B,IAAIG,MAAMjB,aAAaW,KAAK;CAC5BN,cAAca,IAAID,KAAKH,WAAW;CAClC,OAAOG;AACT;;;;;AAMA,SAAgBE,SAASC,KAAKC,KAAK;CACjC,IAAID,QAAQC,KACV,OAAOD;CAGT,IAAIE,SAASjB,cAAckB,IAAIH,GAAG;CAClC,IAAIE,QAAQ;EACVA,OAAOD,GAAG;EACV,OAAOA;CACT;CAEA,IAAIG,SAASnB,cAAckB,IAAIF,GAAG;CAClC,IAAIG,QAAQ;EACVA,OAAOJ,GAAG;EACV,OAAOA;CACT;CAEA,OAAOC;AACT"}

package/dist/utils/react/useIsDarwin.js

@@ -1,7 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { c } from "react/compiler-runtime";
 import { useEffect, useState } from "react";
-
 //#region src/utils/react/useIsDarwin.ts
 /**
 * useIsDarwin
@@ -43,7 +42,7 @@ function useIsDarwin(t0) {
 	useEffect(t1, t2);
 	return isDarwin;
 }
-
 //#endregion
 export { useIsDarwin };
+
 //# sourceMappingURL=useIsDarwin.js.map

package/dist/utils/react/useIsDarwin.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIsDarwin.js","names":["useEffect","useState","useIsDarwin","t0","$","_c","defaultValue","undefined","isDarwin","setIsDarwin","t1","t2","Symbol","for","navigator","chPlatform","userAgentData","platform","test","userAgent"],"sources":["../../../src/utils/react/useIsDarwin.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * useIsDarwin\n * ----------\n * @returns true  – if the browser is running on macOS / iOS\n *          false – otherwise (Windows, Linux, Android…)\n *\n * • Safe to call during server-side rendering: it defaults to `true`\n *   until it can really inspect the client.\n * • Uses the modern UA-Client-Hints platform field where available,\n *   then falls back to navigator.platform, then navigator.userAgent.\n */\nexport function useIsDarwin(defaultValue: boolean = true): boolean {\n  const [isDarwin, setIsDarwin] = useState<boolean>(defaultValue);\n\n  useEffect(() => {\n    if (typeof navigator === 'undefined') return; // ← running on the server\n\n    // 1 — Prefer UA-CH (Chromium 89+, Edge 94+, Arc, Opera, Android Chrome)\n    const chPlatform = (navigator as any).userAgentData?.platform;\n    if (chPlatform) {\n      setIsDarwin(/mac|iphone|ipad|ipod/i.test(chPlatform));\n      return;\n    }\n\n    // 2 — Safari & Firefox: navigator.platform is still reliable\n    if (navigator.platform) {\n      setIsDarwin(/mac|iphone|ipad|ipod/i.test(navigator.platform));\n      return;\n    }\n\n    // 3 — Last-ditch for very old browsers\n    setIsDarwin(/mac|iphone|ipad|ipod/i.test(navigator.userAgent));\n  }, []);\n\n  return isDarwin;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAaA,SAAOE,YAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CACL,MAAA,CAAAG,UAAAC,eAAgCR,SADNE,OAAAI,SAAA,OAAAJ,GACqC;CAAC,IAAAO;CAAA,IAAAC;AAAA,KAAAP,EAAA,OAAAQ,OAAAC,IAAA,4BAAA,EAAA;AAEtDH,aAAA;AACR,OAAI,OAAOI,cAAc,YAAW;GAGpC,MAAAC,aAAoBD,UAAgBE,eAAyBC;AAC7D,OAAIF,YAAU;AACZN,gBAAY,wBAAuBS,KAAMH,WAAW,CAAC;AAAA;;AAKvD,OAAID,UAASG,UAAS;AACpBR,gBAAY,wBAAuBS,KAAMJ,UAASG,SAAU,CAAC;AAAA;;AAK/DR,eAAY,wBAAuBS,KAAMJ,UAASK,UAAW,CAAC;;AAC7DR,OAAA,EAAE;AAAAP,IAAA,KAAAM;AAAAN,IAAA,KAAAO;QAAA;AAAAD,OAAAN,EAAA;AAAAO,OAAAP,EAAA;;AAlBLJ,WAAUU,IAkBPC,GAAG;AAAA,QAECH"}
+{"version":3,"file":"useIsDarwin.js","names":["useEffect","useState","useIsDarwin","t0","$","_c","defaultValue","undefined","isDarwin","setIsDarwin","t1","t2","Symbol","for","navigator","chPlatform","userAgentData","platform","test","userAgent","_c"],"sources":["../../../src/utils/react/useIsDarwin.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * useIsDarwin\n * ----------\n * @returns true  – if the browser is running on macOS / iOS\n *          false – otherwise (Windows, Linux, Android…)\n *\n * • Safe to call during server-side rendering: it defaults to `true`\n *   until it can really inspect the client.\n * • Uses the modern UA-Client-Hints platform field where available,\n *   then falls back to navigator.platform, then navigator.userAgent.\n */\nexport function useIsDarwin(defaultValue: boolean = true): boolean {\n  const [isDarwin, setIsDarwin] = useState<boolean>(defaultValue);\n\n  useEffect(() => {\n    if (typeof navigator === 'undefined') return; // ← running on the server\n\n    // 1 — Prefer UA-CH (Chromium 89+, Edge 94+, Arc, Opera, Android Chrome)\n    const chPlatform = (navigator as any).userAgentData?.platform;\n    if (chPlatform) {\n      setIsDarwin(/mac|iphone|ipad|ipod/i.test(chPlatform));\n      return;\n    }\n\n    // 2 — Safari & Firefox: navigator.platform is still reliable\n    if (navigator.platform) {\n      setIsDarwin(/mac|iphone|ipad|ipod/i.test(navigator.platform));\n      return;\n    }\n\n    // 3 — Last-ditch for very old browsers\n    setIsDarwin(/mac|iphone|ipad|ipod/i.test(navigator.userAgent));\n  }, []);\n\n  return isDarwin;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAaA,SAAOE,YAAAC,IAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAA,CAAAG,UAAAC,eAAgCR,SADNE,OAAAI,KAAAA,IAAA,OAAAJ,EACoC;CAAE,IAAAO;CAAA,IAAAC;CAAA,IAAAP,EAAA,OAAAQ,OAAAC,IAAA,2BAAA,GAAA;EAEtDH,WAAA;GACR,IAAI,OAAOI,cAAc,aAAW;GAGpC,MAAAC,aAAoBD,UAAgBE,eAAyBC;GAC7D,IAAIF,YAAU;IACZN,YAAY,wBAAuBS,KAAMH,UAAU,CAAC;IAAC;GAAA;GAKvD,IAAID,UAASG,UAAS;IACpBR,YAAY,wBAAuBS,KAAMJ,UAASG,QAAS,CAAC;IAAC;GAAA;GAK/DR,YAAY,wBAAuBS,KAAMJ,UAASK,SAAU,CAAC;EAAC;EAC7DR,KAAA,CAAA;EAAEP,EAAA,KAAAM;EAAAN,EAAA,KAAAO;CAAA,OAAA;EAAAD,KAAAN,EAAA;EAAAO,KAAAP,EAAA;CAAA;CAlBLJ,UAAUU,IAkBPC,EAAE;CAAC,OAECH;AAAQ"}

package/dist/utils/react/useKeySymbols.js

@@ -1,7 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useIsDarwin } from "./useIsDarwin.js";
 import { c } from "react/compiler-runtime";
-
 //#region src/utils/react/useKeySymbols.ts
 const COMMON = {
 	esc: "Esc",
@@ -76,7 +75,7 @@ function useKeySymbols(combo) {
 function _temp(raw) {
 	return raw.trim().toLowerCase();
 }
-
 //#endregion
 export { useKeySymbols };
+
 //# sourceMappingURL=useKeySymbols.js.map

package/dist/utils/react/useKeySymbols.js.map

@@ -1 +1 @@
-{"version":3,"file":"useKeySymbols.js","names":["useIsDarwin","COMMON","Record","esc","escape","enter","return","space","backspace","delete","up","arrowup","down","arrowdown","left","arrowleft","right","arrowright","MAC","mod","meta","cmd","command","ctrl","control","alt","option","shift","PC","win","windows","useKeySymbols","combo","$","_c","isDarwin","modifiers","t0","t1","alternative","split","map","part","key","trim","toUpperCase","_temp","filter","Boolean","raw","toLowerCase"],"sources":["../../../src/utils/react/useKeySymbols.ts"],"sourcesContent":["import { useIsDarwin } from './useIsDarwin';\n\n/* symbols that are identical on every OS */\nconst COMMON: Record<string, string> = {\n  esc: 'Esc',\n  escape: 'Esc',\n  enter: '⏎',\n  return: '⏎',\n  space: '␣',\n  backspace: '⌫',\n  delete: '⌦',\n  up: '↑',\n  arrowup: '↑',\n  down: '↓',\n  arrowdown: '↓',\n  left: '←',\n  arrowleft: '←',\n  right: '→',\n  arrowright: '→',\n};\n\n/* modifiers for macOS / iOS */\nconst MAC: Record<string, string> = {\n  mod: '⌘',\n  meta: '⌘',\n  cmd: '⌘',\n  command: '⌘',\n  ctrl: '⌃',\n  control: '⌃',\n  alt: '⌥',\n  option: '⌥',\n  shift: '⇧',\n};\n\n/* modifiers for Windows / Linux */\nconst PC: Record<string, string> = {\n  mod: 'Ctrl',\n  ctrl: 'Ctrl',\n  control: 'Ctrl',\n  meta: 'Win',\n  win: 'Win',\n  windows: 'Win',\n  cmd: 'Win',\n  command: 'Win',\n  alt: '⎇',\n  option: '⎇',\n  shift: '⇧',\n};\n\n/**\n * useKeySymbols\n * -------------\n * Turns an author string such as\n *   \"mod+k, ctrl+k\"\n * into\n *   [[\"⌘\", \"K\"], [\"Ctrl\", \"K\"]]\n */\nexport function useKeySymbols(combo: string): string[][] {\n  const isDarwin = useIsDarwin(); // ⌘ by default during SSR\n  const modifiers = isDarwin ? MAC : PC;\n\n  /** split on commas, trim each alternative */\n  return combo\n    .split(',')\n    .map((raw) => raw.trim().toLowerCase())\n    .filter(Boolean) // drop empty fragments\n    .map((alternative) =>\n      alternative.split('+').map((part) => {\n        const key = part.trim();\n        return (\n          modifiers[key] ?? // platform-specific modifier\n          COMMON[key] ?? // shared glyphs\n          part.toUpperCase() // plain key\n        );\n      }),\n    );\n}\n"],"mappings":";;;;;AAGA,MAAMC,SAAiC;CACrCE,KAAK;CACLC,QAAQ;CACRC,OAAO;CACPC,QAAQ;CACRC,OAAO;CACPC,WAAW;CACXC,QAAQ;CACRC,IAAI;CACJC,SAAS;CACTC,MAAM;CACNC,WAAW;CACXC,MAAM;CACNC,WAAW;CACXC,OAAO;CACPC,YAAY;CACb;AAGD,MAAMC,MAA8B;CAClCC,KAAK;CACLC,MAAM;CACNC,KAAK;CACLC,SAAS;CACTC,MAAM;CACNC,SAAS;CACTC,KAAK;CACLC,QAAQ;CACRC,OAAO;CACR;AAGD,MAAMC,KAA6B;CACjCT,KAAK;CACLI,MAAM;CACNC,SAAS;CACTJ,MAAM;CACNS,KAAK;CACLC,SAAS;CACTT,KAAK;CACLC,SAAS;CACTG,KAAK;CACLC,QAAQ;CACRC,OAAO;CACR;;;;;;;;;AAUD,SAAOI,cAAAC,OAAA;CAAA,MAAAC,IAAAC,EAAA,EAAA;CAEL,MAAAE,YADiBpC,aAAa,GACZkB,MAAAU;CAAoB,IAAAS;AAAA,KAAAJ,EAAA,OAAAD,SAAAC,EAAA,OAAAG,WAAA;EAAA,IAAAE;AAAA,MAAAL,EAAA,OAAAG,WAAA;AAO/BE,SAAAC,gBACHA,YAAWC,MAAO,IAAI,CAAAC,KAAKC,SAAA;IACzB,MAAAC,MAAYD,KAAIE,MAAO;AAAC,WAEtBR,UAAUO,QACV1C,OAAO0C,QACPD,KAAIG,aAAc;KAEpB;AAAAZ,KAAA,KAAAG;AAAAH,KAAA,KAAAK;QAAAA,MAAAL,EAAA;AAZCI,OAAAL,MAAKQ,MACH,IAAI,CAAAC,IACNK,MAAkC,CAAAC,OAC/BC,QAAQ,CAAAP,IACXH,GASJ;AAAAL,IAAA,KAAAD;AAAAC,IAAA,KAAAG;AAAAH,IAAA,KAAAI;OAAAA,MAAAJ,EAAA;AAAA,QAbII;;AALF,SAAAS,MAAAG,KAAA;AAAA,QAOWA,IAAGL,MAAO,CAAAM,aAAc"}
+{"version":3,"file":"useKeySymbols.js","names":["useIsDarwin","COMMON","Record","esc","escape","enter","return","space","backspace","delete","up","arrowup","down","arrowdown","left","arrowleft","right","arrowright","MAC","mod","meta","cmd","command","ctrl","control","alt","option","shift","PC","win","windows","useKeySymbols","combo","$","_c","isDarwin","modifiers","t0","t1","alternative","split","map","part","key","trim","toUpperCase","_temp","filter","Boolean","raw","toLowerCase","_c"],"sources":["../../../src/utils/react/useKeySymbols.ts"],"sourcesContent":["import { useIsDarwin } from './useIsDarwin';\n\n/* symbols that are identical on every OS */\nconst COMMON: Record<string, string> = {\n  esc: 'Esc',\n  escape: 'Esc',\n  enter: '⏎',\n  return: '⏎',\n  space: '␣',\n  backspace: '⌫',\n  delete: '⌦',\n  up: '↑',\n  arrowup: '↑',\n  down: '↓',\n  arrowdown: '↓',\n  left: '←',\n  arrowleft: '←',\n  right: '→',\n  arrowright: '→',\n};\n\n/* modifiers for macOS / iOS */\nconst MAC: Record<string, string> = {\n  mod: '⌘',\n  meta: '⌘',\n  cmd: '⌘',\n  command: '⌘',\n  ctrl: '⌃',\n  control: '⌃',\n  alt: '⌥',\n  option: '⌥',\n  shift: '⇧',\n};\n\n/* modifiers for Windows / Linux */\nconst PC: Record<string, string> = {\n  mod: 'Ctrl',\n  ctrl: 'Ctrl',\n  control: 'Ctrl',\n  meta: 'Win',\n  win: 'Win',\n  windows: 'Win',\n  cmd: 'Win',\n  command: 'Win',\n  alt: '⎇',\n  option: '⎇',\n  shift: '⇧',\n};\n\n/**\n * useKeySymbols\n * -------------\n * Turns an author string such as\n *   \"mod+k, ctrl+k\"\n * into\n *   [[\"⌘\", \"K\"], [\"Ctrl\", \"K\"]]\n */\nexport function useKeySymbols(combo: string): string[][] {\n  const isDarwin = useIsDarwin(); // ⌘ by default during SSR\n  const modifiers = isDarwin ? MAC : PC;\n\n  /** split on commas, trim each alternative */\n  return combo\n    .split(',')\n    .map((raw) => raw.trim().toLowerCase())\n    .filter(Boolean) // drop empty fragments\n    .map((alternative) =>\n      alternative.split('+').map((part) => {\n        const key = part.trim();\n        return (\n          modifiers[key] ?? // platform-specific modifier\n          COMMON[key] ?? // shared glyphs\n          part.toUpperCase() // plain key\n        );\n      }),\n    );\n}\n"],"mappings":";;;;AAGA,MAAMC,SAAiC;CACrCE,KAAK;CACLC,QAAQ;CACRC,OAAO;CACPC,QAAQ;CACRC,OAAO;CACPC,WAAW;CACXC,QAAQ;CACRC,IAAI;CACJC,SAAS;CACTC,MAAM;CACNC,WAAW;CACXC,MAAM;CACNC,WAAW;CACXC,OAAO;CACPC,YAAY;AACd;AAGA,MAAMC,MAA8B;CAClCC,KAAK;CACLC,MAAM;CACNC,KAAK;CACLC,SAAS;CACTC,MAAM;CACNC,SAAS;CACTC,KAAK;CACLC,QAAQ;CACRC,OAAO;AACT;AAGA,MAAMC,KAA6B;CACjCT,KAAK;CACLI,MAAM;CACNC,SAAS;CACTJ,MAAM;CACNS,KAAK;CACLC,SAAS;CACTT,KAAK;CACLC,SAAS;CACTG,KAAK;CACLC,QAAQ;CACRC,OAAO;AACT;;;;;;;;;AAUA,SAAOI,cAAAC,OAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CAEL,MAAAE,YADiBpC,YACCmC,IAAAjB,MAAAU;CAAoB,IAAAS;CAAA,IAAAJ,EAAA,OAAAD,SAAAC,EAAA,OAAAG,WAAA;EAAA,IAAAE;EAAA,IAAAL,EAAA,OAAAG,WAAA;GAO/BE,MAAAC,gBACHA,YAAWC,MAAO,GAAG,CAAC,CAAAC,KAAKC,SAAA;IACzB,MAAAC,MAAYD,KAAIE,KAAM;IAAE,OAEtBR,UAAUO,QACV1C,OAAO0C,QACPD,KAAIG,YAAa;GAAC,CAErB;GAACZ,EAAA,KAAAG;GAAAH,EAAA,KAAAK;EAAA,OAAAA,KAAAL,EAAA;EAZCI,KAAAL,MAAKQ,MACH,GAAG,CAAC,CAAAC,IACNK,KAAiC,CAAC,CAAAC,OAC/BC,OAAO,CAAC,CAAAP,IACXH,EASL;EAACL,EAAA,KAAAD;EAAAC,EAAA,KAAAG;EAAAH,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAA,OAbII;AAaJ;AAlBE,SAAAS,MAAAG,KAAA;CAAA,OAOWA,IAAGL,KAAM,CAAC,CAAAM,YAAa;AAAC"}

package/dist/utils/react/useLayoutEffect.d.ts

@@ -1,6 +1,5 @@
 
 import * as React$1 from "react";
-
 //#region src/utils/react/useLayoutEffect.d.ts
 declare const useLayoutEffect$1: typeof React$1.useEffect;
 //#endregion

package/dist/utils/react/useLayoutEffect.js

@@ -1,9 +1,8 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import * as React$1 from "react";
-
 //#region src/utils/react/useLayoutEffect.tsx
 const useLayoutEffect$1 = typeof window !== "undefined" ? React$1.useLayoutEffect : React$1.useEffect;
-
 //#endregion
 export { useLayoutEffect$1 as useLayoutEffect };
+
 //# sourceMappingURL=useLayoutEffect.js.map

package/dist/utils/react/useLayoutEffect.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLayoutEffect.js","names":["React","useLayoutEffect","window","useEffect"],"sources":["../../../src/utils/react/useLayoutEffect.tsx"],"sourcesContent":["import * as React from 'react';\n\n// During SSR, React emits a warning when calling useLayoutEffect.\n// Since neither useLayoutEffect nor useEffect run on the server,\n// we can suppress this by replacing it with a noop on the server.\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\n"],"mappings":";;;;AAKA,MAAaC,oBACX,OAAOC,WAAW,cAAcF,QAAMC,kBAAkBD,QAAMG"}
+{"version":3,"file":"useLayoutEffect.js","names":["React","useLayoutEffect","window","useEffect","useLayoutEffect","React"],"sources":["../../../src/utils/react/useLayoutEffect.tsx"],"sourcesContent":["import * as React from 'react';\n\n// During SSR, React emits a warning when calling useLayoutEffect.\n// Since neither useLayoutEffect nor useEffect run on the server,\n// we can suppress this by replacing it with a noop on the server.\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\n"],"mappings":";;;AAKA,MAAaC,oBACX,OAAOC,WAAW,cAAcF,QAAMC,kBAAkBD,QAAMG"}

package/dist/utils/react/useLocalStorage.d.ts

@@ -31,7 +31,7 @@ type Updater<T> = T | ((prev: T) => T);
  * const [data, setData] = useLocalStorage(isEnabled ? 'my-key' : null, {});
  * ```
  */
-declare function useLocalStorage<T>(key: string | null | undefined, initialValue: T | (() => T)): readonly [T, (value: Updater<T>) => void];
+export declare function useLocalStorage<T>(key: string | null | undefined, initialValue: T | (() => T)): readonly [T, (value: Updater<T>) => void];
 //#endregion
-export { useLocalStorage };
+export {};
 //# sourceMappingURL=useLocalStorage.d.ts.map

package/dist/utils/react/useLocalStorage.js

@@ -1,8 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useEvent } from "../../_internal/hooks/use-event.js";
 import { c } from "react/compiler-runtime";
 import { useSyncExternalStore } from "react";
-
 //#region src/utils/react/useLocalStorage.ts
 /** Global registry of listeners per key for same-tab cross-instance sync */
 const listeners = /* @__PURE__ */ new Map();
@@ -139,7 +138,7 @@ function useLocalStorage(key, initialValue) {
 	return t5;
 }
 function _temp() {}
-
 //#endregion
 export { useLocalStorage };
+
 //# sourceMappingURL=useLocalStorage.js.map

package/dist/utils/react/useLocalStorage.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLocalStorage.js","names":["useCallback","useSyncExternalStore","useEvent","Updater","T","prev","listeners","Map","Set","notifyListeners","key","get","forEach","listener","isLocalStorageAvailable","testKey","window","localStorage","setItem","removeItem","parseJSON","value","fallback","JSON","parse","getInitialValue","initialValue","useLocalStorage","$","_c","t0","resolvedInitial","t1","onStoreChange","_temp","has","set","add","handleStorageEvent","event","addEventListener","delete","size","removeEventListener","subscribe","t2","getItem","getSnapshot","t3","getServerSnapshot","storedValue","t4","update","currentValue","newValue","stringify","t5","error","console","setValue","const"],"sources":["../../../src/utils/react/useLocalStorage.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\n\nimport { useEvent } from '../../_internal/hooks/use-event';\n\n/** Like React.setState: either a value or a function of the previous value */\ntype Updater<T> = T | ((prev: T) => T);\n\n/** Global registry of listeners per key for same-tab cross-instance sync */\nconst listeners = new Map<string, Set<() => void>>();\n\n/** Notify all listeners for a given key */\nfunction notifyListeners(key: string): void {\n  listeners.get(key)?.forEach((listener) => listener());\n}\n\n/** Check if localStorage is available */\nfunction isLocalStorageAvailable(): boolean {\n  try {\n    const testKey = '__localStorage_test__';\n    window.localStorage.setItem(testKey, testKey);\n    window.localStorage.removeItem(testKey);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Safely parse JSON with fallback */\nfunction parseJSON<T>(value: string | null, fallback: T): T {\n  if (value === null) {\n    return fallback;\n  }\n\n  try {\n    return JSON.parse(value) as T;\n  } catch {\n    return fallback;\n  }\n}\n\n/** Get initial value, supporting lazy initializer */\nfunction getInitialValue<T>(initialValue: T | (() => T)): T {\n  return typeof initialValue === 'function'\n    ? (initialValue as () => T)()\n    : initialValue;\n}\n\n/**\n * A hook to persist state in localStorage with cross-instance synchronization.\n *\n * Features:\n * - JSON serialization/deserialization\n * - Syncs between hook instances with the same key (same tab)\n * - Syncs across browser tabs via storage event\n * - SSR-safe (gracefully handles missing localStorage)\n * - Supports lazy initial value\n *\n * @param key - The localStorage key. Pass `null` or `undefined` to disable the hook.\n * @param initialValue - Initial value or lazy initializer function\n * @returns Tuple of [value, setValue] similar to useState\n *\n * @example\n * ```tsx\n * // Basic usage\n * const [theme, setTheme] = useLocalStorage('theme', 'light');\n *\n * // With lazy initializer\n * const [settings, setSettings] = useLocalStorage('settings', () => getDefaultSettings());\n *\n * // Disabled (returns initialValue, setValue is no-op)\n * const [value, setValue] = useLocalStorage(null, 'default');\n *\n * // Conditionally enabled\n * const [data, setData] = useLocalStorage(isEnabled ? 'my-key' : null, {});\n * ```\n */\nexport function useLocalStorage<T>(\n  key: string | null | undefined,\n  initialValue: T | (() => T),\n): readonly [T, (value: Updater<T>) => void] {\n  const resolvedInitial = getInitialValue(initialValue);\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (!key) {\n        return () => {};\n      }\n\n      // Add to same-tab listeners\n      if (!listeners.has(key)) {\n        listeners.set(key, new Set());\n      }\n      listeners.get(key)!.add(onStoreChange);\n\n      // Listen for cross-tab changes\n      const handleStorageEvent = (event: StorageEvent) => {\n        if (event.key === key) {\n          onStoreChange();\n        }\n      };\n      window.addEventListener('storage', handleStorageEvent);\n\n      return () => {\n        listeners.get(key)?.delete(onStoreChange);\n        if (listeners.get(key)?.size === 0) {\n          listeners.delete(key);\n        }\n        window.removeEventListener('storage', handleStorageEvent);\n      };\n    },\n    [key],\n  );\n\n  const getSnapshot = useCallback((): T => {\n    if (!key || !isLocalStorageAvailable()) {\n      return resolvedInitial;\n    }\n\n    return parseJSON(localStorage.getItem(key), resolvedInitial);\n  }, [key, resolvedInitial]);\n\n  const getServerSnapshot = useCallback((): T => {\n    return resolvedInitial;\n  }, [resolvedInitial]);\n\n  const storedValue = useSyncExternalStore(\n    subscribe,\n    getSnapshot,\n    getServerSnapshot,\n  );\n\n  const setValue = useEvent((update: Updater<T>) => {\n    if (!key || !isLocalStorageAvailable()) {\n      return;\n    }\n\n    const currentValue = parseJSON<T>(\n      localStorage.getItem(key),\n      resolvedInitial,\n    );\n    const newValue =\n      typeof update === 'function'\n        ? (update as (prev: T) => T)(currentValue)\n        : update;\n\n    try {\n      localStorage.setItem(key, JSON.stringify(newValue));\n      notifyListeners(key);\n    } catch (error) {\n      console.error(`[useLocalStorage] Failed to save \"${key}\":`, error);\n    }\n  });\n\n  return [storedValue, setValue] as const;\n}\n"],"mappings":"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"}
+{"version":3,"file":"useLocalStorage.js","names":["useCallback","useSyncExternalStore","useEvent","Updater","T","prev","listeners","Map","Set","notifyListeners","key","get","forEach","listener","isLocalStorageAvailable","testKey","window","localStorage","setItem","removeItem","parseJSON","value","fallback","JSON","parse","getInitialValue","initialValue","useLocalStorage","$","_c","t0","resolvedInitial","t1","onStoreChange","_temp","has","set","add","handleStorageEvent","event","addEventListener","delete","size","removeEventListener","subscribe","t2","getItem","getSnapshot","t3","getServerSnapshot","storedValue","t4","update","currentValue","newValue","stringify","t5","error","console","setValue","const","_c","getServerSnapshot"],"sources":["../../../src/utils/react/useLocalStorage.ts"],"sourcesContent":["import { useCallback, useSyncExternalStore } from 'react';\n\nimport { useEvent } from '../../_internal/hooks/use-event';\n\n/** Like React.setState: either a value or a function of the previous value */\ntype Updater<T> = T | ((prev: T) => T);\n\n/** Global registry of listeners per key for same-tab cross-instance sync */\nconst listeners = new Map<string, Set<() => void>>();\n\n/** Notify all listeners for a given key */\nfunction notifyListeners(key: string): void {\n  listeners.get(key)?.forEach((listener) => listener());\n}\n\n/** Check if localStorage is available */\nfunction isLocalStorageAvailable(): boolean {\n  try {\n    const testKey = '__localStorage_test__';\n    window.localStorage.setItem(testKey, testKey);\n    window.localStorage.removeItem(testKey);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Safely parse JSON with fallback */\nfunction parseJSON<T>(value: string | null, fallback: T): T {\n  if (value === null) {\n    return fallback;\n  }\n\n  try {\n    return JSON.parse(value) as T;\n  } catch {\n    return fallback;\n  }\n}\n\n/** Get initial value, supporting lazy initializer */\nfunction getInitialValue<T>(initialValue: T | (() => T)): T {\n  return typeof initialValue === 'function'\n    ? (initialValue as () => T)()\n    : initialValue;\n}\n\n/**\n * A hook to persist state in localStorage with cross-instance synchronization.\n *\n * Features:\n * - JSON serialization/deserialization\n * - Syncs between hook instances with the same key (same tab)\n * - Syncs across browser tabs via storage event\n * - SSR-safe (gracefully handles missing localStorage)\n * - Supports lazy initial value\n *\n * @param key - The localStorage key. Pass `null` or `undefined` to disable the hook.\n * @param initialValue - Initial value or lazy initializer function\n * @returns Tuple of [value, setValue] similar to useState\n *\n * @example\n * ```tsx\n * // Basic usage\n * const [theme, setTheme] = useLocalStorage('theme', 'light');\n *\n * // With lazy initializer\n * const [settings, setSettings] = useLocalStorage('settings', () => getDefaultSettings());\n *\n * // Disabled (returns initialValue, setValue is no-op)\n * const [value, setValue] = useLocalStorage(null, 'default');\n *\n * // Conditionally enabled\n * const [data, setData] = useLocalStorage(isEnabled ? 'my-key' : null, {});\n * ```\n */\nexport function useLocalStorage<T>(\n  key: string | null | undefined,\n  initialValue: T | (() => T),\n): readonly [T, (value: Updater<T>) => void] {\n  const resolvedInitial = getInitialValue(initialValue);\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      if (!key) {\n        return () => {};\n      }\n\n      // Add to same-tab listeners\n      if (!listeners.has(key)) {\n        listeners.set(key, new Set());\n      }\n      listeners.get(key)!.add(onStoreChange);\n\n      // Listen for cross-tab changes\n      const handleStorageEvent = (event: StorageEvent) => {\n        if (event.key === key) {\n          onStoreChange();\n        }\n      };\n      window.addEventListener('storage', handleStorageEvent);\n\n      return () => {\n        listeners.get(key)?.delete(onStoreChange);\n        if (listeners.get(key)?.size === 0) {\n          listeners.delete(key);\n        }\n        window.removeEventListener('storage', handleStorageEvent);\n      };\n    },\n    [key],\n  );\n\n  const getSnapshot = useCallback((): T => {\n    if (!key || !isLocalStorageAvailable()) {\n      return resolvedInitial;\n    }\n\n    return parseJSON(localStorage.getItem(key), resolvedInitial);\n  }, [key, resolvedInitial]);\n\n  const getServerSnapshot = useCallback((): T => {\n    return resolvedInitial;\n  }, [resolvedInitial]);\n\n  const storedValue = useSyncExternalStore(\n    subscribe,\n    getSnapshot,\n    getServerSnapshot,\n  );\n\n  const setValue = useEvent((update: Updater<T>) => {\n    if (!key || !isLocalStorageAvailable()) {\n      return;\n    }\n\n    const currentValue = parseJSON<T>(\n      localStorage.getItem(key),\n      resolvedInitial,\n    );\n    const newValue =\n      typeof update === 'function'\n        ? (update as (prev: T) => T)(currentValue)\n        : update;\n\n    try {\n      localStorage.setItem(key, JSON.stringify(newValue));\n      notifyListeners(key);\n    } catch (error) {\n      console.error(`[useLocalStorage] Failed to save \"${key}\":`, error);\n    }\n  });\n\n  return [storedValue, setValue] as const;\n}\n"],"mappings":"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"}

package/dist/utils/react/useMergeStyles.d.ts

@@ -1,6 +1,5 @@
 
 import { Styles } from "@tenphi/tasty";
-
 //#region src/utils/react/useMergeStyles.d.ts
 /**
  * Hook to merge base styles with sub-element style props.
@@ -25,7 +24,6 @@ import { Styles } from "@tenphi/tasty";
  * return <TabsElement styles={mergedStyles} {...rest} />;
  * ```
  */
-declare function useMergeStyles(styles: Styles | undefined, subStylesMap: Record<string, Styles | undefined>): Styles;
+export declare function useMergeStyles(styles: Styles | undefined, subStylesMap: Record<string, Styles | undefined>): Styles;
 //#endregion
-export { useMergeStyles };
 //# sourceMappingURL=useMergeStyles.d.ts.map

package/dist/utils/react/useMergeStyles.js

@@ -1,7 +1,6 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { mergeStyles } from "@tenphi/tasty";
 import { useMemo } from "react";
-
 //#region src/utils/react/useMergeStyles.ts
 /**
 * Hook to merge base styles with sub-element style props.
@@ -27,13 +26,14 @@ import { useMemo } from "react";
 * ```
 */
 function useMergeStyles(styles, subStylesMap) {
+	const subStylesValues = Object.values(subStylesMap);
 	return useMemo(() => {
 		const subStyles = {};
 		for (const [element, elementStyles] of Object.entries(subStylesMap)) if (elementStyles != null) subStyles[element] = elementStyles;
 		return mergeStyles(styles, subStyles);
-	}, [styles, ...Object.values(subStylesMap)]);
+	}, [styles, ...subStylesValues]);
 }
-
 //#endregion
 export { useMergeStyles };
+
 //# sourceMappingURL=useMergeStyles.js.map

package/dist/utils/react/useMergeStyles.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMergeStyles.js","names":["mergeStyles","Styles","useMemo","useMergeStyles","styles","subStylesMap","Record","subStylesValues","Object","values","subStyles","element","elementStyles","entries"],"sources":["../../../src/utils/react/useMergeStyles.ts"],"sourcesContent":["import { mergeStyles, Styles } from '@tenphi/tasty';\nimport { useMemo } from 'react';\n\n/**\n * Hook to merge base styles with sub-element style props.\n *\n * This simplifies the common pattern of accepting props like `tabListStyles`,\n * `prefixStyles`, etc. that should merge into `styles.TabList`, `styles.Prefix`, etc.\n *\n * @param styles - Base styles object\n * @param subStylesMap - Mapping of sub-element names to their additional styles\n * @returns Merged styles object\n *\n * @example\n * ```tsx\n * const { styles, tabListStyles, prefixStyles, suffixStyles, ...rest } = props;\n *\n * const mergedStyles = useMergeStyles(styles, {\n *   TabList: tabListStyles,\n *   Prefix: prefixStyles,\n *   Suffix: suffixStyles,\n * });\n *\n * return <TabsElement styles={mergedStyles} {...rest} />;\n * ```\n */\nexport function useMergeStyles(\n  styles: Styles | undefined,\n  subStylesMap: Record<string, Styles | undefined>,\n): Styles {\n  // Extract values for dependency array - must be stable\n  const subStylesValues = Object.values(subStylesMap);\n\n  return useMemo(() => {\n    // Build sub-element styles object from the map\n    const subStyles: Styles = {};\n\n    for (const [element, elementStyles] of Object.entries(subStylesMap)) {\n      if (elementStyles != null) {\n        subStyles[element] = elementStyles;\n      }\n    }\n\n    // Merge base styles with sub-element styles\n    return mergeStyles(styles, subStyles);\n  }, [styles, ...subStylesValues]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgBG,eACdC,QACAC,cACQ;AAIR,QAAOH,cAAc;EAEnB,MAAMQ,YAAoB,EAAE;AAE5B,OAAK,MAAM,CAACC,SAASC,kBAAkBJ,OAAOK,QAAQR,aAAa,CACjE,KAAIO,iBAAiB,KACnBF,WAAUC,WAAWC;AAKzB,SAAOZ,YAAYI,QAAQM,UAAU;IACpC,CAACN,QAAQ,GAdYI,OAAOC,OAAOJ,aAAa,CAcpB,CAAC"}
+{"version":3,"file":"useMergeStyles.js","names":["mergeStyles","Styles","useMemo","useMergeStyles","styles","subStylesMap","Record","subStylesValues","Object","values","subStyles","element","elementStyles","entries"],"sources":["../../../src/utils/react/useMergeStyles.ts"],"sourcesContent":["import { mergeStyles, Styles } from '@tenphi/tasty';\nimport { useMemo } from 'react';\n\n/**\n * Hook to merge base styles with sub-element style props.\n *\n * This simplifies the common pattern of accepting props like `tabListStyles`,\n * `prefixStyles`, etc. that should merge into `styles.TabList`, `styles.Prefix`, etc.\n *\n * @param styles - Base styles object\n * @param subStylesMap - Mapping of sub-element names to their additional styles\n * @returns Merged styles object\n *\n * @example\n * ```tsx\n * const { styles, tabListStyles, prefixStyles, suffixStyles, ...rest } = props;\n *\n * const mergedStyles = useMergeStyles(styles, {\n *   TabList: tabListStyles,\n *   Prefix: prefixStyles,\n *   Suffix: suffixStyles,\n * });\n *\n * return <TabsElement styles={mergedStyles} {...rest} />;\n * ```\n */\nexport function useMergeStyles(\n  styles: Styles | undefined,\n  subStylesMap: Record<string, Styles | undefined>,\n): Styles {\n  // Extract values for dependency array - must be stable\n  const subStylesValues = Object.values(subStylesMap);\n\n  return useMemo(() => {\n    // Build sub-element styles object from the map\n    const subStyles: Styles = {};\n\n    for (const [element, elementStyles] of Object.entries(subStylesMap)) {\n      if (elementStyles != null) {\n        subStyles[element] = elementStyles;\n      }\n    }\n\n    // Merge base styles with sub-element styles\n    return mergeStyles(styles, subStyles);\n  }, [styles, ...subStylesValues]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgBG,eACdC,QACAC,cACQ;CAER,MAAME,kBAAkBC,OAAOC,OAAOJ,YAAY;CAElD,OAAOH,cAAc;EAEnB,MAAMQ,YAAoB,CAAC;EAE3B,KAAK,MAAM,CAACC,SAASC,kBAAkBJ,OAAOK,QAAQR,YAAY,GAChE,IAAIO,iBAAiB,MACnBF,UAAUC,WAAWC;EAKzB,OAAOZ,YAAYI,QAAQM,SAAS;CACtC,GAAG,CAACN,QAAQ,GAAGG,eAAe,CAAC;AACjC"}

package/dist/utils/react/useOverlayEscapeGuard.js

@@ -1,8 +1,7 @@
-/** @license MIT | @cube-dev/ui-kit v0.197.0 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.198.1 | Cube Dev Team */
 import { useEvent } from "../../_internal/hooks/use-event.js";
 import { c } from "react/compiler-runtime";
 import { getEventTarget, nodeContains } from "@react-aria/utils";
-
 //#region src/utils/react/useOverlayEscapeGuard.ts
 /**
 * Stops a CLOSED overlay from answering for `Escape` (CUB-4839).
@@ -62,7 +61,7 @@ function useOverlayEscapeGuard(overlayProps, isOpen) {
 	} else t1 = $[5];
 	return t1;
 }
-
 //#endregion
 export { useOverlayEscapeGuard };
+
 //# sourceMappingURL=useOverlayEscapeGuard.js.map