1  import { c as _c } from "react/compiler-runtime";
  2  /**
  3   * Overlay tracking for Escape key coordination.
  4   *
  5   * This solves the problem of escape key handling when overlays (like Select with onCancel)
  6   * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't
  7   * cancel requests when the user just wants to dismiss the overlay.
  8   *
  9   * Usage:
 10   * 1. Call useRegisterOverlay() in any overlay component to automatically register it
 11   * 2. Call useIsOverlayActive() to check if any overlay is currently active
 12   *
 13   * The hook automatically registers on mount and unregisters on unmount,
 14   * so no manual cleanup or state management is needed.
 15   */
 16  import { useContext, useEffect, useLayoutEffect } from 'react';
 17  import instances from '../ink/instances.js';
 18  import { AppStoreContext, useAppState } from '../state/AppState.js';
 19  
 20  // Non-modal overlays that shouldn't disable TextInput focus
 21  const NON_MODAL_OVERLAYS = new Set(['autocomplete']);
 22  
 23  /**
 24   * Hook to register a component as an active overlay.
 25   * Automatically registers on mount and unregisters on unmount.
 26   *
 27   * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')
 28   * @param enabled - Whether to register (default: true). Use this to conditionally register
 29   *                  based on component props, e.g., only register when onCancel is provided.
 30   *
 31   * @example
 32   * // Conditional registration based on whether cancel is supported
 33   * function useSelectInput({ state }) {
 34   *   useRegisterOverlay('select', !!state.onCancel)
 35   *   // ...
 36   * }
 37   */
 38  export function useRegisterOverlay(id, t0) {
 39    const $ = _c(8);
 40    const enabled = t0 === undefined ? true : t0;
 41    const store = useContext(AppStoreContext);
 42    const setAppState = store?.setState;
 43    let t1;
 44    let t2;
 45    if ($[0] !== enabled || $[1] !== id || $[2] !== setAppState) {
 46      t1 = () => {
 47        if (!enabled || !setAppState) {
 48          return;
 49        }
 50        setAppState(prev => {
 51          if (prev.activeOverlays.has(id)) {
 52            return prev;
 53          }
 54          const next = new Set(prev.activeOverlays);
 55          next.add(id);
 56          return {
 57            ...prev,
 58            activeOverlays: next
 59          };
 60        });
 61        return () => {
 62          setAppState(prev_0 => {
 63            if (!prev_0.activeOverlays.has(id)) {
 64              return prev_0;
 65            }
 66            const next_0 = new Set(prev_0.activeOverlays);
 67            next_0.delete(id);
 68            return {
 69              ...prev_0,
 70              activeOverlays: next_0
 71            };
 72          });
 73        };
 74      };
 75      t2 = [id, enabled, setAppState];
 76      $[0] = enabled;
 77      $[1] = id;
 78      $[2] = setAppState;
 79      $[3] = t1;
 80      $[4] = t2;
 81    } else {
 82      t1 = $[3];
 83      t2 = $[4];
 84    }
 85    useEffect(t1, t2);
 86    let t3;
 87    let t4;
 88    if ($[5] !== enabled) {
 89      t3 = () => {
 90        if (!enabled) {
 91          return;
 92        }
 93        return _temp;
 94      };
 95      t4 = [enabled];
 96      $[5] = enabled;
 97      $[6] = t3;
 98      $[7] = t4;
 99    } else {
100      t3 = $[6];
101      t4 = $[7];
102    }
103    useLayoutEffect(t3, t4);
104  }
105  
106  /**
107   * Hook to check if any overlay is currently active.
108   * This is reactive - the component will re-render when the overlay state changes.
109   *
110   * @returns true if any overlay is currently active
111   *
112   * @example
113   * function CancelRequestHandler() {
114   *   const isOverlayActive = useIsOverlayActive()
115   *   const isActive = !isOverlayActive && canCancelRunningTask
116   *   useKeybinding('chat:cancel', handleCancel, { isActive })
117   * }
118   */
119  function _temp() {
120    return instances.get(process.stdout)?.invalidatePrevFrame();
121  }
122  export function useIsOverlayActive() {
123    return useAppState(_temp2);
124  }
125  
126  /**
127   * Hook to check if any modal overlay is currently active.
128   * Modal overlays are overlays that should capture all input (like Select dialogs).
129   * Non-modal overlays (like autocomplete) don't disable TextInput focus.
130   *
131   * @returns true if any modal overlay is currently active
132   *
133   * @example
134   * // Use for TextInput focus - allows typing during autocomplete
135   * focus: !isSearchingHistory && !isModalOverlayActive
136   */
137  function _temp2(s) {
138    return s.activeOverlays.size > 0;
139  }
140  export function useIsModalOverlayActive() {
141    return useAppState(_temp3);
142  }
143  function _temp3(s) {
144    for (const id of s.activeOverlays) {
145      if (!NON_MODAL_OVERLAYS.has(id)) {
146        return true;
147      }
148    }
149    return false;
150  }
151  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useContext","useEffect","useLayoutEffect","instances","AppStoreContext","useAppState","NON_MODAL_OVERLAYS","Set","useRegisterOverlay","id","t0","$","_c","enabled","undefined","store","setAppState","setState","t1","t2","prev","activeOverlays","has","next","add","prev_0","next_0","delete","t3","t4","_temp","get","process","stdout","invalidatePrevFrame","useIsOverlayActive","_temp2","s","size","useIsModalOverlayActive","_temp3"],"sources":["overlayContext.tsx"],"sourcesContent":["/**\n * Overlay tracking for Escape key coordination.\n *\n * This solves the problem of escape key handling when overlays (like Select with onCancel)\n * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't\n * cancel requests when the user just wants to dismiss the overlay.\n *\n * Usage:\n * 1. Call useRegisterOverlay() in any overlay component to automatically register it\n * 2. Call useIsOverlayActive() to check if any overlay is currently active\n *\n * The hook automatically registers on mount and unregisters on unmount,\n * so no manual cleanup or state management is needed.\n */\nimport { useContext, useEffect, useLayoutEffect } from 'react'\nimport instances from '../ink/instances.js'\nimport { AppStoreContext, useAppState } from '../state/AppState.js'\n\n// Non-modal overlays that shouldn't disable TextInput focus\nconst NON_MODAL_OVERLAYS = new Set(['autocomplete'])\n\n/**\n * Hook to register a component as an active overlay.\n * Automatically registers on mount and unregisters on unmount.\n *\n * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')\n * @param enabled - Whether to register (default: true). Use this to conditionally register\n *                  based on component props, e.g., only register when onCancel is provided.\n *\n * @example\n * // Conditional registration based on whether cancel is supported\n * function useSelectInput({ state }) {\n *   useRegisterOverlay('select', !!state.onCancel)\n *   // ...\n * }\n */\nexport function useRegisterOverlay(id: string, enabled = true): void {\n  // Use context directly so this is a no-op when rendered outside AppStateProvider\n  // (e.g., in isolated component tests that don't need the full app state tree).\n  const store = useContext(AppStoreContext)\n  const setAppState = store?.setState\n  useEffect(() => {\n    if (!enabled || !setAppState) return\n    setAppState(prev => {\n      if (prev.activeOverlays.has(id)) return prev\n      const next = new Set(prev.activeOverlays)\n      next.add(id)\n      return { ...prev, activeOverlays: next }\n    })\n    return () => {\n      setAppState(prev => {\n        if (!prev.activeOverlays.has(id)) return prev\n        const next = new Set(prev.activeOverlays)\n        next.delete(id)\n        return { ...prev, activeOverlays: next }\n      })\n    }\n  }, [id, enabled, setAppState])\n\n  // On overlay close, force the next render to full-damage diff instead\n  // of blit. A tall overlay (e.g. FuzzyPicker with a 20-line preview)\n  // shrinks the Ink-managed region on unmount; the blit fast path can\n  // copy stale cells from the overlay's previous frame into rows the\n  // shorter layout no longer reaches, leaving a ghost title/divider.\n  // useLayoutEffect so cleanup runs synchronously before the microtask-\n  // deferred onRender (scheduleRender queues a microtask from\n  // resetAfterCommit; passive-effect cleanup would land after it).\n  useLayoutEffect(() => {\n    if (!enabled) return\n    return () => instances.get(process.stdout)?.invalidatePrevFrame()\n  }, [enabled])\n}\n\n/**\n * Hook to check if any overlay is currently active.\n * This is reactive - the component will re-render when the overlay state changes.\n *\n * @returns true if any overlay is currently active\n *\n * @example\n * function CancelRequestHandler() {\n *   const isOverlayActive = useIsOverlayActive()\n *   const isActive = !isOverlayActive && canCancelRunningTask\n *   useKeybinding('chat:cancel', handleCancel, { isActive })\n * }\n */\nexport function useIsOverlayActive(): boolean {\n  return useAppState(s => s.activeOverlays.size > 0)\n}\n\n/**\n * Hook to check if any modal overlay is currently active.\n * Modal overlays are overlays that should capture all input (like Select dialogs).\n * Non-modal overlays (like autocomplete) don't disable TextInput focus.\n *\n * @returns true if any modal overlay is currently active\n *\n * @example\n * // Use for TextInput focus - allows typing during autocomplete\n * focus: !isSearchingHistory && !isModalOverlayActive\n */\nexport function useIsModalOverlayActive(): boolean {\n  return useAppState(s => {\n    for (const id of s.activeOverlays) {\n      if (!NON_MODAL_OVERLAYS.has(id)) return true\n    }\n    return false\n  })\n}\n"],"mappings":"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","ignoreList":[]}