@dexto/tui 1.6.2

package/dist/contexts/ScrollProvider.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ScrollProvider_exports = {};
+__export(ScrollProvider_exports, {
+  ScrollProvider: () => ScrollProvider,
+  useScrollable: () => useScrollable
+});
+module.exports = __toCommonJS(ScrollProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_ink = require("ink");
+var import_MouseContext = require("./MouseContext.js");
+const ScrollContext = (0, import_react.createContext)(null);
+const findScrollableCandidates = (mouseEvent, scrollables) => {
+  const candidates = [];
+  for (const entry of scrollables.values()) {
+    if (!entry.ref.current || !entry.hasFocus()) {
+      continue;
+    }
+    const boundingBox = (0, import_ink.getBoundingBox)(entry.ref.current);
+    if (!boundingBox) continue;
+    const { x, y, width, height } = boundingBox;
+    const isInside = mouseEvent.col >= x && mouseEvent.col < x + width + 1 && mouseEvent.row >= y && mouseEvent.row < y + height;
+    if (isInside) {
+      candidates.push({ ...entry, area: width * height });
+    }
+  }
+  candidates.sort((a, b) => a.area - b.area);
+  return candidates;
+};
+function useDragDetection(onSelectionAttempt) {
+  const isLeftButtonDownRef = (0, import_react.useRef)(false);
+  const selectionHintShownRef = (0, import_react.useRef)(false);
+  const handleDragDetection = (0, import_react.useCallback)(
+    (event) => {
+      if (event.name === "left-press") {
+        isLeftButtonDownRef.current = true;
+        selectionHintShownRef.current = false;
+      } else if (event.name === "left-release") {
+        isLeftButtonDownRef.current = false;
+      } else if (event.name === "move" && isLeftButtonDownRef.current) {
+        if (!selectionHintShownRef.current && onSelectionAttempt) {
+          selectionHintShownRef.current = true;
+          onSelectionAttempt();
+        }
+      }
+    },
+    [onSelectionAttempt]
+  );
+  return handleDragDetection;
+}
+const ScrollProvider = ({ children, onSelectionAttempt }) => {
+  const [scrollables, setScrollables] = (0, import_react.useState)(/* @__PURE__ */ new Map());
+  const handleDragDetection = useDragDetection(onSelectionAttempt);
+  const register = (0, import_react.useCallback)((entry) => {
+    setScrollables((prev) => new Map(prev).set(entry.id, entry));
+  }, []);
+  const unregister = (0, import_react.useCallback)((id) => {
+    setScrollables((prev) => {
+      const next = new Map(prev);
+      next.delete(id);
+      return next;
+    });
+  }, []);
+  const scrollablesRef = (0, import_react.useRef)(scrollables);
+  (0, import_react.useEffect)(() => {
+    scrollablesRef.current = scrollables;
+  }, [scrollables]);
+  const pendingScrollsRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const flushScheduledRef = (0, import_react.useRef)(false);
+  const scheduleFlush = (0, import_react.useCallback)(() => {
+    if (!flushScheduledRef.current) {
+      flushScheduledRef.current = true;
+      setTimeout(() => {
+        flushScheduledRef.current = false;
+        for (const [id, delta] of pendingScrollsRef.current.entries()) {
+          const entry = scrollablesRef.current.get(id);
+          if (entry) {
+            entry.scrollBy(delta);
+          }
+        }
+        pendingScrollsRef.current.clear();
+      }, 0);
+    }
+  }, []);
+  const handleScroll = (0, import_react.useCallback)(
+    (direction, mouseEvent) => {
+      const delta = direction === "up" ? -1 : 1;
+      const candidates = findScrollableCandidates(mouseEvent, scrollablesRef.current);
+      for (const candidate of candidates) {
+        const { scrollTop, scrollHeight, innerHeight } = candidate.getScrollState();
+        const pendingDelta = pendingScrollsRef.current.get(candidate.id) || 0;
+        const effectiveScrollTop = scrollTop + pendingDelta;
+        const canScrollUp = effectiveScrollTop > 1e-3;
+        const canScrollDown = effectiveScrollTop < scrollHeight - innerHeight - 1e-3;
+        if (direction === "up" && canScrollUp) {
+          pendingScrollsRef.current.set(candidate.id, pendingDelta + delta);
+          scheduleFlush();
+          return true;
+        }
+        if (direction === "down" && canScrollDown) {
+          pendingScrollsRef.current.set(candidate.id, pendingDelta + delta);
+          scheduleFlush();
+          return true;
+        }
+      }
+      return false;
+    },
+    [scheduleFlush]
+  );
+  (0, import_MouseContext.useMouse)(
+    (0, import_react.useCallback)(
+      (event) => {
+        if (event.name === "scroll-up") {
+          return handleScroll("up", event);
+        } else if (event.name === "scroll-down") {
+          return handleScroll("down", event);
+        }
+        handleDragDetection(event);
+        return false;
+      },
+      [handleScroll, handleDragDetection]
+    ),
+    { isActive: true }
+  );
+  const contextValue = (0, import_react.useMemo)(() => ({ register, unregister }), [register, unregister]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScrollContext.Provider, { value: contextValue, children });
+};
+let nextId = 0;
+const useScrollable = (entry, isActive) => {
+  const context = (0, import_react.useContext)(ScrollContext);
+  if (!context) {
+    throw new Error("useScrollable must be used within a ScrollProvider");
+  }
+  const [id] = (0, import_react.useState)(() => `scrollable-${nextId++}`);
+  const entryRef = (0, import_react.useRef)(entry);
+  entryRef.current = entry;
+  (0, import_react.useEffect)(() => {
+    if (isActive) {
+      const registrationEntry = {
+        id,
+        ref: entryRef.current.ref,
+        getScrollState: () => entryRef.current.getScrollState(),
+        scrollBy: (delta) => entryRef.current.scrollBy(delta),
+        hasFocus: () => entryRef.current.hasFocus()
+      };
+      if (entryRef.current.scrollTo) {
+        registrationEntry.scrollTo = (scrollTop, duration) => {
+          entryRef.current.scrollTo?.(scrollTop, duration);
+        };
+      }
+      context.register(registrationEntry);
+      return () => {
+        context.unregister(id);
+      };
+    }
+    return;
+  }, [context, id, isActive]);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScrollProvider,
+  useScrollable
+});

