giggles 0.5.1 → 0.5.3

package/dist/{chunk-LXNKSYJT.js → chunk-RO3ZD423.js}

@@ -48,7 +48,6 @@ function useKeybindingRegistry(focus) {
     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) : [];
@@ -397,14 +396,13 @@ var FocusStore = class {
       if (typeof def === "function") {
         return [key, { handler: def }];
       }
-      return [key, { handler: def.action, name: def.name, when: def.when }];
+      return [key, { handler: def.action, name: def.name }];
     });
     const registration = {
       bindings: new Map(entries),
       capture: (options == null ? void 0 : options.capture) ?? false,
       onKeypress: options == null ? void 0 : options.onKeypress,
-      passthrough: (options == null ? void 0 : options.passthrough) ? new Set(options.passthrough) : void 0,
-      layer: options == null ? void 0 : options.layer
+      passthrough: (options == null ? void 0 : options.passthrough) ? new Set(options.passthrough) : void 0
     };
     if (!this.keybindings.has(nodeId)) {
       this.keybindings.set(nodeId, /* @__PURE__ */ new Map());
@@ -427,7 +425,6 @@ var FocusStore = class {
     let finalCapture = false;
     let finalOnKeypress;
     let finalPassthrough;
-    let finalLayer;
     for (const registration of nodeRegistrations.values()) {
       const isCaptureRegistration = registration.onKeypress !== void 0;
       const shouldIncludeBindings = !isCaptureRegistration || registration.capture;
@@ -441,16 +438,12 @@ var FocusStore = class {
         finalOnKeypress = registration.onKeypress;
         finalPassthrough = registration.passthrough;
       }
-      if (registration.layer) {
-        finalLayer = registration.layer;
-      }
     }
     return {
       bindings: mergedBindings,
       capture: finalCapture,
       onKeypress: finalOnKeypress,
-      passthrough: finalPassthrough,
-      layer: finalLayer
+      passthrough: finalPassthrough
     };
   }
   getAllBindings() {
@@ -462,9 +455,7 @@ var FocusStore = class {
             nodeId,
             key,
             handler: entry.handler,
-            name: entry.name,
-            when: entry.when,
-            layer: registration.layer
+            name: entry.name
           });
         }
       }
