@weasel-js/routing 1.14.1 → 1.15.0

package/dist/react.d.ts

@@ -1,16 +1,17 @@
-import { U as UseGestureDispatcherOptions } from './internal-CaJ4viHc.js';
-export { D as DispatcherChannels } from './internal-CaJ4viHc.js';
+import { U as UseGestureDispatcherOptions } from './internal-C8-r3Zmo.js';
+export { D as DispatcherChannels } from './internal-C8-r3Zmo.js';
 import * as react from 'react';
 import { ReactNode, ReactElement } from 'react';
-import { D as DepRegistry, a as DepName, b as DepSource, S as ScopeNode, A as Action, c as ActionDeps, M as MenuHost, d as ActionsRegistry, e as ActionDisabledReason, B as BoundGesture, f as ActionVariant, g as MenuDef, h as DepNode, T as ToolNode, K as KeymapDescription, W as WorldPoint, N as NodeId, i as KernelOverlay, C as Contribution, j as Tool, O as OverlayPosition } from './index-DJ7SxEKS.js';
-export { k as ActiveToolContextProvider, l as ActiveToolContextProviderIfRoot, m as ActiveToolContextProviderProps, n as ActiveToolContextValue, u as useActiveToolContext, o as useOptionalActiveToolContext } from './index-DJ7SxEKS.js';
+import { D as DepRegistry, a as DepName, b as DepSource, S as ScopeNode, L as LastOperationKeeper, A as Action, c as ActionDeps, M as MenuHost, d as ActionsRegistry, e as ActionDisabledReason, B as BoundGesture, f as ActionVariant, g as LastOperationStore, h as LastOperation, i as MenuDef, j as DepNode, T as ToolNode, K as KeymapDescription, W as WorldPoint, N as NodeId, k as KernelOverlay, C as Contribution, l as Tool, O as OverlayPosition } from './index-C2EcHkCp.js';
+export { m as ActiveToolContextProvider, n as ActiveToolContextProviderIfRoot, o as ActiveToolContextProviderProps, p as ActiveToolContextValue, u as useActiveToolContext, q as useOptionalActiveToolContext } from './index-C2EcHkCp.js';
 import { IconRef } from '@weasel-js/icons';
 import { ModeRegistry } from '@weasel-js/modes';
 import '@weasel-js/gestures';
 import '@weasel-js/cursor';
+import '@weasel-js/history';
+import '@weasel-js/prefs';
 import '@weasel-js/geom';
 import '@weasel-js/menu';
-import '@weasel-js/prefs';
 import '@weasel-js/registry';
 import '@weasel-js/select';
 