package/dist/contexts/ScrollProvider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ScrollProvider
+ *
+ * Manages scrollable components and handles mouse scroll events.
+ * Components register themselves as scrollable, and the provider
+ * routes scroll events to the appropriate component.
+ */
+import type React from 'react';
+import { type DOMElement } from 'ink';
+export interface ScrollState {
+    scrollTop: number;
+    scrollHeight: number;
+    innerHeight: number;
+}
+export interface ScrollableEntry {
+    id: string;
+    ref: React.RefObject<DOMElement | null>;
+    getScrollState: () => ScrollState;
+    scrollBy: (delta: number) => void;
+    scrollTo?: (scrollTop: number, duration?: number) => void;
+    hasFocus: () => boolean;
+}
+export interface ScrollProviderProps {
+    children: React.ReactNode;
+    /** Callback when user attempts to select text (drag without Option key) */
+    onSelectionAttempt?: () => void;
+}
+export declare const ScrollProvider: React.FC<ScrollProviderProps>;
+/**
+ * Hook to register a component as scrollable
+ */
+export declare const useScrollable: (entry: Omit<ScrollableEntry, "id">, isActive: boolean) => void;
+//# sourceMappingURL=ScrollProvider.d.ts.map

package/dist/contexts/ScrollProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollProvider.d.ts","sourceRoot":"","sources":["../../src/contexts/ScrollProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAU/B,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,KAAK,CAAC;AAGtD,MAAM,WAAW,WAAW;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACxC,cAAc,EAAE,MAAM,WAAW,CAAC;IAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,QAAQ,EAAE,MAAM,OAAO,CAAC;CAC3B;AA8CD,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,2EAA2E;IAC3E,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC;AAgCD,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAkGxD,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,EAAE,UAAU,OAAO,SAmClF,CAAC"}

package/dist/contexts/ScrollProvider.js

