151 lines
14 KiB
TypeScript
151 lines
14 KiB
TypeScript
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":[]}
|