@@ -60,12 +61,17 @@ declare class ActionsNode extends ScopeNode<ActionsNode> {
     private host;
     /** Called on `activate`, so a scope's dep and tool nodes move with it. */
     readonly onActivate: (() => void)[];
+    /** The tree's last operation, kept at its root. */
+    readonly lastOperation: LastOperationKeeper;
+    private opHost;
     constructor(parent: ActionsNode | null, descends: boolean, contextDeps: () => DepRegistry | null);
     private resolve;
     /** Every tuning for `id` from the root down to here, root first. */
     private tuningsOf;
     /** `a` under every tuning for its id from the root down to here. */
     private tuned;
+    /** How the last operation reads and reruns what ran in this scope. */
+    private lastOperationHost;
     /** Every binding override from the root down to here, read into specs. */
     private overridesHere;
     private snapshot;
@@ -127,6 +133,14 @@ interface CommandOptions {
  */
 declare function useCommand(id: string, label: string, run: (params?: Readonly<Record<string, unknown>>) => void, options?: CommandOptions): void;
 
+/** The last operation store of the actions tree `registry` belongs to, or `null` for a registry that is not one
+ *  of the kit's. */
+declare function lastOperationOf(registry: ActionsRegistry | null): LastOperationStore | null;
+/** The last operation store of the actions tree in scope, or `null` outside an `<ActionsProvider>`. */
+declare function useLastOperationStore(): LastOperationStore | null;
+/** What `store` holds now, rerendering as it changes; `store` defaults to the one in scope. */
+declare function useLastOperation(store?: LastOperationStore | null): LastOperation | null;
+
 /** The menu host in scope: the nearest `<ActionsProvider>`'s, else the one a
  *  canvas with no provider above it makes. Null outside both. */
 declare function useMenuHost(): MenuHost | null;
@@ -329,8 +343,10 @@ interface UseToolsOptions<TOverlay = KernelOverlay> {
     /** Always-on entries — tools or other contributions, live regardless of
      *  the active slot. */
     ambient?: readonly Contribution<TOverlay>[];
-    /** The modes the canvas can be in, read by the dev-time route-conflict
-     *  check; without a registry it checks against the kit's `DEFAULT_MODES`. */
+    /** The modes the canvas can be in. A mode's `defaultTool` becomes active
+     *  as the mode is entered, and the tool it replaced comes back as the mode
+     *  is left. The dev-time route-conflict check reads them too; without a
+     *  registry it checks against the kit's `DEFAULT_MODES`. */
     modes?: ModeRegistry;
 }
 /** The tool registry's runtime surface: which tool is active, which is
@@ -419,4 +435,4 @@ declare function useContributions<TOverlay = KernelOverlay>(opts: UseContributio
  */
 declare function useOffhandAction(entries: readonly Contribution<unknown>[]): void;
 
-export { ActionsProvider, type CommandOptions, type ContributionsApi, DepRegistry, DepRegistryProvider, InputScope, type InputScopeProps, type OngoingAction, PointerContextProvider, type PointerContextValue, type PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type ToolsApi, type UseContributionsOptions, UseGestureDispatcherOptions, type UseToolsOptions, Yoke, type YokeProps, createPointerStore, useAction, useActionsRegistry, useCommand, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOffhandAction, useOngoingAction, useOpenKeymap, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
+export { ActionsProvider, type CommandOptions, type ContributionsApi, DepRegistry, DepRegistryProvider, InputScope, type InputScopeProps, type OngoingAction, PointerContextProvider, type PointerContextValue, type PointerWorldPos, SelectionContextProvider, SelectionContextProviderIfRoot, type SelectionContextValue, type ToolsApi, type UseContributionsOptions, UseGestureDispatcherOptions, type UseToolsOptions, Yoke, type YokeProps, createPointerStore, lastOperationOf, useAction, useActionsRegistry, useCommand, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useLastOperation, useLastOperationStore, useMenuHost, useMenus, useOffhandAction, useOngoingAction, useOpenKeymap, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };

package/dist/react.js

@@ -1,14 +1,14 @@
-import { createKeymapStack, createDispatchTrace, createDispatcher, describeKeymap, assembleEntries, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, reportRouteConflicts, isTool, clientToCanvas, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, carryGestureId, anyBinding, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, immediateParams } from './chunk-HR5F4LBX.js';
-import { useDepRegistry, actionsNodeOf, useAction, useActionsRegistry, useOptionalDepRegistry, ActionsNode, MenuHostContext, DepRegistryContext, ActionsContext } from './chunk-INZ63QGX.js';
-export { ActionsProvider, DepRegistryProvider, useAction, useActionsRegistry, useDepRegistry, useDepSource, useMenuHost, useMenus, useOptionalDepRegistry } from './chunk-INZ63QGX.js';
-import { NO_OVERRIDES, ScopeNode, depNodeOf, DepNode, actionCursor, buildDepsFromRequires } from './chunk-EUCNVGJV.js';
+import { createKeymapStack, createDispatchTrace, createDispatcher, describeKeymap, assembleEntries, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, reportRouteConflicts, isTool, clientToCanvas, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, carryGestureId, anyBinding, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, immediateParams } from './chunk-ZK72IBMI.js';
+import { useDepRegistry, actionsNodeOf, useAction, useActionsRegistry, useOptionalDepRegistry, ActionsNode, MenuHostContext, DepRegistryContext, ActionsContext } from './chunk-3SPPC6UP.js';
+export { ActionsProvider, DepRegistryProvider, useAction, useActionsRegistry, useDepRegistry, useDepSource, useMenuHost, useMenus, useOptionalDepRegistry } from './chunk-3SPPC6UP.js';
+import { NO_OVERRIDES, ScopeNode, depNodeOf, DepNode, actionCursor, buildDepsFromRequires } from './chunk-A6MN3I6R.js';
 import { createContext, useState, useContext, useEffect, useRef, useMemo, useCallback, useSyncExternalStore } from 'react';
 import { isApplePlatform, heldPointers, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
 import { useLatest, useKitSettings, useStableByContent, sameList, isDev } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import { createCursorSink, resolveCursorTier } from '@weasel-js/cursor';
 import { deepEqual, createEmitter } from '@weasel-js/registry';
-import { activeModeOf } from '@weasel-js/modes';
+import { activeModeOf, defaultToolOf } from '@weasel-js/modes';
 
 var ToolNode = class extends ScopeNode {
   state;
@@ -596,6 +596,46 @@ function keymapKeys(stack) {
   };
 }
 
+// src/interactions/dispatcher/channels/overKeys.ts
+var OVER_ONLY = { held: false, over: true };
+function followPointer(core, down, held) {
+  const arrive = (e) => {
+    for (const [physical, { key, code }] of down) {
+      if (held.has(physical)) continue;
+      core.routeAt(null, e.clientX, e.clientY);
+      const on = core.dispatcherNow();
+      const codeField = code !== void 0 ? { code } : {};
+      const ev = {
+        kind: "key-held",
+        key,
+        ...codeField,
+        phase: "down",
+        altKey: e.altKey,
+        ctrlKey: e.ctrlKey,
+        metaKey: e.metaKey,
+        shiftKey: e.shiftKey
+      };
+      if (core.dispatch(ev, on, OVER_ONLY) === "handled") held.set(physical, { key, ...codeField, on });
+    }
+  };
+  const leave = () => {
+    for (const [physical, { key, code, on }] of [...held]) {
+      const ev = {
+        kind: "key-held",
+        key,
+        ...code !== void 0 ? { code } : {},
+        phase: "up",
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false
+      };
+      if (core.dispatch(ev, on, OVER_ONLY) === "handled") held.delete(physical);
+    }
+  };
+  return { arrive, leave };
+}
+
 // src/interactions/dispatcher/channels/keyboard.ts
 function typedWithAltGraph(e) {
   if (!e.ctrlKey || !e.altKey || e.key.length !== 1 || !e.getModifierState?.("AltGraph")) return false;
@@ -613,10 +653,12 @@ var inMenu = (t) => t instanceof Element && t.closest('[role="menu"]') !== null;
 function keyboardInput(core) {
   const { dispatch, dispatcherNow } = core;
   const heldKeys = /* @__PURE__ */ new Map();
+  const downKeys = /* @__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) => {
+    downKeys.set(physicalKey(e), { key: e.key, ...codeOf(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;
@@ -642,6 +684,7 @@ function keyboardInput(core) {
   };
   const onKeyUp = (e) => {
     const physical = physicalKey(e);
+    downKeys.delete(physical);
     keymaps.up(e, physical);
     const down = heldKeys.get(physical);
     if (down === void 0) return;
@@ -659,6 +702,7 @@ function keyboardInput(core) {
     dispatch(ev, down.on);
   };
   const releaseAll = () => {
+    downKeys.clear();
     keymaps.clear();
     const releasing = [...heldKeys.values()];
     heldKeys.clear();
@@ -676,7 +720,7 @@ function keyboardInput(core) {
       dispatch(ev, on);
     }
   };
-  return { onKeyDown, onKeyUp, releaseAll };
+  return { onKeyDown, onKeyUp, releaseAll, ...followPointer(core, downKeys, heldKeys) };
 }
 
 // src/interactions/dispatcher/channels/listeners.ts
@@ -1001,12 +1045,7 @@ function attachInput(canvas, src, channels) {
   listeners.on(canvas, "pointerdown", () => {
     src.actions().activate();
   });
-  const setOver = (on) => () => {
-    core.setPointerOver(on);
-  };
-  listeners.on(canvas, "pointerenter", setOver(true));
-  listeners.on(canvas, "pointermove", setOver(true));
-  listeners.on(canvas, "pointerleave", setOver(false));
+  trackPointerOver(listeners, canvas, core, keys);
   if (channels.pointer) {
     listeners.on(window, "keydown", hover.onKey);
     listeners.on(window, "keyup", hover.onKey);
@@ -1057,6 +1096,19 @@ function attachInput(canvas, src, channels) {
     src.context().keymaps?.closeAll();
   };
 }
+function trackPointerOver(listeners, canvas, core, keys) {
+  const onOver = (e) => {
+    if (core.pointerOver()) return;
+    core.setPointerOver(true);
+    keys.arrive(e);
+  };
+  listeners.on(canvas, "pointerenter", onOver);
+  listeners.on(canvas, "pointermove", onOver);
+  listeners.on(canvas, "pointerleave", () => {
+    core.setPointerOver(false);
+    keys.leave();
+  });
+}
 
 // src/interactions/dispatcher/useGestureDispatcher.tsx
 function useGestureDispatcher(opts) {
@@ -1215,6 +1267,20 @@ function bindingOf(keys) {
   return "spec" in keys ? [keys] : keys;
 }
 var isList = (keys) => Array.isArray(keys);
+var NO_STORE = () => null;
+var NO_SUBSCRIBE2 = () => () => {
+};
+function lastOperationOf(registry) {
+  return actionsNodeOf(registry)?.lastOperation ?? null;
+}
+function useLastOperationStore() {
+  return lastOperationOf(useActionsRegistry());
+}
+function useLastOperation(store) {
+  const inScope = useLastOperationStore();
+  const s = store === void 0 ? inScope : store;
+  return useSyncExternalStore(s?.subscribe ?? NO_SUBSCRIBE2, s?.get ?? NO_STORE, s?.get ?? NO_STORE);
+}
 function useNodes(descends, ownsTool, parent) {
   const parentActions = useActionsRegistry();
   const parentDeps = useOptionalDepRegistry();
@@ -1411,7 +1477,7 @@ function usePublishSelection(ids, kinds) {
     }
   }, [ctxRef, serializedRef]);
 }
-var NO_SUBSCRIBE2 = () => () => {
+var NO_SUBSCRIBE3 = () => () => {
 };
 function useContributions(opts) {
   const ctx = useActiveToolContext();
@@ -1433,7 +1499,7 @@ function useContributions(opts) {
   }, [ctx]);
   const modes = opts.modes;
   const modeVersion = useSyncExternalStore(
-    modes ? modes.subscribe : NO_SUBSCRIBE2,
+    modes ? modes.subscribe : NO_SUBSCRIBE3,
     () => modes?.getVersion() ?? 0
   );
   const openKeymap = useInnermostKeymap()?.id ?? null;
@@ -1505,6 +1571,32 @@ function useOffhandAction(entries) {
     return actionsRegistry.register(makeToolOffhandAction(buildToolOffhandBindings(specs)));
   }, [actionsRegistry, offhandSig]);
 }
+function useModeDefaultTool(modes, tools) {
+  const toolsRef = useLatest(tools);
+  const entered = useRef(null);
+  useEffect(() => {
+    if (!modes) return;
+    const enter = (next, from) => {
+      const target = defaultToolOf(next, toolsRef.current.has);
+      entered.current = { mode: next, restore: target === null ? void 0 : from };
+      const want = target ?? from;
+      if (want !== toolsRef.current.active) toolsRef.current.setActive(want);
+    };
+    const follow = () => {
+      const next = modes.current();
+      const prior = entered.current;
+      if (prior?.mode === next) return;
+      const restore = prior?.restore;
+      const back = restore !== void 0 && (restore === null || toolsRef.current.has(restore));
+      enter(next, back ? restore : toolsRef.current.active);
+    };
+    if (entered.current === null) enter(modes.current(), toolsRef.current.active ?? toolsRef.current.initial);
+    follow();
+    return modes.subscribe(follow);
+  }, [modes, toolsRef]);
+}
+
+// src/tools/useTools.ts
 function declareSlot(tool, slot) {
   const hotkey = tool.def?.hotkey;
   const eligibility = {
@@ -1591,6 +1683,7 @@ function useTools(opts) {
     (id) => id in slotted.registry || slotted.ambient.some((t) => t.id === id),
     [slotted]
   );
+  useModeDefaultTool(opts.modes, { active: contributions.focused, initial: initialActive, setActive, has });
   const active = contributions.focused;
   const getActiveOverlays = contributions.overlays;
   return useMemo(
@@ -1609,6 +1702,6 @@ function useTools(opts) {
   );
 }
 
-export { ActiveToolContextProvider, ActiveToolContextProviderIfRoot, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, useActiveToolContext, useCommand, useContributions, useGestureDispatcher, useOffhandAction, useOngoingAction, useOpenKeymap, useOptionalActiveToolContext, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
+export { ActiveToolContextProvider, ActiveToolContextProviderIfRoot, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, lastOperationOf, useActiveToolContext, useCommand, useContributions, useGestureDispatcher, useLastOperation, useLastOperationStore, useOffhandAction, useOngoingAction, useOpenKeymap, useOptionalActiveToolContext, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map