@@ -0,0 +1,163 @@
+import { jsx } from "react/jsx-runtime";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { getBoundingBox } from "ink";
+import { useMouse } from "./MouseContext.js";
+const ScrollContext = createContext(null);
+const findScrollableCandidates = (mouseEvent, scrollables) => {
+  const candidates = [];
+  for (const entry of scrollables.values()) {
+    if (!entry.ref.current || !entry.hasFocus()) {
+      continue;
+    }
+    const boundingBox = getBoundingBox(entry.ref.current);
+    if (!boundingBox) continue;
+    const { x, y, width, height } = boundingBox;
+    const isInside = mouseEvent.col >= x && mouseEvent.col < x + width + 1 && mouseEvent.row >= y && mouseEvent.row < y + height;
+    if (isInside) {
+      candidates.push({ ...entry, area: width * height });
+    }
+  }
+  candidates.sort((a, b) => a.area - b.area);
+  return candidates;
+};
+function useDragDetection(onSelectionAttempt) {
+  const isLeftButtonDownRef = useRef(false);
+  const selectionHintShownRef = useRef(false);
+  const handleDragDetection = useCallback(
+    (event) => {
+      if (event.name === "left-press") {
+        isLeftButtonDownRef.current = true;
+        selectionHintShownRef.current = false;
+      } else if (event.name === "left-release") {
+        isLeftButtonDownRef.current = false;
+      } else if (event.name === "move" && isLeftButtonDownRef.current) {
+        if (!selectionHintShownRef.current && onSelectionAttempt) {
+          selectionHintShownRef.current = true;
+          onSelectionAttempt();
+        }
+      }
+    },
+    [onSelectionAttempt]
+  );
+  return handleDragDetection;
+}
+const ScrollProvider = ({ children, onSelectionAttempt }) => {
+  const [scrollables, setScrollables] = useState(/* @__PURE__ */ new Map());
+  const handleDragDetection = useDragDetection(onSelectionAttempt);
+  const register = useCallback((entry) => {
+    setScrollables((prev) => new Map(prev).set(entry.id, entry));
+  }, []);
+  const unregister = useCallback((id) => {
+    setScrollables((prev) => {
+      const next = new Map(prev);
+      next.delete(id);
+      return next;
+    });
+  }, []);
+  const scrollablesRef = useRef(scrollables);
+  useEffect(() => {
+    scrollablesRef.current = scrollables;
+  }, [scrollables]);
+  const pendingScrollsRef = useRef(/* @__PURE__ */ new Map());
+  const flushScheduledRef = useRef(false);
+  const scheduleFlush = useCallback(() => {
+    if (!flushScheduledRef.current) {
+      flushScheduledRef.current = true;
+      setTimeout(() => {
+        flushScheduledRef.current = false;
+        for (const [id, delta] of pendingScrollsRef.current.entries()) {
+          const entry = scrollablesRef.current.get(id);
+          if (entry) {
+            entry.scrollBy(delta);
+          }
+        }
+        pendingScrollsRef.current.clear();
+      }, 0);
+    }
+  }, []);
+  const handleScroll = useCallback(
+    (direction, mouseEvent) => {
+      const delta = direction === "up" ? -1 : 1;
+      const candidates = findScrollableCandidates(mouseEvent, scrollablesRef.current);
+      for (const candidate of candidates) {
+        const { scrollTop, scrollHeight, innerHeight } = candidate.getScrollState();
+        const pendingDelta = pendingScrollsRef.current.get(candidate.id) || 0;
+        const effectiveScrollTop = scrollTop + pendingDelta;
+        const canScrollUp = effectiveScrollTop > 1e-3;
+        const canScrollDown = effectiveScrollTop < scrollHeight - innerHeight - 1e-3;
+        if (direction === "up" && canScrollUp) {
+          pendingScrollsRef.current.set(candidate.id, pendingDelta + delta);
+          scheduleFlush();
+          return true;
+        }
+        if (direction === "down" && canScrollDown) {
+          pendingScrollsRef.current.set(candidate.id, pendingDelta + delta);
+          scheduleFlush();
+          return true;
+        }
+      }
+      return false;
+    },
+    [scheduleFlush]
+  );
+  useMouse(
+    useCallback(
+      (event) => {
+        if (event.name === "scroll-up") {
+          return handleScroll("up", event);
+        } else if (event.name === "scroll-down") {
+          return handleScroll("down", event);
+        }
+        handleDragDetection(event);
+        return false;
+      },
+      [handleScroll, handleDragDetection]
+    ),
+    { isActive: true }
+  );
+  const contextValue = useMemo(() => ({ register, unregister }), [register, unregister]);
+  return /* @__PURE__ */ jsx(ScrollContext.Provider, { value: contextValue, children });
+};
+let nextId = 0;
+const useScrollable = (entry, isActive) => {
+  const context = useContext(ScrollContext);
+  if (!context) {
+    throw new Error("useScrollable must be used within a ScrollProvider");
+  }
+  const [id] = useState(() => `scrollable-${nextId++}`);
+  const entryRef = useRef(entry);
+  entryRef.current = entry;
+  useEffect(() => {
+    if (isActive) {
+      const registrationEntry = {
+        id,
+        ref: entryRef.current.ref,
+        getScrollState: () => entryRef.current.getScrollState(),
+        scrollBy: (delta) => entryRef.current.scrollBy(delta),
+        hasFocus: () => entryRef.current.hasFocus()
+      };
+      if (entryRef.current.scrollTo) {
+        registrationEntry.scrollTo = (scrollTop, duration) => {
+          entryRef.current.scrollTo?.(scrollTop, duration);
+        };
+      }
+      context.register(registrationEntry);
+      return () => {
+        context.unregister(id);
+      };
+    }
+    return;
+  }, [context, id, isActive]);
+};
+export {
+  ScrollProvider,
+  useScrollable
+};

