@weasel-js/routing 1.11.1 → 1.12.0

package/dist/react.js

@@ -1,4 +1,4 @@
-import { createDepRegistry, createDispatchTrace, createDispatcher, assembleEntries, liveScope, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, tuneAction, createMenuHost, pushOwner, evaluateEnabled, tunedParams, validateActionId, validateActionDefaultBinding, isTool, depNodeOf, DepNode, buildDepsFromRequires, clientToCanvas, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, carryGestureId, anyBinding, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, actionCursor } from './chunk-KLBH7VFF.js';
+import { createDepRegistry, createKeymapStack, createDispatchTrace, createDispatcher, describeKeymap, assembleEntries, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, NO_OVERRIDES, reportRouteConflicts, ScopeNode, overrideActionBindings, tuneAction, resolveBindingOverrides, createMenuHost, pushOwner, evaluateEnabled, tunedParams, validateActionId, validateActionDefaultBinding, isTool, depNodeOf, DepNode, buildDepsFromRequires, clientToCanvas, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, carryGestureId, anyBinding, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, actionCursor } from './chunk-ARDHI47M.js';
 import { createContext, useState, useContext, useEffect, useMemo, useRef, useCallback, useSyncExternalStore } from 'react';
 import { isApplePlatform, heldPointers, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
 import { isDev, useLatest, useKitSettings, useStableByContent, sameList } from '@weasel-js/react';
@@ -148,6 +148,8 @@ var ActionsNode = class extends ScopeNode {
   actions = /* @__PURE__ */ new Map();
   muted = /* @__PURE__ */ new Map();
   tunings = /* @__PURE__ */ new Map();
+  overrides = [];
+  overrideCache = null;
   dispatchers = [];
   cache = null;
   host = null;
@@ -173,7 +175,17 @@ var ActionsNode = class extends ScopeNode {
   /** `a` under every tuning for its id from the root down to here. */
   tuned(a) {
     const tunings = this.tuningsOf(a.id);
-    return tunings.length ? tuneAction(a, tunings) : a;
+    return overrideActionBindings(tunings.length ? tuneAction(a, tunings) : a, this.overridesHere());
+  }
+  /** Every binding override from the root down to here, read into specs. */
+  overridesHere() {
+    const cached = this.overrideCache;
+    if (cached && cached.version === this.tree.version) return cached.resolved;
+    const maps = [];
+    for (const n of this.chain()) maps.unshift(...n.overrides);
+    const resolved = resolveBindingOverrides(maps);
+    this.overrideCache = { version: this.tree.version, resolved };
+    return resolved;
   }
   snapshot() {
     const leaf = this.start();
@@ -291,6 +303,18 @@ var ActionsNode = class extends ScopeNode {
       };
     },
     paramsOf: (id, given) => tunedParams(this.tuningsOf(id), given),
+    overrideBindings: (overrides) => {
+      const release = pushOwner(this.overrides, overrides);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        release();
+        this.changed();
+      };
+    },
+    bindingOverrides: () => this.start().overridesHere(),
     list: () => this.snapshot(),
     trigger: (id, params) => {
       const leaf = this.start();
@@ -427,6 +451,10 @@ function createDispatchCore(src) {
   const dispatcherNow = () => target().dispatcher;
   const routedDeps = withViewDeps(() => src.context().depRegistry, () => target().deps?.());
   const routedRuleCtx = () => target().getRuleCtx?.();
+  const batch = (fn) => {
+    const keymaps = src.context().keymaps;
+    return keymaps ? keymaps.batch(fn) : fn();
+  };
   const ctxNow = () => ({
     ...src.context(),
     depRegistry: routedDeps,
@@ -462,11 +490,13 @@ function createDispatchCore(src) {
       const [x, y] = clientToCanvas(canvas, cx, cy);
       return { x, y };
     },
-    dispatch: (ev, on, reach) => {
+    dispatch: (ev, on, reach) => batch(() => {
       const d = on ?? dispatcherNow();
       src.uses(d);
       return d.handleInput(ev, reach ? { ...ctxNow(), keyReach: reach } : ctxNow());
-    },
+    }),
+    batch,
+    keymaps: () => src.context().keymaps,
     holdsKeys: () => canvas ? src.actions().holdsKeys() : src.actions().isActive(),
     pointerOver: () => over,
     setPointerOver: (next) => {
@@ -797,49 +827,71 @@ function ingestInput(core) {
   return { onDragOver, onDragLeave, onDrop, onPaste };
 }
 
+// src/interactions/dispatcher/channels/keymapKeys.ts
+function keymapKeys(stack) {
+  const leaders = /* @__PURE__ */ new Map();
+  const quiet = /* @__PURE__ */ new Set();
+  const release = (physical) => {
+    if (leaders.delete(physical)) stack()?.release(`key:${physical}`);
+  };
+  return {
+    quiet: (physical) => leaders.has(physical) || quiet.has(physical),
+    press: (e, physical, run) => {
+      const before = stack()?.innermost() ?? null;
+      run();
+      const s = stack();
+      if (s?.holdOpened(`key:${physical}`)) leaders.set(physical, e.metaKey);
+      else if (before !== null && s?.innermost() !== before) quiet.add(physical);
+    },
+    up: (e, physical) => {
+      quiet.delete(physical);
+      release(physical);
+      if (e.key === "Meta") {
+        for (const [k, withCmd] of [...leaders]) if (withCmd) release(k);
+      }
+    },
+    clear: () => {
+      leaders.clear();
+      quiet.clear();
+    }
+  };
+}
+
 // src/interactions/dispatcher/channels/keyboard.ts
 function typedWithAltGraph(e) {
   if (!e.ctrlKey || !e.altKey || e.key.length !== 1 || !e.getModifierState?.("AltGraph")) return false;
   const base = /^(?:Key|Digit)(.)$/.exec(e.code)?.[1];
   return base === void 0 || base.toLowerCase() !== e.key.toLowerCase();
 }
+function keystrokeEvents(e, mods) {
+  const common = { key: e.key, ...e.code ? { code: e.code } : {}, ...mods, metaKey: e.metaKey, shiftKey: e.shiftKey };
+  return {
+    keyEv: { kind: "key", ...common, repeat: e.repeat },
+    heldEv: { kind: "key-held", ...common, phase: "down" }
+  };
+}
 var inMenu = (t) => t instanceof Element && t.closest('[role="menu"]') !== null;
 function keyboardInput(core) {
   const { dispatch, dispatcherNow } = core;
   const heldKeys = /* @__PURE__ */ new Map();
+  const keymaps = keymapKeys(core.keymaps);
   const codeOf = (e) => e.code ? { code: e.code } : {};
   const physicalKey = (e) => e.code || e.key.toLowerCase();
   const onKeyDown = (e) => {
     if (e.defaultPrevented || isEditableTarget(e.target) || inMenu(e.target) || focusedControlOwnsKey(e)) return;
     const reach = { held: core.holdsKeys(), over: core.pointerOver() };
     if (!reach.held && !reach.over) return;
-    if (e.repeat && heldKeys.has(physicalKey(e))) {
+    if (e.repeat && (heldKeys.has(physicalKey(e)) || keymaps.quiet(physicalKey(e)))) {
       e.preventDefault();
       return;
     }
-    if (press(e, { altKey: e.altKey, ctrlKey: e.ctrlKey }, reach)) return;
-    if (typedWithAltGraph(e)) press(e, { altKey: false, ctrlKey: false }, reach);
+    const altGr = typedWithAltGraph(e);
+    const typed = { altKey: false, ctrlKey: false };
+    keymaps.press(e, physicalKey(e), () => core.batch(() => altGr && core.keymaps()?.innermost() ? press(e, typed, reach) : press(e, { altKey: e.altKey, ctrlKey: e.ctrlKey }, reach) || altGr && press(e, typed, reach)));
   };
   const press = (e, mods, reach) => {
-    const keyEv = {
-      kind: "key",
-      key: e.key,
-      ...codeOf(e),
-      ...mods,
-      metaKey: e.metaKey,
-      shiftKey: e.shiftKey,
-      repeat: e.repeat
-    };
+    const { keyEv, heldEv } = keystrokeEvents(e, mods);
     const keyResult = dispatch(keyEv, void 0, reach);
-    const heldEv = {
-      kind: "key-held",
-      key: e.key,
-      ...codeOf(e),
-      phase: "down",
-      ...mods,
-      metaKey: e.metaKey,
-      shiftKey: e.shiftKey
-    };
     const heldOn = dispatcherNow();
     const heldResult = dispatch(heldEv, heldOn, reach);
     if (heldResult === "handled") {
@@ -851,6 +903,7 @@ function keyboardInput(core) {
   };
   const onKeyUp = (e) => {
     const physical = physicalKey(e);
+    keymaps.up(e, physical);
     const down = heldKeys.get(physical);
     if (down === void 0) return;
     const ev = {
@@ -867,6 +920,7 @@ function keyboardInput(core) {
     dispatch(ev, down.on);
   };
   const releaseAll = () => {
+    keymaps.clear();
     const releasing = [...heldKeys.values()];
     heldKeys.clear();
     for (const { key, code, on } of releasing) {
@@ -1194,6 +1248,7 @@ function attachInput(canvas, src, channels) {
     pinch.end();
     pointer.cancelHeld();
     keys.releaseAll();
+    src.context().keymaps?.closeAll();
   };
   const listeners = listenerSet();
   const keyCapture = channels.keyboard === "first";
@@ -1257,6 +1312,7 @@ function attachInput(canvas, src, channels) {
     held?.release();
     redraw.stop();
     for (const d of src.dispatchers()) d.cancelAll("cancel");
+    src.context().keymaps?.closeAll();
   };
 }
 
@@ -1275,6 +1331,9 @@ function useGestureDispatcher(opts) {
   const activeTool = useActiveToolContext();
   const depRegistry = useDepRegistry();
   const [isMac] = useState(isApplePlatform);
+  const [keymaps] = useState(createKeymapStack);
+  useEffect(() => depRegistry.register("keymaps", () => keymaps), [depRegistry, keymaps]);
+  const kitSettings = useKitSettings();
   const [ownTrace] = useState(createDispatchTrace);
   const trace = traceOpt ?? ownTrace;
   useEffect(() => depRegistry.register("dispatchTrace", () => trace), [depRegistry, trace]);
@@ -1294,7 +1353,10 @@ function useGestureDispatcher(opts) {
     hotkeyStack: activeTool.hotkeyStack,
     entriesById,
     isMac,
-    trace
+    trace,
+    bindingOverrides: () => registryRef.current.bindingOverrides(),
+    keymaps,
+    leaderUnbound: kitSettings.get("gestures.keymapUnbound")
   });
   const rootTargetRef = useLatest({
     id: null,
@@ -1313,7 +1375,7 @@ function useGestureDispatcher(opts) {
   const requestRedrawRef = useLatest(requestRedraw);
   const cursorRef = useLatest({ painted: paintedCursor, sink: cursorSink });
   const longPressRef = useLatest(longPress);
-  const kitSettingsRef = useLatest(useKitSettings());
+  const kitSettingsRef = useLatest(kitSettings);
   const clicksRef = useRef({ last: null });
   useToolLifecycle({
     entriesById,
@@ -1489,6 +1551,34 @@ function useOngoingAction(actionId) {
   }, [edit, actionId]);
   return edit;
 }
+function useInnermostKeymap() {
+  const deps = useOptionalDepRegistry();
+  const subscribe = useCallback((notify) => {
+    if (!deps) return () => {
+    };
+    let leaveStack = deps.get("keymaps")?.subscribe(notify);
+    const leaveDeps = deps.subscribe?.(() => {
+      leaveStack?.();
+      leaveStack = deps.get("keymaps")?.subscribe(notify);
+      notify();
+    });
+    return () => {
+      leaveStack?.();
+      leaveDeps?.();
+    };
+  }, [deps]);
+  return useSyncExternalStore(subscribe, () => deps?.get("keymaps")?.innermost() ?? null);
+}
+
+// src/keymaps/useOpenKeymap.ts
+function useOpenKeymap() {
+  const registry = useActionsRegistry();
+  const open = useInnermostKeymap();
+  return useMemo(
+    () => open ? describeKeymap(open, registry?.list() ?? [], registry?.bindingOverrides()) : null,
+    [open, registry]
+  );
+}
 function samePos(a, b) {
   if (a === null || b === null) return a === b;
   return a.worldX === b.worldX && a.worldY === b.worldY && a.viewId === b.viewId;
@@ -1579,7 +1669,7 @@ function usePublishSelection(ids, kinds) {
     }
   }, [ctxRef, serializedRef]);
 }
-var NO_MODES = () => () => {
+var NO_SUBSCRIBE2 = () => () => {
 };
 function useContributions(opts) {
   const ctx = useActiveToolContext();
@@ -1601,16 +1691,18 @@ function useContributions(opts) {
   }, [ctx]);
   const modes = opts.modes;
   const modeVersion = useSyncExternalStore(
-    modes ? modes.subscribe : NO_MODES,
+    modes ? modes.subscribe : NO_SUBSCRIBE2,
     () => modes?.getVersion() ?? 0
   );
+  const openKeymap = useInnermostKeymap()?.id ?? null;
   const snapshot = useCallback(() => assembleEntries(entries, {
     focusedId: focused,
     hotkeyStack: engaged,
+    openKeymap,
     ...modes ? { allowedCapabilities: activeModeOf(modes.current()).allowedCapabilities } : {}
     // The version is what changes; `modes` is one object for the registry's life.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }), [entries, focused, engaged, modes, modeVersion]);
+  }), [entries, focused, engaged, openKeymap, modes, modeVersion]);
   const overlays = useCallback((position = "top") => {
     const { ordered, state } = snapshot();
     const active = [];
@@ -1633,21 +1725,28 @@ function useContributions(opts) {
   const modesRegistry = opts.modes;
   useEffect(() => {
     if (!isDev()) return;
-    const last = lastConflictSigRef.current;
-    if (last?.sig === entrySig && last.modes === modesRegistry) return;
-    lastConflictSigRef.current = { sig: entrySig, modes: modesRegistry };
-    const registry = [];
-    const ambient = [];
-    for (const entry of entries) {
-      if (entry.eligibility?.focus) registry.push(entry);
-      if (entry.eligibility?.always || entry.eligibility?.claimed) ambient.push(entry);
-    }
-    reportRouteConflicts({
-      registry,
-      ambient,
-      actions: actionsRegistry?.list() ?? [],
-      ...modesRegistry ? { modes: modesRegistry.list().map(activeModeOf) } : {}
-    });
+    const check = () => {
+      const overrides = actionsRegistry?.bindingOverrides() ?? NO_OVERRIDES;
+      const sig = `${entrySig}|${JSON.stringify([...overrides])}`;
+      const last = lastConflictSigRef.current;
+      if (last?.sig === sig && last.modes === modesRegistry) return;
+      lastConflictSigRef.current = { sig, modes: modesRegistry };
+      const registry = [];
+      const ambient = [];
+      for (const entry of entries) {
+        if (entry.eligibility?.focus) registry.push(entry);
+        if (entry.eligibility?.always || entry.eligibility?.claimed) ambient.push(entry);
+      }
+      reportRouteConflicts({
+        registry,
+        ambient,
+        actions: actionsRegistry?.list() ?? [],
+        overrides,
+        ...modesRegistry ? { modes: modesRegistry.list().map(activeModeOf) } : {}
+      });
+    };
+    check();
+    return actionsRegistry?.subscribe(check);
   }, [entrySig, entries, actionsRegistry, modesRegistry]);
   return useMemo(
     () => ({ entries, focused, setFocused, overlays }),
@@ -1768,6 +1867,6 @@ function useTools(opts) {
   );
 }
 
-export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOffhandAction, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOffhandAction, useOngoingAction, useOpenKeymap, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map