@@ -476,38 +467,41 @@ var FocusStore = class {
   // ---------------------------------------------------------------------------
   // Bridge target for InputRouter. Walks the active branch path with passive-scope
   // skipping, capture mode, and trap boundary — the full dispatch algorithm.
+  //
+  // Priority order (per node, walking focused → root):
+  //   1. Named bindings — always checked first
+  //   2. Capture mode (onKeypress) — deferred until after the full path walk,
+  //      so named bindings at any ancestor still fire before capture kicks in.
+  //      Keys in `passthrough` skip capture and bubble to the next ancestor.
+  //   3. Trap boundary — stops the walk; capture inside the trap still fires.
   dispatch(input, key) {
     var _a;
     const keyName = normalizeKey(input, key);
     if (!keyName) return;
     const path = this.getActiveBranchPath();
     const trapNodeId = this.trapNodeId;
+    let pendingCapture;
     for (const nodeId of path) {
       if (this.passiveSet.has(nodeId)) continue;
       const nodeBindings = this.getNodeBindings(nodeId);
       if (nodeBindings) {
-        if (nodeBindings.capture && nodeBindings.onKeypress) {
-          if (!((_a = nodeBindings.passthrough) == null ? void 0 : _a.has(keyName))) {
-            nodeBindings.onKeypress(input, key);
-            return;
-          }
-        }
         const entry = nodeBindings.bindings.get(keyName);
-        if (entry && entry.when !== "mounted") {
+        if (entry) {
           entry.handler(input, key);
           return;
         }
+        if (!pendingCapture && nodeBindings.capture && nodeBindings.onKeypress) {
+          if ((_a = nodeBindings.passthrough) == null ? void 0 : _a.has(keyName)) {
+            continue;
+          }
+          pendingCapture = nodeBindings.onKeypress;
+        }
       }
       if (nodeId === trapNodeId) {
-        return;
-      }
-    }
-    for (const binding of this.getAllBindings()) {
-      if (binding.key === keyName && binding.when === "mounted") {
-        binding.handler(input, key);
-        return;
+        break;
       }
     }
+    pendingCapture == null ? void 0 : pendingCapture(input, key);
   }
   // ---------------------------------------------------------------------------
   // Private helpers

package/dist/index.d.ts

@@ -2,8 +2,8 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
 import { BoxProps } from 'ink';
 export { Key } from 'ink';
-import { K as Keybindings, a as KeybindingOptions, R as RegisteredKeybinding } from './types-Dmw9TKt4.js';
-export { b as KeyHandler } from './types-Dmw9TKt4.js';
+import { K as Keybindings, a as KeybindingOptions, R as RegisteredKeybinding } from './types-BODf7e7U.js';
+export { b as KeyHandler } from './types-BODf7e7U.js';
 
 declare class GigglesError extends Error {
     constructor(message: string);

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   useKeybindingRegistry,
   useKeybindings,
   useStore
-} from "./chunk-LXNKSYJT.js";
+} from "./chunk-RO3ZD423.js";
 import {
   ThemeProvider,
   useTheme

package/dist/{types-Dmw9TKt4.d.ts → types-BODf7e7U.d.ts}

@@ -6,22 +6,18 @@ type KeyName = SpecialKey | (string & {});
 type KeybindingDefinition = KeyHandler | {
     action: KeyHandler;
     name: string;
-    when?: 'focused' | 'mounted';
 };
 type Keybindings = Partial<Record<KeyName, KeybindingDefinition>>;
 type KeybindingOptions = {
     capture?: boolean;
     onKeypress?: (input: string, key: Key) => void;
     passthrough?: string[];
-    layer?: string;
 };
 type RegisteredKeybinding = {
     nodeId: string;
     key: string;
     handler: KeyHandler;
     name?: string;
-    when?: 'focused' | 'mounted';
-    layer?: string;
 };
 
 export type { Keybindings as K, RegisteredKeybinding as R, KeybindingOptions as a, KeyHandler as b };

package/dist/ui/index.d.ts

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { R as RegisteredKeybinding } from '../types-Dmw9TKt4.js';
+import { R as RegisteredKeybinding } from '../types-BODf7e7U.js';
 import React$1 from 'react';
 import { BoxProps } from 'ink';
 

package/dist/ui/index.js

@@ -4,7 +4,7 @@ import {
   useFocusNode,
   useKeybindingRegistry,
   useKeybindings
-} from "../chunk-LXNKSYJT.js";
+} from "../chunk-RO3ZD423.js";
 import {
   CodeBlock
 } from "../chunk-SKSDNDQF.js";
@@ -78,7 +78,6 @@ function Inner({ onClose, render }) {
     },
     {
       capture: true,
-      passthrough: ["escape", "enter", "left", "right", "backspace"],
       onKeypress: (input, key) => {
         if (input.length === 1 && !key.ctrl) {
           setQuery((q) => q + input);
@@ -644,20 +643,7 @@ function Autocomplete({
     },
     {
       capture: true,
-      passthrough: [
-        "tab",
-        "shift+tab",
-        "escape",
-        "backspace",
-        "delete",
-        "left",
-        "right",
-        "home",
-        "end",
-        "up",
-        "down",
-        "enter"
-      ],
+      passthrough: ["tab", "shift+tab", "escape"],
       onKeypress: (input, key) => {
         if (input.length === 1 && !key.ctrl && !key.return && !key.escape && !key.tab) {
           const c = cursorRef.current;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "giggles",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "license": "MIT",
   "repository": {
     "type": "git",