src/context/overlayContext.tsx

import { c as _c } from "react/compiler-runtime";
/**
 * Overlay tracking for Escape key coordination.
 *
 * This solves the problem of escape key handling when overlays (like Select with onCancel)
 * are open. The CancelRequestHandler needs to know when an overlay is active so it doesn't
 * cancel requests when the user just wants to dismiss the overlay.
 *
 * Usage:
 * 1. Call useRegisterOverlay() in any overlay component to automatically register it
 * 2. Call useIsOverlayActive() to check if any overlay is currently active
 *
 * The hook automatically registers on mount and unregisters on unmount,
 * so no manual cleanup or state management is needed.
 */
import { useContext, useEffect, useLayoutEffect } from 'react';
import instances from '../ink/instances.js';
import { AppStoreContext, useAppState } from '../state/AppState.js';

// Non-modal overlays that shouldn't disable TextInput focus
const NON_MODAL_OVERLAYS = new Set(['autocomplete']);

/**
 * Hook to register a component as an active overlay.
 * Automatically registers on mount and unregisters on unmount.
 *
 * @param id - Unique identifier for this overlay (e.g., 'select', 'multi-select')
 * @param enabled - Whether to register (default: true). Use this to conditionally register
 *                  based on component props, e.g., only register when onCancel is provided.
 *
 * @example
 * // Conditional registration based on whether cancel is supported
 * function useSelectInput({ state }) {
 *   useRegisterOverlay('select', !!state.onCancel)
 *   // ...
 * }
 */
export function useRegisterOverlay(id, t0) {
  const $ = _c(8);
  const enabled = t0 === undefined ? true : t0;
  const store = useContext(AppStoreContext);
  const setAppState = store?.setState;
  let t1;
  let t2;
  if ($[0] !== enabled || $[1] !== id || $[2] !== setAppState) {
    t1 = () => {
      if (!enabled || !setAppState) {
        return;
      }
      setAppState(prev => {
        if (prev.activeOverlays.has(id)) {
          return prev;
        }
        const next = new Set(prev.activeOverlays);
        next.add(id);
        return {
          ...prev,
          activeOverlays: next
        };
      });
      return () => {
        setAppState(prev_0 => {
          if (!prev_0.activeOverlays.has(id)) {
            return prev_0;
          }
          const next_0 = new Set(prev_0.activeOverlays);
          next_0.delete(id);
          return {
            ...prev_0,
            activeOverlays: next_0
          };
        });
      };
    };
    t2 = [id, enabled, setAppState];
    $[0] = enabled;
    $[1] = id;
    $[2] = setAppState;
    $[3] = t1;
    $[4] = t2;
  } else {
    t1 = $[3];
    t2 = $[4];
  }
  useEffect(t1, t2);
  let t3;
  let t4;
  if ($[5] !== enabled) {
    t3 = () => {
      if (!enabled) {
        return;
      }
      return _temp;
    };
    t4 = [enabled];
    $[5] = enabled;
    $[6] = t3;
    $[7] = t4;
  } else {
    t3 = $[6];
    t4 = $[7];
  }
  useLayoutEffect(t3, t4);
}

/**
 * Hook to check if any overlay is currently active.
 * This is reactive - the component will re-render when the overlay state changes.
 *
 * @returns true if any overlay is currently active
 *
 * @example
 * function CancelRequestHandler() {
 *   const isOverlayActive = useIsOverlayActive()
 *   const isActive = !isOverlayActive && canCancelRunningTask
 *   useKeybinding('chat:cancel', handleCancel, { isActive })
 * }
 */
function _temp() {
  return instances.get(process.stdout)?.invalidatePrevFrame();
}
export function useIsOverlayActive() {
  return useAppState(_temp2);
}

/**
 * Hook to check if any modal overlay is currently active.
 * Modal overlays are overlays that should capture all input (like Select dialogs).
 * Non-modal overlays (like autocomplete) don't disable TextInput focus.
 *
 * @returns true if any modal overlay is currently active
 *
 * @example
 * // Use for TextInput focus - allows typing during autocomplete
 * focus: !isSearchingHistory && !isModalOverlayActive
 */
function _temp2(s) {
  return s.activeOverlays.size > 0;
}
export function useIsModalOverlayActive() {
  return useAppState(_temp3);
}
function _temp3(s) {
  for (const id of s.activeOverlays) {
    if (!NON_MODAL_OVERLAYS.has(id)) {
      return true;
    }
  }
  return false;
}
//# 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":[]}