package/dist/contexts/SoundContext.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SoundContext_exports = {};
+__export(SoundContext_exports, {
+  SoundProvider: () => SoundProvider,
+  useSoundService: () => useSoundService
+});
+module.exports = __toCommonJS(SoundContext_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+const SoundContext = (0, import_react.createContext)(null);
+function SoundProvider({ soundService, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SoundContext.Provider, { value: soundService, children });
+}
+function useSoundService() {
+  return (0, import_react.useContext)(SoundContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SoundProvider,
+  useSoundService
+});

package/dist/contexts/SoundContext.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SoundContext - Provides sound notification service to components
+ *
+ * Initialized at CLI startup based on user preferences.
+ * Components can use useSoundService() to access the service.
+ */
+import { type ReactNode } from 'react';
+import type { SoundNotificationService } from '../utils/soundNotification.js';
+interface SoundProviderProps {
+    soundService: SoundNotificationService | null;
+    children: ReactNode;
+}
+/**
+ * Provider component for sound notification service
+ */
+export declare function SoundProvider({ soundService, children }: SoundProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the sound notification service
+ * Returns null if sounds are not configured
+ */
+export declare function useSoundService(): SoundNotificationService | null;
+export {};
+//# sourceMappingURL=SoundContext.d.ts.map

package/dist/contexts/SoundContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SoundContext.d.ts","sourceRoot":"","sources":["../../src/contexts/SoundContext.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAc,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAI9E,UAAU,kBAAkB;IACxB,YAAY,EAAE,wBAAwB,GAAG,IAAI,CAAC;IAC9C,QAAQ,EAAE,SAAS,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,kBAAkB,2CAE3E;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,wBAAwB,GAAG,IAAI,CAEjE"}

package/dist/contexts/SoundContext.js

@@ -0,0 +1,13 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const SoundContext = createContext(null);
+function SoundProvider({ soundService, children }) {
+  return /* @__PURE__ */ jsx(SoundContext.Provider, { value: soundService, children });
+}
+function useSoundService() {
+  return useContext(SoundContext);
+}
+export {
+  SoundProvider,
+  useSoundService
+};

package/dist/contexts/index.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contexts_exports = {};
+__export(contexts_exports, {
+  KeypressProvider: () => import_KeypressContext.KeypressProvider,
+  MouseProvider: () => import_MouseContext.MouseProvider,
+  ScrollProvider: () => import_ScrollProvider.ScrollProvider,
+  SoundProvider: () => import_SoundContext.SoundProvider,
+  useKeypressContext: () => import_KeypressContext.useKeypressContext,
+  useMouse: () => import_MouseContext.useMouse,
+  useMouseContext: () => import_MouseContext.useMouseContext,
+  useScrollable: () => import_ScrollProvider.useScrollable,
+  useSoundService: () => import_SoundContext.useSoundService
+});
+module.exports = __toCommonJS(contexts_exports);
+var import_KeypressContext = require("./KeypressContext.js");
+var import_MouseContext = require("./MouseContext.js");
+var import_ScrollProvider = require("./ScrollProvider.js");
+var import_SoundContext = require("./SoundContext.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KeypressProvider,
+  MouseProvider,
+  ScrollProvider,
+  SoundProvider,
+  useKeypressContext,
+  useMouse,
+  useMouseContext,
+  useScrollable,
+  useSoundService
+});

package/dist/contexts/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Context providers for ink-cli
+ */
+export { KeypressProvider, useKeypressContext, type Key, type KeypressHandler, type KeypressProviderProps, } from './KeypressContext.js';
+export { MouseProvider, useMouseContext, useMouse, type MouseEvent, type MouseEventName, type MouseHandler, type MouseProviderProps, } from './MouseContext.js';
+export { ScrollProvider, useScrollable, type ScrollState, type ScrollableEntry, } from './ScrollProvider.js';
+export { SoundProvider, useSoundService } from './SoundContext.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACH,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,KAAK,qBAAqB,GAC7B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACH,aAAa,EACb,eAAe,EACf,QAAQ,EACR,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,kBAAkB,GAC1B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACH,cAAc,EACd,aAAa,EACb,KAAK,WAAW,EAChB,KAAK,eAAe,GACvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/contexts/index.js

@@ -0,0 +1,25 @@
+import {
+  KeypressProvider,
+  useKeypressContext
+} from "./KeypressContext.js";
+import {
+  MouseProvider,
+  useMouseContext,
+  useMouse
+} from "./MouseContext.js";
+import {
+  ScrollProvider,
+  useScrollable
+} from "./ScrollProvider.js";
+import { SoundProvider, useSoundService } from "./SoundContext.js";
+export {
+  KeypressProvider,
+  MouseProvider,
+  ScrollProvider,
+  SoundProvider,
+  useKeypressContext,
+  useMouse,
+  useMouseContext,
+  useScrollable,
+  useSoundService
+};

package/dist/hooks/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  createApprovalInputHandler: () => import_useInputOrchestrator.createApprovalInputHandler,
+  createAutocompleteInputHandler: () => import_useInputOrchestrator.createAutocompleteInputHandler,
+  createMainInputHandler: () => import_useInputOrchestrator.createMainInputHandler,
+  createSelectorInputHandler: () => import_useInputOrchestrator.createSelectorInputHandler,
+  useAgentEvents: () => import_useAgentEvents.useAgentEvents,
+  useCLIState: () => import_useCLIState.useCLIState,
+  useGitBranch: () => import_useGitBranch.useGitBranch,
+  useInputOrchestrator: () => import_useInputOrchestrator.useInputOrchestrator,
+  useKeyboardShortcuts: () => import_useKeyboardShortcuts.useKeyboardShortcuts,
+  useKeypress: () => import_useKeypress.useKeypress,
+  useTerminalSize: () => import_useTerminalSize.useTerminalSize
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_useAgentEvents = require("./useAgentEvents.js");
+var import_useKeyboardShortcuts = require("./useKeyboardShortcuts.js");
+var import_useInputOrchestrator = require("./useInputOrchestrator.js");
+var import_useKeypress = require("./useKeypress.js");
+var import_useTerminalSize = require("./useTerminalSize.js");
+var import_useGitBranch = require("./useGitBranch.js");
+var import_useCLIState = require("./useCLIState.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createApprovalInputHandler,
+  createAutocompleteInputHandler,
+  createMainInputHandler,
+  createSelectorInputHandler,
+  useAgentEvents,
+  useCLIState,
+  useGitBranch,
+  useInputOrchestrator,
+  useKeyboardShortcuts,
+  useKeypress,
+  useTerminalSize
+});

