@hexdspace/react 0.1.50 → 0.1.52

package/dist/index.d.ts

@@ -926,13 +926,13 @@ declare class VimController {
     private readonly regions;
     private readonly handleKey;
     private readonly selection;
-    private readonly modifierMovementActionsByScope;
+    private readonly modifierMovementActionsByRegion;
     constructor(selection: SelectionController, regions?: VimRegionRegistry, handleKey?: VimHandleKeyUseCase);
     handleRegisterRegionMeta(meta: VimRegionMeta): void;
     handleUnregisterRegionMeta(key: RegionKey): void;
     handleCharKey(char: string, e: KeyboardEvent): void;
     handleEscape(e: KeyboardEvent): void;
-    setModifierMovementActions(scopeId: ScopeId, actions: VimModifierMovementActions | null): void;
+    setModifierMovementActions(key: RegionKey, actions: VimModifierMovementActions | null): void;
     handleModifiedMovement(dir: VimDirection, modifier: VimMovementModifier, e: KeyboardEvent): void;
     resetActiveScope(): void;
     getSelection(): SelectionController;
@@ -956,7 +956,7 @@ type VimBindingOptions = {
     allowArrowKeys?: boolean;
     modifierMovementActions?: VimModifierMovementActions;
 };
-declare function useVimBindings(keyboardScopeId: string, options?: VimBindingOptions): void;
+declare function useVimBindings(regionKey: RegionKey, keyboardScopeId: string, options?: VimBindingOptions): void;
 
 type UseVimRegionArgs = {
     key: RegionKey;

package/dist/index.js

@@ -3576,7 +3576,7 @@ var VimController = class {
   regions;
   handleKey;
   selection;
-  modifierMovementActionsByScope = /* @__PURE__ */ new Map();
+  modifierMovementActionsByRegion = /* @__PURE__ */ new Map();
   constructor(selection, regions = new VimRegionRegistry(), handleKey = new VimHandleKeyUseCase(
     selection.getHandle(),
     selection.getQuery(),
@@ -3599,19 +3599,20 @@ var VimController = class {
   handleEscape(e) {
     this.handleKey.handleEscape(e);
   }
-  setModifierMovementActions(scopeId, actions) {
+  setModifierMovementActions(key, actions) {
+    const regionKey = toRegionKeyString(key);
     if (!actions) {
-      this.modifierMovementActionsByScope.delete(scopeId);
+      this.modifierMovementActionsByRegion.delete(regionKey);
       return;
     }
-    this.modifierMovementActionsByScope.set(scopeId, actions);
+    this.modifierMovementActionsByRegion.set(regionKey, actions);
   }
   handleModifiedMovement(dir, modifier, e) {
     const scopeId = this.selection.getActiveScope();
     if (!scopeId) return;
     const activeKey = this.selection.getActiveRegion(scopeId);
     if (!activeKey) return;
-    const actions = this.modifierMovementActionsByScope.get(scopeId);
+    const actions = this.modifierMovementActionsByRegion.get(toRegionKeyString(activeKey));
     const action = actions?.[modifier]?.[dir];
     if (!action) return;
     const itemId = this.selection.getActiveItem(activeKey);
@@ -3648,6 +3649,9 @@ var createVimController = controllerFactory(
     };
   }
 );
+function toRegionKeyString(key) {
+  return `${key.scopeId}.${key.regionId}`;
+}
 
 // src/feature/vim-navigation/infra/web/react/VimControllerProvider.tsx
 import { createContext as createContext5, useContext as useContext6 } from "react";
@@ -3667,30 +3671,40 @@ import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMem
 var scopeBindings = /* @__PURE__ */ new Map();
 function notify(entry) {
   for (const notifySub of entry.subscribers.values()) {
-    notifySub(entry.ownerId);
+    notifySub(entry);
   }
 }
-function useVimBindings(keyboardScopeId, options = {}) {
+function getScopeEntry(keyboardScopeId) {
+  const existing = scopeBindings.get(keyboardScopeId);
+  if (existing) return existing;
+  const entry = {
+    ownerId: null,
+    subscribers: /* @__PURE__ */ new Map(),
+    modifierActionsByOwner: /* @__PURE__ */ new Map(),
+    modifierActionsVersion: 0
+  };
+  scopeBindings.set(keyboardScopeId, entry);
+  return entry;
+}
+function useVimBindings(regionKey, keyboardScopeId, options = {}) {
   const vim = useVimController();
   const enabled = options.enabled ?? true;
   const allowArrowKeys = options.allowArrowKeys ?? true;
   const modifierMovementActions = options.modifierMovementActions;
   const ownerIdRef = useRef3(Symbol("vim-binding-owner"));
   const [isOwner, setIsOwner] = useState5(false);
-  const handleOwnerChange = useCallback5((ownerId) => {
-    setIsOwner(ownerId === ownerIdRef.current);
+  const [modifierActionsVersion, setModifierActionsVersion] = useState5(0);
+  const handleEntryChange = useCallback5((entry) => {
+    setIsOwner(entry.ownerId === ownerIdRef.current);
+    setModifierActionsVersion(entry.modifierActionsVersion);
   }, []);
   useEffect7(() => {
     if (!enabled) {
       setIsOwner(false);
       return;
     }
-    const entry = scopeBindings.get(keyboardScopeId) ?? {
-      ownerId: null,
-      subscribers: /* @__PURE__ */ new Map()
-    };
-    scopeBindings.set(keyboardScopeId, entry);
-    entry.subscribers.set(ownerIdRef.current, handleOwnerChange);
+    const entry = getScopeEntry(keyboardScopeId);
+    entry.subscribers.set(ownerIdRef.current, handleEntryChange);
     if (!entry.ownerId) {
       entry.ownerId = ownerIdRef.current;
     }
@@ -3700,25 +3714,46 @@ function useVimBindings(keyboardScopeId, options = {}) {
       if (entry.ownerId === ownerIdRef.current) {
         const nextOwner = entry.subscribers.keys().next().value ?? null;
         entry.ownerId = nextOwner;
-        if (!nextOwner && entry.subscribers.size === 0) {
+        if (!nextOwner && entry.subscribers.size === 0 && entry.modifierActionsByOwner.size === 0) {
           scopeBindings.delete(keyboardScopeId);
           return;
         }
         notify(entry);
         return;
       }
-      if (entry.subscribers.size === 0) {
+      if (entry.subscribers.size === 0 && entry.modifierActionsByOwner.size === 0) {
         scopeBindings.delete(keyboardScopeId);
       }
     };
-  }, [enabled, handleOwnerChange, keyboardScopeId]);
+  }, [enabled, handleEntryChange, keyboardScopeId]);
   useEffect7(() => {
-    if (!enabled || !isOwner) {
+    if (!enabled) {
       return;
     }
-    vim.setModifierMovementActions(keyboardScopeId, modifierMovementActions ?? null);
-    return () => vim.setModifierMovementActions(keyboardScopeId, null);
-  }, [enabled, isOwner, keyboardScopeId, modifierMovementActions, vim]);
+    const entry = getScopeEntry(keyboardScopeId);
+    entry.modifierActionsByOwner.set(ownerIdRef.current, modifierMovementActions ?? null);
+    entry.modifierActionsVersion += 1;
+    notify(entry);
+    return () => {
+      const existing = scopeBindings.get(keyboardScopeId);
+      if (!existing) return;
+      existing.modifierActionsByOwner.delete(ownerIdRef.current);
+      existing.modifierActionsVersion += 1;
+      if (!existing.ownerId && existing.subscribers.size === 0 && existing.modifierActionsByOwner.size === 0) {
+        scopeBindings.delete(keyboardScopeId);
+        return;
+      }
+      notify(existing);
+    };
+  }, [enabled, keyboardScopeId, modifierMovementActions]);
+  useEffect7(() => {
+    if (!enabled) {
+      vim.setModifierMovementActions(regionKey, null);
+      return;
+    }
+    vim.setModifierMovementActions(regionKey, modifierMovementActions ?? null);
+    return () => vim.setModifierMovementActions(regionKey, null);
+  }, [enabled, modifierMovementActions, regionKey, vim]);
   const bindings = useMemo6(() => {
     if (!enabled || !isOwner) {
       return [];
@@ -3752,11 +3787,12 @@ function useVimBindings(keyboardScopeId, options = {}) {
       shift: { label: "Shift", prefix: "Shift" },
       ctrlShift: { label: "Ctrl+Shift", prefix: "Control+Shift" }
     };
+    const modifierAvailability = getModifierAvailability(keyboardScopeId);
     const modifierBindings = (modifier, actions) => {
       if (!actions) return [];
       const { label, prefix } = modifierLabels[modifier];
       return movementEntries.flatMap((entry) => {
-        if (!actions?.[entry.dir]) return [];
+        if (!actions[entry.dir]) return [];
         const combos = [`${prefix}+${entry.char.toUpperCase()}`];
         if (entry.arrow) {
           combos.push(`${prefix}+${entry.arrow}`);
@@ -3812,13 +3848,44 @@ function useVimBindings(keyboardScopeId, options = {}) {
         group: "vim"
       },
       { combos: ["Escape"], handler: (e) => vim.handleEscape(e), description: "vim: escape", group: "vim" },
-      ...modifierBindings("ctrl", modifierMovementActions?.ctrl),
-      ...modifierBindings("shift", modifierMovementActions?.shift),
-      ...modifierBindings("ctrlShift", modifierMovementActions?.ctrlShift)
+      ...modifierBindings("ctrl", modifierAvailability?.ctrl),
+      ...modifierBindings("shift", modifierAvailability?.shift),
+      ...modifierBindings("ctrlShift", modifierAvailability?.ctrlShift)
     ];
-  }, [allowArrowKeys, enabled, isOwner, modifierMovementActions, vim]);
+  }, [allowArrowKeys, enabled, isOwner, keyboardScopeId, modifierActionsVersion, vim]);
   useShortcut(keyboardScopeId, bindings, { ignoreTyping: true, preventDefault: true });
 }
+function getModifierAvailability(keyboardScopeId) {
+  const entry = scopeBindings.get(keyboardScopeId);
+  if (!entry) return null;
+  const result = {
+    ctrl: {},
+    shift: {},
+    ctrlShift: {}
+  };
+  for (const actions of entry.modifierActionsByOwner.values()) {
+    if (!actions) continue;
+    const ctrl = actions.ctrl;
+    if (ctrl) {
+      for (const dir of Object.keys(ctrl)) {
+        if (ctrl[dir]) result.ctrl[dir] = true;
+      }
+    }
+    const shift = actions.shift;
+    if (shift) {
+      for (const dir of Object.keys(shift)) {
+        if (shift[dir]) result.shift[dir] = true;
+      }
+    }
+    const ctrlShift = actions.ctrlShift;
+    if (ctrlShift) {
+      for (const dir of Object.keys(ctrlShift)) {
+        if (ctrlShift[dir]) result.ctrlShift[dir] = true;
+      }
+    }
+  }
+  return result;
+}
 
 // src/feature/vim-navigation/infra/web/react/hook/use-vim-region.tsx
 import { useEffect as useEffect9, useMemo as useMemo8, useRef as useRef4, useSyncExternalStore } from "react";
@@ -3899,7 +3966,7 @@ function useVimRegion(containerRef, args) {
     keyboard.handleEnableScope(keyboardScopeId);
     return () => keyboard.handleDisableScope(keyboardScopeId);
   }, [bindKeys, keyboard, keyboardScopeId]);
-  useVimBindings(keyboardScopeId, {
+  useVimBindings(args.key, keyboardScopeId, {
     enabled: bindKeys,
     allowArrowKeys: args.allowArrowKeys,
     modifierMovementActions: args.modifierMovementActions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexdspace/react",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",