giggles 0.2.4 → 0.3.1

package/README.md

@@ -1,4 +1,4 @@
-[![CI](https://github.com/zion-off/giggles/actions/workflows/giggles-lint.yml/badge.svg)](https://github.com/zion-off/giggles/actions/workflows/giggles-lint.yml)
+[![CI](https://github.com/zion-off/giggles/actions/workflows/giggles-ci.yml/badge.svg)](https://github.com/zion-off/giggles/actions/workflows/giggles-ci.yml)
 [![CD](https://github.com/zion-off/giggles/actions/workflows/giggles-cd.yml/badge.svg)](https://github.com/zion-off/giggles/actions/workflows/giggles-cd.yml)
 [![docs](https://img.shields.io/badge/docs-giggles.zzzzion.com-blue)](https://giggles.zzzzion.com)
 

package/dist/chunk-4LED4GXQ.js

@@ -0,0 +1,460 @@
+// src/core/GigglesError.ts
+var GigglesError = class extends Error {
+  constructor(message) {
+    super(`[giggles] ${message}`);
+    this.name = "GigglesError";
+  }
+};
+
+// src/core/input/useKeybindings.tsx
+import { useEffect } from "react";
+
+// src/core/input/InputContext.tsx
+import { createContext, useCallback, useContext, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var InputContext = createContext(null);
+var InputProvider = ({ children }) => {
+  const bindingsRef = useRef(/* @__PURE__ */ new Map());
+  const trapNodeIdRef = useRef(null);
+  const registerKeybindings = useCallback((nodeId, bindings, options) => {
+    const entries = Object.entries(bindings).filter((entry) => entry[1] != null).map(([key, def]) => {
+      if (typeof def === "function") {
+        return [key, { handler: def }];
+      }
+      return [key, { handler: def.action, name: def.name, when: def.when }];
+    });
+    const registration = {
+      bindings: new Map(entries),
+      capture: (options == null ? void 0 : options.capture) ?? false,
+      onKeypress: options == null ? void 0 : options.onKeypress,
+      layer: options == null ? void 0 : options.layer
+    };
+    bindingsRef.current.set(nodeId, registration);
+  }, []);
+  const unregisterKeybindings = useCallback((nodeId) => {
+    bindingsRef.current.delete(nodeId);
+  }, []);
+  const getNodeBindings = useCallback((nodeId) => {
+    return bindingsRef.current.get(nodeId);
+  }, []);
+  const setTrap = useCallback((nodeId) => {
+    trapNodeIdRef.current = nodeId;
+  }, []);
+  const clearTrap = useCallback((nodeId) => {
+    if (trapNodeIdRef.current === nodeId) {
+      trapNodeIdRef.current = null;
+    }
+  }, []);
+  const getTrapNodeId = useCallback(() => {
+    return trapNodeIdRef.current;
+  }, []);
+  const getAllBindings = useCallback(() => {
+    const allBindings = [];
+    bindingsRef.current.forEach((nodeBindings, nodeId) => {
+      nodeBindings.bindings.forEach((entry, key) => {
+        allBindings.push({
+          nodeId,
+          key,
+          handler: entry.handler,
+          name: entry.name,
+          when: entry.when,
+          layer: nodeBindings.layer
+        });
+      });
+    });
+    return allBindings;
+  }, []);
+  return /* @__PURE__ */ jsx(
+    InputContext.Provider,
+    {
+      value: {
+        registerKeybindings,
+        unregisterKeybindings,
+        getNodeBindings,
+        setTrap,
+        clearTrap,
+        getTrapNodeId,
+        getAllBindings
+      },
+      children
+    }
+  );
+};
+function useInputContext() {
+  const context = useContext(InputContext);
+  if (!context) {
+    throw new GigglesError("useInputContext must be used within an InputProvider");
+  }
+  return context;
+}
+
+// src/core/input/useKeybindings.tsx
+function useKeybindings(focus, bindings, options) {
+  const { registerKeybindings, unregisterKeybindings } = useInputContext();
+  registerKeybindings(focus.id, bindings, options);
+  useEffect(() => {
+    return () => unregisterKeybindings(focus.id);
+  }, [focus.id, unregisterKeybindings]);
+}
+
+// src/core/focus/FocusContext.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext2, useRef as useRef2, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var FocusContext = createContext2(null);
+var FocusProvider = ({ children }) => {
+  const nodesRef = useRef2(/* @__PURE__ */ new Map());
+  const pendingFocusFirstChildRef = useRef2(/* @__PURE__ */ new Set());
+  const [focusedId, setFocusedId] = useState(null);
+  const focusNode = useCallback2((id) => {
+    const nodes = nodesRef.current;
+    if (!nodes.has(id)) return;
+    setFocusedId((current) => {
+      if (current === id) return current;
+      return id;
+    });
+  }, []);
+  const focusFirstChild = useCallback2(
+    (parentId) => {
+      const nodes = nodesRef.current;
+      const parent = nodes.get(parentId);
+      if (parent && parent.childrenIds.length > 0) {
+        focusNode(parent.childrenIds[0]);
+      } else {
+        pendingFocusFirstChildRef.current.add(parentId);
+      }
+    },
+    [focusNode]
+  );
+  const registerNode = useCallback2(
+    (id, parentId) => {
+      const nodes = nodesRef.current;
+      const node = {
+        id,
+        parentId,
+        childrenIds: []
+      };
+      nodes.set(id, node);
+      if (parentId) {
+        const parent = nodes.get(parentId);
+        if (parent && !parent.childrenIds.includes(id)) {
+          const wasEmpty = parent.childrenIds.length === 0;
+          parent.childrenIds.push(id);
+          if (wasEmpty && pendingFocusFirstChildRef.current.has(parentId)) {
+            pendingFocusFirstChildRef.current.delete(parentId);
+            focusNode(id);
+          }
+        }
+      }
+      nodes.forEach((existingNode) => {
+        if (existingNode.parentId === id && !node.childrenIds.includes(existingNode.id)) {
+          node.childrenIds.push(existingNode.id);
+        }
+      });
+      if (nodes.size === 1) {
+        focusNode(id);
+      }
+    },
+    [focusNode]
+  );
+  const unregisterNode = useCallback2((id) => {
+    const nodes = nodesRef.current;
+    const node = nodes.get(id);
+    if (!node) return;
+    if (node.parentId) {
+      const parent = nodes.get(node.parentId);
+      if (parent) {
+        parent.childrenIds = parent.childrenIds.filter((childId) => childId !== id);
+      }
+    }
+    nodes.delete(id);
+    pendingFocusFirstChildRef.current.delete(id);
+    setFocusedId((current) => {
+      if (current !== id) return current;
+      return node.parentId ?? null;
+    });
+  }, []);
+  const isFocused = useCallback2(
+    (id) => {
+      return id === focusedId;
+    },
+    [focusedId]
+  );
+  const getFocusedId = useCallback2(() => {
+    return focusedId;
+  }, [focusedId]);
+  const getActiveBranchPath = useCallback2(() => {
+    if (!focusedId) return [];
+    const nodes = nodesRef.current;
+    const pathArray = [];
+    let node = focusedId;
+    while (node) {
+      pathArray.push(node);
+      const n = nodes.get(node);
+      node = (n == null ? void 0 : n.parentId) ?? null;
+    }
+    return pathArray;
+  }, [focusedId]);
+  const navigateSibling = useCallback2(
+    (direction, wrap = true) => {
+      const currentId = focusedId;
+      if (!currentId) return;
+      const nodes = nodesRef.current;
+      const currentNode = nodes.get(currentId);
+      if (!(currentNode == null ? void 0 : currentNode.parentId)) return;
+      const parent = nodes.get(currentNode.parentId);
+      if (!parent || parent.childrenIds.length === 0) return;
+      const siblings = parent.childrenIds;
+      const currentIndex = siblings.indexOf(currentId);
+      if (currentIndex === -1) return;
+      let nextIndex;
+      if (wrap) {
+        nextIndex = direction === "next" ? (currentIndex + 1) % siblings.length : (currentIndex - 1 + siblings.length) % siblings.length;
+      } else {
+        nextIndex = direction === "next" ? Math.min(currentIndex + 1, siblings.length - 1) : Math.max(currentIndex - 1, 0);
+      }
+      focusNode(siblings[nextIndex]);
+    },
+    [focusedId, focusNode]
+  );
+  return /* @__PURE__ */ jsx2(
+    FocusContext.Provider,
+    {
+      value: {
+        registerNode,
+        unregisterNode,
+        focusNode,
+        focusFirstChild,
+        isFocused,
+        getFocusedId,
+        getActiveBranchPath,
+        navigateSibling
+      },
+      children
+    }
+  );
+};
+var FocusNodeContext = createContext2(null);
+var useFocusContext = () => {
+  const context = useContext2(FocusContext);
+  if (!context) {
+    throw new GigglesError("useFocusContext must be used within a FocusProvider");
+  }
+  return context;
+};
+
+// src/core/input/useKeybindingRegistry.ts
+function useKeybindingRegistry(focus) {
+  const { getAllBindings, getTrapNodeId } = useInputContext();
+  const { getActiveBranchPath } = useFocusContext();
+  const all = getAllBindings().filter((b) => b.name != null);
+  const branchPath = getActiveBranchPath();
+  const branchSet = new Set(branchPath);
+  const trapNodeId = getTrapNodeId();
+  const withinTrapSet = (() => {
+    if (!trapNodeId) return null;
+    const trapIndex = branchPath.indexOf(trapNodeId);
+    return trapIndex >= 0 ? new Set(branchPath.slice(0, trapIndex + 1)) : null;
+  })();
+  const available = all.filter((b) => {
+    if (b.when === "mounted") return withinTrapSet ? withinTrapSet.has(b.nodeId) : true;
+    return (withinTrapSet ?? branchSet).has(b.nodeId);
+  });
+  const local = focus ? all.filter((b) => b.nodeId === focus.id) : [];
+  return { all, available, local };
+}
+
+// src/core/input/FocusTrap.tsx
+import { useEffect as useEffect4, useRef as useRef4 } from "react";
+
+// src/core/focus/FocusGroup.tsx
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo, useRef as useRef3 } from "react";
+
+// src/core/input/InputRouter.tsx
+import { useInput } from "ink";
+
+// src/core/input/normalizeKey.ts
+function normalizeKey(input, key) {
+  if (input === "\x1B[I" || input === "\x1B[O") return "";
+  if (key.downArrow) return "down";
+  if (key.upArrow) return "up";
+  if (key.leftArrow) return "left";
+  if (key.rightArrow) return "right";
+  if (key.return) return "enter";
+  if (key.escape) return "escape";
+  if (key.tab) return "tab";
+  if (key.backspace || key.delete) return "backspace";
+  if (key.pageUp) return "pageup";
+  if (key.pageDown) return "pagedown";
+  if (key.home) return "home";
+  if (key.end) return "end";
+  if (key.ctrl && input.length === 1) {
+    return `ctrl+${input}`;
+  }
+  return input;
+}
+
+// src/core/input/InputRouter.tsx
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+function InputRouter({ children }) {
+  const { getFocusedId, getActiveBranchPath } = useFocusContext();
+  const { getNodeBindings, getTrapNodeId, getAllBindings } = useInputContext();
+  useInput((input, key) => {
+    const focusedId = getFocusedId();
+    if (!focusedId) return;
+    const path = getActiveBranchPath();
+    const trapNodeId = getTrapNodeId();
+    const keyName = normalizeKey(input, key);
+    if (!keyName) return;
+    for (const nodeId of path) {
+      const nodeBindings = getNodeBindings(nodeId);
+      if (!nodeBindings) continue;
+      const entry = nodeBindings.bindings.get(keyName);
+      if (entry && entry.when !== "mounted") {
+        entry.handler(input, key);
+        return;
+      }
+      if (nodeBindings.capture && nodeBindings.onKeypress) {
+        nodeBindings.onKeypress(input, key);
+        return;
+      }
+      if (nodeId === trapNodeId) {
+        return;
+      }
+    }
+    for (const binding of getAllBindings()) {
+      if (binding.key === keyName && binding.when === "mounted") {
+        binding.handler(input, key);
+        return;
+      }
+    }
+  });
+  return /* @__PURE__ */ jsx3(Fragment, { children });
+}
+
+// src/core/focus/FocusBindContext.tsx
+import { createContext as createContext3 } from "react";
+var FocusBindContext = createContext3(null);
+
+// src/core/focus/useFocus.ts
+import { useContext as useContext3, useEffect as useEffect2, useId } from "react";
+var useFocus = (id) => {
+  const nodeId = useId();
+  const parentId = useContext3(FocusNodeContext);
+  const bindContext = useContext3(FocusBindContext);
+  const { focusNode, registerNode, unregisterNode, isFocused } = useFocusContext();
+  useEffect2(() => {
+    registerNode(nodeId, parentId);
+    if (id && bindContext) {
+      bindContext.register(id, nodeId);
+    }
+    return () => {
+      unregisterNode(nodeId);
+      if (id && bindContext) {
+        bindContext.unregister(id);
+      }
+    };
+  }, [nodeId, parentId, id, bindContext, registerNode, unregisterNode]);
+  return {
+    id: nodeId,
+    focused: isFocused(nodeId),
+    focus: () => focusNode(nodeId)
+  };
+};
+
+// src/core/focus/FocusGroup.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function FocusGroup({
+  children,
+  direction = "vertical",
+  value,
+  wrap = true,
+  navigable = true,
+  keybindings: customBindings
+}) {
+  const focus = useFocus();
+  const { focusNode, navigateSibling } = useFocusContext();
+  const bindMapRef = useRef3(/* @__PURE__ */ new Map());
+  const register = useCallback3((logicalId, nodeId) => {
+    if (bindMapRef.current.has(logicalId)) {
+      throw new GigglesError(`FocusGroup: Duplicate id "${logicalId}". Each child must have a unique id.`);
+    }
+    bindMapRef.current.set(logicalId, nodeId);
+  }, []);
+  const unregister = useCallback3((logicalId) => {
+    bindMapRef.current.delete(logicalId);
+  }, []);
+  useEffect3(() => {
+    if (value) {
+      const nodeId = bindMapRef.current.get(value);
+      if (nodeId) {
+        focusNode(nodeId);
+      }
+    }
+  }, [value, focusNode]);
+  const bindContextValue = useMemo(() => value ? { register, unregister } : null, [value, register, unregister]);
+  const navigationKeys = useMemo(() => {
+    if (!navigable) return {};
+    const next = () => navigateSibling("next", wrap);
+    const prev = () => navigateSibling("prev", wrap);
+    return direction === "vertical" ? {
+      j: next,
+      k: prev,
+      down: next,
+      up: prev
+    } : {
+      l: next,
+      h: prev,
+      right: next,
+      left: prev
+    };
+  }, [navigable, direction, wrap, navigateSibling]);
+  const mergedBindings = useMemo(
+    () => ({ ...navigationKeys, ...customBindings }),
+    [navigationKeys, customBindings]
+  );
+  useKeybindings(focus, mergedBindings);
+  return /* @__PURE__ */ jsx4(FocusNodeContext.Provider, { value: focus.id, children: /* @__PURE__ */ jsx4(FocusBindContext.Provider, { value: bindContextValue, children }) });
+}
+
+// src/core/focus/useFocusState.ts
+import { useState as useState2 } from "react";
+function useFocusState(initial) {
+  const [focused, setFocused] = useState2(initial);
+  return [focused, setFocused];
+}
+
+// src/core/input/FocusTrap.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function FocusTrap({ children }) {
+  const { id } = useFocus();
+  const { setTrap, clearTrap } = useInputContext();
+  const { focusFirstChild, getFocusedId, focusNode } = useFocusContext();
+  const previousFocusRef = useRef4(getFocusedId());
+  useEffect4(() => {
+    const previousFocus = previousFocusRef.current;
+    setTrap(id);
+    focusFirstChild(id);
+    return () => {
+      clearTrap(id);
+      if (previousFocus) {
+        focusNode(previousFocus);
+      }
+    };
+  }, [id]);
+  return /* @__PURE__ */ jsx5(FocusNodeContext.Provider, { value: id, children });
+}
+
+export {
+  GigglesError,
+  FocusProvider,
+  FocusNodeContext,
+  useFocusContext,
+  InputProvider,
+  InputRouter,
+  useKeybindings,
+  useKeybindingRegistry,
+  FocusTrap,
+  useFocus,
+  FocusGroup,
+  useFocusState
+};

package/dist/chunk-7PDVDYFB.js

@@ -0,0 +1,23 @@
+// src/terminal/components/AlternateScreen.tsx
+import { useEffect, useState } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var _a;
+var isTTY = typeof process !== "undefined" && ((_a = process.stdout) == null ? void 0 : _a.write);
+function AlternateScreen({ children }) {
+  const [ready, setReady] = useState(!isTTY);
+  useEffect(() => {
+    if (!isTTY) return;
+    process.stdout.write("\x1B[?1049h");
+    process.stdout.write("\x1B[2J");
+    process.stdout.write("\x1B[H");
+    setReady(true);
+    return () => {
+      process.stdout.write("\x1B[?1049l");
+    };
+  }, []);
+  return ready ? /* @__PURE__ */ jsx(Fragment, { children }) : null;
+}
+
+export {
+  AlternateScreen
+};

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React$1 from 'react';
 import React__default from 'react';
-import { Key } from 'ink';
+import { K as Keybindings, a as KeybindingOptions, R as RegisteredKeybinding } from './types-ClgDW3fy.js';
+export { b as KeyHandler } from './types-ClgDW3fy.js';
 export { Key } from 'ink';
 
 declare class GigglesError extends Error {
@@ -13,14 +14,29 @@ type GigglesProviderProps = {
 };
 declare function GigglesProvider({ children }: GigglesProviderProps): react_jsx_runtime.JSX.Element;
 
+declare function useKeybindings(focus: FocusHandle, bindings: Keybindings, options?: KeybindingOptions): void;
+
+type KeybindingRegistry = {
+    all: RegisteredKeybinding[];
+    available: RegisteredKeybinding[];
+    local: RegisteredKeybinding[];
+};
+declare function useKeybindingRegistry(focus?: FocusHandle): KeybindingRegistry;
+
+type FocusTrapProps = {
+    children: React.ReactNode;
+};
+declare function FocusTrap({ children }: FocusTrapProps): react_jsx_runtime.JSX.Element;
+
 type FocusGroupProps = {
     children: React__default.ReactNode;
     direction?: 'vertical' | 'horizontal';
     value?: string;
     wrap?: boolean;
     navigable?: boolean;
+    keybindings?: Keybindings;
 };
-declare function FocusGroup({ children, direction, value, wrap, navigable }: FocusGroupProps): react_jsx_runtime.JSX.Element;
+declare function FocusGroup({ children, direction, value, wrap, navigable, keybindings: customBindings }: FocusGroupProps): react_jsx_runtime.JSX.Element;
 
 type FocusHandle = {
     id: string;
@@ -32,23 +48,6 @@ declare const useFocus: (id?: string) => FocusHandle;
 
 declare function useFocusState<T extends string>(initial: T): readonly [T, React$1.Dispatch<React$1.SetStateAction<T>>];
 
-type KeyHandler = (input: string, key: Key) => void;
-type SpecialKey = 'up' | 'down' | 'left' | 'right' | 'enter' | 'escape' | 'tab' | 'backspace' | 'delete' | 'pageup' | 'pagedown' | 'home' | 'end';
-type KeyName = SpecialKey | (string & {});
-type Keybindings = Partial<Record<KeyName, KeyHandler>>;
-type KeybindingOptions = {
-    capture?: boolean;
-    onKeypress?: (input: string, key: Key) => void;
-    layer?: string;
-};
-
-declare function useKeybindings(focus: FocusHandle, bindings: Keybindings, options?: KeybindingOptions): void;
-
-type FocusTrapProps = {
-    children: React.ReactNode;
-};
-declare function FocusTrap({ children }: FocusTrapProps): react_jsx_runtime.JSX.Element;
-
 type RouterProps = {
     children: React__default.ReactNode;
     initialScreen: string;
@@ -80,4 +79,4 @@ type NavigationContextValue = {
 
 declare const useNavigation: () => NavigationContextValue;
 
-export { FocusGroup, type FocusHandle, FocusTrap, GigglesError, GigglesProvider, type KeyHandler, type KeybindingOptions, type Keybindings, type NavigationContextValue, Router, Screen, useFocus, useFocusState, useKeybindings, useNavigation };
+export { FocusGroup, type FocusHandle, FocusTrap, GigglesError, GigglesProvider, KeybindingOptions, type KeybindingRegistry, Keybindings, type NavigationContextValue, RegisteredKeybinding, Router, Screen, useFocus, useFocusState, useKeybindingRegistry, useKeybindings, useNavigation };