package/dist/hooks/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hooks module exports
+ */
+export { useAgentEvents } from './useAgentEvents.js';
+export { useKeyboardShortcuts } from './useKeyboardShortcuts.js';
+export { useInputOrchestrator, createApprovalInputHandler, createSelectorInputHandler, createAutocompleteInputHandler, createMainInputHandler, type InputHandler, type InputHandlers, type UseInputOrchestratorProps, type ApprovalHandlerProps, type SelectorHandlerProps, type AutocompleteHandlerProps, type MainInputHandlerProps, } from './useInputOrchestrator.js';
+export { useKeypress } from './useKeypress.js';
+export { useTerminalSize, type TerminalSize } from './useTerminalSize.js';
+export { useGitBranch } from './useGitBranch.js';
+export { useCLIState, type UseCLIStateProps, type CLIStateReturn, type UIState, type InputState, type SessionState, } from './useCLIState.js';
+export type { Key } from './useInputOrchestrator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACH,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,8BAA8B,EAC9B,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACH,WAAW,EACX,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,YAAY,GACpB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,GAAG,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,28 @@
+import { useAgentEvents } from "./useAgentEvents.js";
+import { useKeyboardShortcuts } from "./useKeyboardShortcuts.js";
+import {
+  useInputOrchestrator,
+  createApprovalInputHandler,
+  createSelectorInputHandler,
+  createAutocompleteInputHandler,
+  createMainInputHandler
+} from "./useInputOrchestrator.js";
+import { useKeypress } from "./useKeypress.js";
+import { useTerminalSize } from "./useTerminalSize.js";
+import { useGitBranch } from "./useGitBranch.js";
+import {
+  useCLIState
+} from "./useCLIState.js";
+export {
+  createApprovalInputHandler,
+  createAutocompleteInputHandler,
+  createMainInputHandler,
+  createSelectorInputHandler,
+  useAgentEvents,
+  useCLIState,
+  useGitBranch,
+  useInputOrchestrator,
+  useKeyboardShortcuts,
+  useKeypress,
+  useTerminalSize
+};