@opentui/keymap 0.2.1 → 0.2.3

package/src/keymap.d.ts

@@ -1,58 +1,50 @@
-import type { ActiveKey, ActiveKeyOptions, BindingInput, BindingExpander, BindingParser, BindingFieldCompiler, Bindings, BindingTransformer, Events, CommandFieldCompiler, CommandEntry, CommandQuery, CommandRecord, KeymapEvent, KeymapHost, LayerAnalyzer, Listener, RunCommandOptions, RunCommandResult, CommandResolver, KeyInterceptOptions, KeyInputContext, Layer, LayerFieldCompiler, KeyDisambiguationResolver, RawInterceptOptions, RawInputContext, EventMatchResolver, KeyStringifyInput, KeyToken, KeyLike, KeySequencePart } from "./types.js";
+import type { ActiveBinding, ActiveKey, ActiveKeyOptions, BindingExpander, BindingParser, BindingFieldCompiler, LayerBindingsTransformer, BindingTransformer, Events, CommandFieldCompiler, CommandTransformer, CommandBindingsQuery, CommandEntry, CommandQuery, Command, KeymapEvent, KeymapHost, HostMetadata, LayerAnalyzer, Listener, RunCommandOptions, RunCommandResult, CommandResolver, KeyAfterInputContext, KeyInterceptOptions, KeyInputContext, Layer, LayerFieldCompiler, KeyDisambiguationResolver, RawInterceptOptions, RawInputContext, EventMatchResolver, KeyStringifyInput, KeyToken, SequencePattern, KeyLike, KeySequencePart, StringifyOptions } from "./types.js";
+import { KEYMAP_EXTENSION_CONTEXT, type KeymapExtensionContext } from "./services/extension-context.js";
 export declare class Keymap<TTarget extends object, TEvent extends KeymapEvent = KeymapEvent> {
-    private readonly host;
-    private readonly state;
-    private cleanedUp;
-    private readonly resources;
-    private readonly cleanupListeners;
-    private events;
-    private hooks;
-    private readonly notify;
-    private readonly activation;
-    private readonly runtime;
-    private readonly conditions;
-    private readonly catalog;
-    private readonly executor;
-    private readonly compiler;
-    private readonly dispatch;
-    private readonly layers;
-    private readonly environment;
-    private readonly keypressListener;
-    private readonly keyreleaseListener;
-    private readonly rawListener;
-    private readonly focusedTargetListener;
+    #private;
+    getPendingSequence: () => readonly KeySequencePart[];
+    getActiveKeys: (options?: ActiveKeyOptions) => readonly ActiveKey<TTarget, TEvent>[];
     constructor(host: KeymapHost<TTarget, TEvent>);
-    private cleanup;
+    [KEYMAP_EXTENSION_CONTEXT](): KeymapExtensionContext<TTarget, TEvent>;
     setData(name: string, value: unknown): void;
     getData(name: string): unknown;
+    getHostMetadata(): Readonly<HostMetadata>;
     hasPendingSequence(): boolean;
-    getPendingSequence(): readonly KeySequencePart[];
     createKeyMatcher(key: KeyLike): (input: KeyStringifyInput | null | undefined) => boolean;
+    parseKeySequence(key: KeyLike): readonly KeySequencePart[];
+    formatKey(key: KeyLike, options?: StringifyOptions): string;
     clearPendingSequence(): void;
     popPendingSequence(): boolean;
-    getActiveKeys(options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
-    getCommands(query?: CommandQuery<TTarget>): readonly CommandRecord[];
-    getCommandEntries(query?: CommandQuery<TTarget>): readonly CommandEntry<TTarget, TEvent>[];
-    normalizeCommandName(name: string): string;
-    normalizeBindings(bindings: Bindings<TTarget, TEvent>): BindingInput<TTarget, TEvent>[];
+    getCommands(query?: CommandQuery<TTarget, TEvent>): readonly Command<TTarget, TEvent>[];
+    getCommandEntries(query?: CommandQuery<TTarget, TEvent>): readonly CommandEntry<TTarget, TEvent>[];
+    getCommandBindings(query: CommandBindingsQuery<TTarget>): ReadonlyMap<string, readonly ActiveBinding<TTarget, TEvent>[]>;
     acquireResource(key: symbol, setup: () => () => void): () => void;
-    runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult;
-    dispatchCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult;
+    runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>;
+    dispatchCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>;
     on(name: "state", fn: Listener<Events<TTarget, TEvent>["state"]>): () => void;
     on(name: "pendingSequence", fn: Listener<Events<TTarget, TEvent>["pendingSequence"]>): () => void;
+    on(name: "dispatch", fn: Listener<Events<TTarget, TEvent>["dispatch"]>): () => void;
     on(name: "warning", fn: Listener<Events<TTarget, TEvent>["warning"]>): () => void;
     on(name: "error", fn: Listener<Events<TTarget, TEvent>["error"]>): () => void;
     intercept(name: "key", fn: (ctx: KeyInputContext<TEvent>) => void, options?: KeyInterceptOptions): () => void;
+    intercept(name: "key:after", fn: (ctx: KeyAfterInputContext<TTarget, TEvent>) => void, options?: KeyInterceptOptions): () => void;
     intercept(name: "raw", fn: (ctx: RawInputContext) => void, options?: RawInterceptOptions): () => void;
     registerLayer(layer: Layer<TTarget, TEvent>): () => void;
     registerLayerFields(fields: Record<string, LayerFieldCompiler>): () => void;
+    prependLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void;
+    appendLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void;
+    clearLayerBindingsTransformers(): void;
     prependBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
     appendBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void;
     clearBindingTransformers(): void;
+    prependCommandTransformer(transformer: CommandTransformer<TTarget, TEvent>): () => void;
+    appendCommandTransformer(transformer: CommandTransformer<TTarget, TEvent>): () => void;
+    clearCommandTransformers(): void;
     prependBindingParser(parser: BindingParser): () => void;
     appendBindingParser(parser: BindingParser): () => void;
     clearBindingParsers(): void;
     registerToken(token: KeyToken): () => void;
+    registerSequencePattern(pattern: SequencePattern<TEvent>): () => void;
     prependBindingExpander(expander: BindingExpander): () => void;
     appendBindingExpander(expander: BindingExpander): () => void;
     clearBindingExpanders(): void;
@@ -70,8 +62,4 @@ export declare class Keymap<TTarget extends object, TEvent extends KeymapEvent =
     prependDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void;
     appendDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void;
     clearDisambiguationResolvers(): void;
-    private handleFocusedTargetChange;
-    private warnUnknownField;
-    private warnUnknownToken;
-    private releaseResource;
 }

package/src/lib/emitter.d.ts

@@ -1,8 +1,7 @@
 export type EmitterListener<TValue> = [TValue] extends [void] ? () => void : (value: TValue) => void;
 type EmitterArgs<TValue> = [TValue] extends [void] ? [] : [TValue];
 export declare class Emitter<TEvents extends Record<string, unknown>> {
-    private readonly onError;
-    private listeners;
+    #private;
     constructor(onError: (name: keyof TEvents, error: unknown) => void);
     hook<TName extends keyof TEvents>(name: TName, listener: EmitterListener<TEvents[TName]>): () => void;
     has<TName extends keyof TEvents>(name: TName): boolean;

package/src/lib/registry.d.ts

@@ -5,7 +5,7 @@ export type PriorityRegistration<TListener, TOptions extends {
     order: number;
 }>;
 declare abstract class CopyOnWriteRegistry<TValue> {
-    private items;
+    #private;
     protected getItems(): readonly TValue[];
     protected setItems(items: readonly TValue[]): void;
     protected removeItem(value: TValue): boolean;
@@ -21,7 +21,7 @@ export declare class OrderedRegistry<TValue> extends CopyOnWriteRegistry<TValue>
 export declare class PriorityRegistry<TListener, TOptions extends {
     priority: number;
 }> extends CopyOnWriteRegistry<PriorityRegistration<TListener, TOptions>> {
-    private order;
+    #private;
     register(listener: TListener, options: TOptions): () => void;
     entries(): readonly PriorityRegistration<TListener, TOptions>[];
 }

package/src/lib/runtime-utils.d.ts

@@ -0,0 +1,34 @@
+export type RuntimeEmitterListener<TValue> = [TValue] extends [void] ? () => void : (value: TValue) => void;
+type RuntimeEmitterArgs<TValue> = [TValue] extends [void] ? [] : [TValue];
+export interface RuntimeEmitter<TEvents extends Record<string, unknown>> {
+    hook<TName extends keyof TEvents>(name: TName, listener: RuntimeEmitterListener<TEvents[TName]>): () => void;
+    has<TName extends keyof TEvents>(name: TName): boolean;
+    emit<TName extends keyof TEvents>(name: TName, ...args: RuntimeEmitterArgs<TEvents[TName]>): void;
+}
+export declare function createRuntimeEmitter<TEvents extends Record<string, unknown>>(onError: (name: keyof TEvents, error: unknown) => void): RuntimeEmitter<TEvents>;
+export type RuntimePriorityRegistration<TListener, TOptions extends {
+    priority: number;
+}> = Readonly<TOptions & {
+    listener: TListener;
+    order: number;
+}>;
+export interface RuntimeOrderedRegistry<TValue> {
+    append(value: TValue): () => void;
+    prepend(value: TValue): () => void;
+    values(): readonly TValue[];
+    has(): boolean;
+    clear(): void;
+}
+export interface RuntimePriorityRegistry<TListener, TOptions extends {
+    priority: number;
+}> {
+    register(listener: TListener, options: TOptions): () => void;
+    entries(): readonly RuntimePriorityRegistration<TListener, TOptions>[];
+    has(): boolean;
+    clear(): void;
+}
+export declare function createRuntimeOrderedRegistry<TValue>(): RuntimeOrderedRegistry<TValue>;
+export declare function createRuntimePriorityRegistry<TListener, TOptions extends {
+    priority: number;
+}>(): RuntimePriorityRegistry<TListener, TOptions>;
+export {};

package/src/opentui.d.ts

@@ -1,7 +1,5 @@
 import { KeyEvent, type CliRenderer, type Renderable } from "@opentui/core";
-import { Keymap } from "./keymap.js";
-import type { KeymapHost } from "./types.js";
-export * from "./index.js";
+import { Keymap, type KeymapHost } from "@opentui/keymap";
 export declare function createOpenTuiKeymapHost(renderer: CliRenderer): KeymapHost<Renderable, KeyEvent>;
 export declare function createOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent>;
 export declare function createDefaultOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent>;

package/src/opentui.js

@@ -0,0 +1,133 @@
+// @bun
+// src/opentui.ts
+import { CliRenderEvents, KeyEvent, RenderableEvents } from "@opentui/core";
+import { Keymap } from "@opentui/keymap";
+import { registerDefaultKeys, registerEnabledFields, registerMetadataFields } from "@opentui/keymap/addons";
+function createSyntheticCommandEvent() {
+  return new KeyEvent({
+    name: "command",
+    ctrl: false,
+    meta: false,
+    shift: false,
+    option: false,
+    sequence: "",
+    number: false,
+    raw: "",
+    eventType: "press",
+    source: "raw"
+  });
+}
+function normalizeRuntimePlatform(platform) {
+  if (platform === "darwin") {
+    return "macos";
+  }
+  if (platform === "win32") {
+    return "windows";
+  }
+  if (platform === "linux") {
+    return "linux";
+  }
+  return "unknown";
+}
+function createOpenTuiHostMetadata(renderer) {
+  const platform = normalizeRuntimePlatform(process.platform);
+  const hasKittyKeyboard = renderer.capabilities?.kitty_keyboard === true;
+  return {
+    platform,
+    primaryModifier: platform === "macos" ? "super" : platform === "unknown" ? "unknown" : "ctrl",
+    modifiers: {
+      ctrl: "supported",
+      shift: "supported",
+      meta: "supported",
+      super: hasKittyKeyboard ? "supported" : "unknown",
+      hyper: hasKittyKeyboard ? "supported" : "unknown"
+    }
+  };
+}
+function createOpenTuiKeymapHost(renderer) {
+  return {
+    get metadata() {
+      return createOpenTuiHostMetadata(renderer);
+    },
+    rootTarget: renderer.root,
+    get isDestroyed() {
+      return renderer.isDestroyed;
+    },
+    getFocusedTarget() {
+      const focused = renderer.currentFocusedRenderable;
+      if (!focused || focused.isDestroyed || !focused.focused) {
+        return null;
+      }
+      return focused;
+    },
+    getParentTarget(target) {
+      return target.parent;
+    },
+    isTargetDestroyed(target) {
+      return target.isDestroyed;
+    },
+    onKeyPress(listener) {
+      renderer.keyInput.prependListener("keypress", listener);
+      return () => {
+        renderer.keyInput.off("keypress", listener);
+      };
+    },
+    onKeyRelease(listener) {
+      renderer.keyInput.prependListener("keyrelease", listener);
+      return () => {
+        renderer.keyInput.off("keyrelease", listener);
+      };
+    },
+    onFocusChange(listener) {
+      renderer.on(CliRenderEvents.FOCUSED_RENDERABLE, listener);
+      return () => {
+        renderer.off(CliRenderEvents.FOCUSED_RENDERABLE, listener);
+      };
+    },
+    onDestroy(listener) {
+      renderer.once(CliRenderEvents.DESTROY, listener);
+      return () => {
+        renderer.off(CliRenderEvents.DESTROY, listener);
+      };
+    },
+    onTargetDestroy(target, listener) {
+      target.once(RenderableEvents.DESTROYED, listener);
+      return () => {
+        target.off(RenderableEvents.DESTROYED, listener);
+      };
+    },
+    onRawInput(listener) {
+      renderer.prependInputHandler(listener);
+      return () => {
+        renderer.removeInputHandler(listener);
+      };
+    },
+    createCommandEvent() {
+      return createSyntheticCommandEvent();
+    }
+  };
+}
+function createOpenTuiKeymap(renderer) {
+  if (renderer.isDestroyed) {
+    throw new Error("Cannot create a keymap for a destroyed renderer");
+  }
+  return new Keymap(createOpenTuiKeymapHost(renderer));
+}
+function createDefaultOpenTuiKeymap(renderer) {
+  if (renderer.isDestroyed) {
+    throw new Error("Cannot create a keymap for a destroyed renderer");
+  }
+  const keymap = new Keymap(createOpenTuiKeymapHost(renderer));
+  registerDefaultKeys(keymap);
+  registerEnabledFields(keymap);
+  registerMetadataFields(keymap);
+  return keymap;
+}
+export {
+  createOpenTuiKeymapHost,
+  createOpenTuiKeymap,
+  createDefaultOpenTuiKeymap
+};
+
+//# debugId=7616A56E1652597164756E2164756E21
+//# sourceMappingURL=opentui.js.map

package/src/opentui.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/opentui.ts"],
+  "sourcesContent": [
+    "import { CliRenderEvents, KeyEvent, RenderableEvents, type CliRenderer, type Renderable } from \"@opentui/core\"\nimport { Keymap, type HostMetadata, type HostPlatform, type KeymapHost } from \"@opentui/keymap\"\nimport { registerDefaultKeys, registerEnabledFields, registerMetadataFields } from \"@opentui/keymap/addons\"\n\nfunction createSyntheticCommandEvent(): KeyEvent {\n  return new KeyEvent({\n    name: \"command\",\n    ctrl: false,\n    meta: false,\n    shift: false,\n    option: false,\n    sequence: \"\",\n    number: false,\n    raw: \"\",\n    eventType: \"press\",\n    source: \"raw\",\n  })\n}\n\nfunction normalizeRuntimePlatform(platform: NodeJS.Platform | string | undefined): HostPlatform {\n  if (platform === \"darwin\") {\n    return \"macos\"\n  }\n\n  if (platform === \"win32\") {\n    return \"windows\"\n  }\n\n  if (platform === \"linux\") {\n    return \"linux\"\n  }\n\n  return \"unknown\"\n}\n\nfunction createOpenTuiHostMetadata(renderer: CliRenderer): HostMetadata {\n  const platform = normalizeRuntimePlatform(process.platform)\n  const hasKittyKeyboard = renderer.capabilities?.kitty_keyboard === true\n\n  return {\n    platform,\n    primaryModifier: platform === \"macos\" ? \"super\" : platform === \"unknown\" ? \"unknown\" : \"ctrl\",\n    modifiers: {\n      ctrl: \"supported\",\n      shift: \"supported\",\n      meta: \"supported\",\n      super: hasKittyKeyboard ? \"supported\" : \"unknown\",\n      hyper: hasKittyKeyboard ? \"supported\" : \"unknown\",\n    },\n  }\n}\n\nexport function createOpenTuiKeymapHost(renderer: CliRenderer): KeymapHost<Renderable, KeyEvent> {\n  return {\n    get metadata() {\n      return createOpenTuiHostMetadata(renderer)\n    },\n    rootTarget: renderer.root,\n    get isDestroyed() {\n      return renderer.isDestroyed\n    },\n    getFocusedTarget() {\n      const focused = renderer.currentFocusedRenderable\n      if (!focused || focused.isDestroyed || !focused.focused) {\n        return null\n      }\n\n      return focused\n    },\n    getParentTarget(target) {\n      return target.parent\n    },\n    isTargetDestroyed(target) {\n      return target.isDestroyed\n    },\n    onKeyPress(listener) {\n      renderer.keyInput.prependListener(\"keypress\", listener)\n      return () => {\n        renderer.keyInput.off(\"keypress\", listener)\n      }\n    },\n    onKeyRelease(listener) {\n      renderer.keyInput.prependListener(\"keyrelease\", listener)\n      return () => {\n        renderer.keyInput.off(\"keyrelease\", listener)\n      }\n    },\n    onFocusChange(listener) {\n      renderer.on(CliRenderEvents.FOCUSED_RENDERABLE, listener)\n      return () => {\n        renderer.off(CliRenderEvents.FOCUSED_RENDERABLE, listener)\n      }\n    },\n    onDestroy(listener) {\n      renderer.once(CliRenderEvents.DESTROY, listener)\n      return () => {\n        renderer.off(CliRenderEvents.DESTROY, listener)\n      }\n    },\n    onTargetDestroy(target, listener) {\n      target.once(RenderableEvents.DESTROYED, listener)\n      return () => {\n        target.off(RenderableEvents.DESTROYED, listener)\n      }\n    },\n    onRawInput(listener) {\n      renderer.prependInputHandler(listener)\n      return () => {\n        renderer.removeInputHandler(listener)\n      }\n    },\n    createCommandEvent() {\n      return createSyntheticCommandEvent()\n    },\n  }\n}\n\nexport function createOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent> {\n  if (renderer.isDestroyed) {\n    throw new Error(\"Cannot create a keymap for a destroyed renderer\")\n  }\n\n  return new Keymap(createOpenTuiKeymapHost(renderer))\n}\n\nexport function createDefaultOpenTuiKeymap(renderer: CliRenderer): Keymap<Renderable, KeyEvent> {\n  if (renderer.isDestroyed) {\n    throw new Error(\"Cannot create a keymap for a destroyed renderer\")\n  }\n\n  const keymap = new Keymap(createOpenTuiKeymapHost(renderer))\n  registerDefaultKeys(keymap)\n  registerEnabledFields(keymap)\n  registerMetadataFields(keymap)\n  return keymap\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "7616A56E1652597164756E2164756E21",
+  "names": []
+}

package/src/react/index.d.ts

@@ -1,5 +1,5 @@
 import type { KeyEvent, Renderable } from "@opentui/core";
-import { type ActiveKey, type ActiveKeyOptions, type LayerFields, type Keymap, type ReactiveMatcher, type KeySequencePart } from "../index.js";
+import { type ActiveKey, type ActiveKeyOptions, type Layer, type Keymap, type ReactiveMatcher, type KeySequencePart, type TargetMode } from "../index.js";
 import { type DependencyList, type ReactNode } from "react";
 type OpenTuiKeymap = Keymap<Renderable, KeyEvent>;
 export interface KeymapProviderProps {
@@ -10,28 +10,14 @@ export declare function KeymapProvider({ keymap, children }: KeymapProviderProps
 export interface UseBindingsTargetRef<TRenderable extends Renderable = Renderable> {
     current: TRenderable | null;
 }
-type UseBindingsLayerBase = LayerFields<Renderable, KeyEvent>;
-export interface UseGlobalBindingsLayer extends UseBindingsLayerBase {
-    targetRef?: undefined;
+export interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<Layer<Renderable, KeyEvent>, "target" | "targetMode"> {
+    targetRef?: UseBindingsTargetRef<TRenderable>;
+    targetMode?: TargetMode;
 }
-export interface UseFocusBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode: "focus";
-    targetRef: UseBindingsTargetRef<TRenderable>;
-}
-export interface UseFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode?: "focus-within";
-    targetRef: UseBindingsTargetRef<TRenderable>;
-}
-export interface UseInferredFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetRef: UseBindingsTargetRef<TRenderable>;
-}
-export type UseTargetBindingsLayer<TRenderable extends Renderable = Renderable> = UseFocusBindingsLayer<TRenderable> | UseFocusWithinBindingsLayer<TRenderable> | UseInferredFocusWithinBindingsLayer<TRenderable>;
-export type UseBindingsLayer<TRenderable extends Renderable = Renderable> = UseGlobalBindingsLayer | UseTargetBindingsLayer<TRenderable>;
 export declare const useKeymap: () => OpenTuiKeymap;
 export declare const useActiveKeys: (options?: ActiveKeyOptions) => readonly ActiveKey[];
 export declare const usePendingSequence: () => readonly KeySequencePart[];
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseGlobalBindingsLayer, deps?: DependencyList): void;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseTargetBindingsLayer<TRenderable>, deps?: DependencyList): void;
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseBindingsLayer<TRenderable>, deps?: DependencyList): void;
 /**
  * Adapts any `subscribe` + `getSnapshot` store to
  * `ReactiveMatcher`. Pass `predicate` when the snapshot value is not

package/{react → src/react}/index.js

@@ -122,3 +122,6 @@ export {
   reactiveMatcherFromStore,
   KeymapProvider
 };
+
+//# debugId=88193D455507349A64756E2164756E21
+//# sourceMappingURL=index.js.map

package/src/react/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/react/index.ts"],
+  "sourcesContent": [
+    "import type { KeyEvent, Renderable } from \"@opentui/core\"\nimport {\n  type ActiveKey,\n  type ActiveKeyOptions,\n  type Layer,\n  type Keymap,\n  type ReactiveMatcher,\n  type KeySequencePart,\n  type TargetMode,\n} from \"../index.js\"\nimport {\n  createElement,\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useReducer,\n  useRef,\n  type DependencyList,\n  type ReactNode,\n} from \"react\"\n\ntype OpenTuiKeymap = Keymap<Renderable, KeyEvent>\n\nconst KeymapContext = createContext<OpenTuiKeymap | null>(null)\n\nexport interface KeymapProviderProps {\n  keymap: OpenTuiKeymap\n  children?: ReactNode\n}\n\nexport function KeymapProvider({ keymap, children }: KeymapProviderProps) {\n  return createElement(KeymapContext.Provider, { value: keymap }, children)\n}\n\nexport interface UseBindingsTargetRef<TRenderable extends Renderable = Renderable> {\n  current: TRenderable | null\n}\n\nexport interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<\n  Layer<Renderable, KeyEvent>,\n  \"target\" | \"targetMode\"\n> {\n  targetRef?: UseBindingsTargetRef<TRenderable>\n  targetMode?: TargetMode\n}\n\nfunction resolveBindingsTarget(targetRef: UseBindingsTargetRef | undefined): Renderable | undefined {\n  return targetRef?.current ?? undefined\n}\n\nexport const useKeymap = (): OpenTuiKeymap => {\n  const keymap = useContext(KeymapContext)\n\n  if (!keymap) {\n    throw new Error(\"Keymap not found. Wrap the tree in <KeymapProvider>.\")\n  }\n\n  return keymap\n}\n\n// Use the batched `state` event for derived reads. Pending-sequence changes\n// already flow through `state`, so subscribing to both would duplicate work.\nfunction useKeymapStateVersion(keymap: OpenTuiKeymap): number {\n  const [version, bumpVersion] = useReducer((value: number) => value + 1, 0)\n\n  useLayoutEffect(() => {\n    const dispose = keymap.on(\"state\", () => {\n      bumpVersion()\n    })\n\n    return () => {\n      dispose()\n    }\n  }, [keymap])\n\n  return version\n}\n\nexport const useActiveKeys = (options?: ActiveKeyOptions): readonly ActiveKey[] => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return useMemo(() => {\n    void version\n    return keymap.getActiveKeys(options)\n  }, [keymap, options, version])\n}\n\nexport const usePendingSequence = (): readonly KeySequencePart[] => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return useMemo(() => {\n    void version\n    return keymap.getPendingSequence()\n  }, [keymap, version])\n}\n\nexport function useBindings<TRenderable extends Renderable = Renderable>(\n  createLayer: () => UseBindingsLayer<TRenderable>,\n  deps: DependencyList = [],\n): void {\n  const keymap = useKeymap()\n  const layer = useMemo(createLayer, deps)\n  const layerRef = useRef(layer)\n  const disposeRef = useRef<(() => void) | undefined>(undefined)\n  const registeredLayerRef = useRef<UseBindingsLayer<TRenderable> | undefined>(undefined)\n  const registeredTargetModeRef = useRef<TargetMode | undefined>(undefined)\n  const registeredTargetRef = useRef<Renderable | undefined>(undefined)\n\n  layerRef.current = layer\n\n  const unregister = useCallback(() => {\n    disposeRef.current?.()\n    disposeRef.current = undefined\n    registeredLayerRef.current = undefined\n    registeredTargetModeRef.current = undefined\n    registeredTargetRef.current = undefined\n  }, [])\n\n  useEffect(() => {\n    const currentLayer = layerRef.current\n    const hasExplicitTarget = currentLayer.targetRef !== undefined\n    const explicitTarget = resolveBindingsTarget(currentLayer.targetRef)\n    const nextTargetMode = currentLayer.targetMode ?? (hasExplicitTarget ? \"focus-within\" : undefined)\n    const nextTarget = nextTargetMode ? explicitTarget : undefined\n\n    if (!hasExplicitTarget && nextTargetMode) {\n      throw new Error(\"useBindings local bindings need a targetRef\")\n    }\n\n    if (\n      registeredLayerRef.current === currentLayer &&\n      registeredTargetModeRef.current === nextTargetMode &&\n      registeredTargetRef.current === nextTarget\n    ) {\n      return\n    }\n\n    unregister()\n\n    if (!nextTarget && nextTargetMode) {\n      registeredLayerRef.current = currentLayer\n      registeredTargetModeRef.current = nextTargetMode\n      registeredTargetRef.current = undefined\n      return\n    }\n\n    const { targetRef: _targetRef, targetMode: _targetMode, ...baseLayer } = currentLayer\n    disposeRef.current = keymap.registerLayer(\n      !nextTargetMode\n        ? {\n            ...baseLayer,\n          }\n        : {\n            ...baseLayer,\n            target: nextTarget!,\n            targetMode: nextTargetMode,\n          },\n    )\n    registeredLayerRef.current = currentLayer\n    registeredTargetModeRef.current = nextTargetMode\n    registeredTargetRef.current = nextTarget\n  })\n\n  useEffect(() => {\n    return () => {\n      unregister()\n    }\n  }, [unregister])\n}\n\n/**\n * Adapts any `subscribe` + `getSnapshot` store to\n * `ReactiveMatcher`. Pass `predicate` when the snapshot value is not\n * already boolean.\n */\nexport function reactiveMatcherFromStore<T>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => T,\n  predicate?: (value: T) => boolean,\n): ReactiveMatcher {\n  return {\n    get() {\n      return predicate ? predicate(getSnapshot()) : Boolean(getSnapshot())\n    },\n    subscribe(onChange) {\n      return subscribe(onChange)\n    },\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "88193D455507349A64756E2164756E21",
+  "names": []
+}

package/src/runtime-modules.d.ts

@@ -0,0 +1,20 @@
+import * as keymap from "@opentui/keymap";
+import * as keymapExtras from "@opentui/keymap/extras";
+import * as keymapGraphExtra from "@opentui/keymap/extras/graph";
+import * as keymapAddons from "@opentui/keymap/addons";
+import * as keymapOpenTuiAddons from "@opentui/keymap/addons/opentui";
+import * as keymapHtml from "@opentui/keymap/html";
+import * as keymapOpenTui from "@opentui/keymap/opentui";
+import * as keymapReact from "@opentui/keymap/react";
+import * as keymapSolid from "@opentui/keymap/solid";
+export declare const runtimeModules: {
+    "@opentui/keymap": typeof keymap;
+    "@opentui/keymap/extras": typeof keymapExtras;
+    "@opentui/keymap/extras/graph": typeof keymapGraphExtra;
+    "@opentui/keymap/addons": typeof keymapAddons;
+    "@opentui/keymap/addons/opentui": typeof keymapOpenTuiAddons;
+    "@opentui/keymap/html": typeof keymapHtml;
+    "@opentui/keymap/opentui": typeof keymapOpenTui;
+    "@opentui/keymap/react": typeof keymapReact;
+    "@opentui/keymap/solid": typeof keymapSolid;
+};

package/src/runtime-modules.js

@@ -0,0 +1,28 @@
+// @bun
+// src/runtime-modules.ts
+import * as keymap from "@opentui/keymap";
+import * as keymapExtras from "@opentui/keymap/extras";
+import * as keymapGraphExtra from "@opentui/keymap/extras/graph";
+import * as keymapAddons from "@opentui/keymap/addons";
+import * as keymapOpenTuiAddons from "@opentui/keymap/addons/opentui";
+import * as keymapHtml from "@opentui/keymap/html";
+import * as keymapOpenTui from "@opentui/keymap/opentui";
+import * as keymapReact from "@opentui/keymap/react";
+import * as keymapSolid from "@opentui/keymap/solid";
+var runtimeModules = {
+  "@opentui/keymap": keymap,
+  "@opentui/keymap/extras": keymapExtras,
+  "@opentui/keymap/extras/graph": keymapGraphExtra,
+  "@opentui/keymap/addons": keymapAddons,
+  "@opentui/keymap/addons/opentui": keymapOpenTuiAddons,
+  "@opentui/keymap/html": keymapHtml,
+  "@opentui/keymap/opentui": keymapOpenTui,
+  "@opentui/keymap/react": keymapReact,
+  "@opentui/keymap/solid": keymapSolid
+};
+export {
+  runtimeModules
+};
+
+//# debugId=0BF94D448A4CF4C764756E2164756E21
+//# sourceMappingURL=runtime-modules.js.map

package/src/runtime-modules.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/runtime-modules.ts"],
+  "sourcesContent": [
+    "import type { RuntimeModuleEntry } from \"@opentui/core/runtime-plugin\"\nimport * as keymap from \"@opentui/keymap\"\nimport * as keymapExtras from \"@opentui/keymap/extras\"\nimport * as keymapGraphExtra from \"@opentui/keymap/extras/graph\"\nimport * as keymapAddons from \"@opentui/keymap/addons\"\nimport * as keymapOpenTuiAddons from \"@opentui/keymap/addons/opentui\"\nimport * as keymapHtml from \"@opentui/keymap/html\"\nimport * as keymapOpenTui from \"@opentui/keymap/opentui\"\nimport * as keymapReact from \"@opentui/keymap/react\"\nimport * as keymapSolid from \"@opentui/keymap/solid\"\n\nexport const runtimeModules = {\n  \"@opentui/keymap\": keymap,\n  \"@opentui/keymap/extras\": keymapExtras,\n  \"@opentui/keymap/extras/graph\": keymapGraphExtra,\n  \"@opentui/keymap/addons\": keymapAddons,\n  \"@opentui/keymap/addons/opentui\": keymapOpenTuiAddons,\n  \"@opentui/keymap/html\": keymapHtml,\n  \"@opentui/keymap/opentui\": keymapOpenTui,\n  \"@opentui/keymap/react\": keymapReact,\n  \"@opentui/keymap/solid\": keymapSolid,\n} satisfies Record<string, RuntimeModuleEntry>\n"
+  ],
+  "mappings": ";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,IAAM,iBAAiB;AAAA,EAC5B,mBAAmB;AAAA,EACnB,0BAA0B;AAAA,EAC1B,gCAAgC;AAAA,EAChC,0BAA0B;AAAA,EAC1B,kCAAkC;AAAA,EAClC,wBAAwB;AAAA,EACxB,2BAA2B;AAAA,EAC3B,yBAAyB;AAAA,EACzB,yBAAyB;AAC3B;",
+  "debugId": "0BF94D448A4CF4C764756E2164756E21",
+  "names": []
+}

package/src/services/activation.d.ts

@@ -1,5 +1,5 @@
-import type { Emitter } from "../lib/emitter.js";
-import type { ActiveBinding, ActiveKey, ActiveKeyOptions, CompiledBinding, Hooks, KeymapEvent, KeymapHost, PendingSequenceCapture, KeySequencePart, PendingSequenceState, RegisteredLayer, SequenceNode } from "../types.js";
+import type { RuntimeEmitter } from "../lib/runtime-utils.js";
+import type { ActiveBinding, ActiveKey, ActiveKeyOptions, BindingState, Hooks, KeymapEvent, KeymapHost, PendingSequenceCapture, KeySequencePart, PendingSequenceState, RegisteredLayer } from "../types.js";
 import type { CommandCatalogService } from "./command-catalog.js";
 import type { ConditionService } from "./conditions.js";
 import type { NotificationService } from "./notify.js";
@@ -7,15 +7,7 @@ import type { ActiveCommandView, State } from "./state.js";
 interface ActivationOptions<TTarget extends object, TEvent extends KeymapEvent> {
     onPendingSequenceChanged?: (previous: PendingSequenceState<TTarget, TEvent> | null, next: PendingSequenceState<TTarget, TEvent> | null) => void;
 }
-export declare class ActivationService<TTarget extends object, TEvent extends KeymapEvent> {
-    private readonly state;
-    private readonly host;
-    private readonly hooks;
-    private readonly notify;
-    private readonly conditions;
-    private readonly catalog;
-    private readonly options;
-    constructor(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, hooks: Emitter<Hooks<TTarget, TEvent>>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>, options?: ActivationOptions<TTarget, TEvent>);
+export interface ActivationService<TTarget extends object, TEvent extends KeymapEvent> {
     getFocusedTarget(): TTarget | null;
     getFocusedTargetIfAvailable(): TTarget | null;
     setPendingSequence(next: PendingSequenceState<TTarget, TEvent> | null): void;
@@ -26,30 +18,12 @@ export declare class ActivationService<TTarget extends object, TEvent extends Ke
     popPendingSequence(): boolean;
     getActiveKeys(options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
     getActiveKeysForCaptures(captures: readonly PendingSequenceCapture<TTarget, TEvent>[], options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
-    nodeHasReachableBindings(node: SequenceNode<TTarget, TEvent>, focused: TTarget | null): boolean;
+    getActiveKeysForFocused(focused: TTarget | null, options?: ActiveKeyOptions): readonly ActiveKey<TTarget, TEvent>[];
     getActiveLayers(focused: TTarget | null): RegisteredLayer<TTarget, TEvent>[];
-    refreshActiveLayers(focused?: TTarget | null): void;
-    invalidateActiveLayers(): void;
     isLayerActiveForFocused(layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null): boolean;
-    layerCanCacheActiveKeys(layer: RegisteredLayer<TTarget, TEvent>): boolean;
-    activeLayersCanCacheActiveKeys(activeLayers: readonly RegisteredLayer<TTarget, TEvent>[]): boolean;
-    private collectNodesFromNode;
     collectSequencePartsFromPending(pending: PendingSequenceState<TTarget, TEvent>): KeySequencePart[];
-    collectMatchingBindings(bindings: readonly CompiledBinding<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): CompiledBinding<TTarget, TEvent>[];
-    private hasMatchingBindings;
-    private getNodePresentation;
-    private toActiveBinding;
-    collectActiveBindings(bindings: readonly CompiledBinding<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): ActiveBinding<TTarget, TEvent>[];
-    private collectActiveKeysAtRoot;
-    private collectActiveKeysFromPending;
-    private selectActiveKey;
-    private selectPrefixActiveKey;
-    private selectExactActiveKey;
-    private selectActiveBindings;
-    private createActiveKeyState;
-    private updateActiveKeyState;
-    private materializeActiveKey;
-    private invalidateCaches;
-    private notifyPendingSequenceChange;
+    collectMatchingBindings(bindings: readonly BindingState<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): BindingState<TTarget, TEvent>[];
+    collectActiveBindings(bindings: readonly BindingState<TTarget, TEvent>[], focused: TTarget | null, activeView: ActiveCommandView<TTarget, TEvent>): ActiveBinding<TTarget, TEvent>[];
 }
+export declare function createActivationService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, hooks: RuntimeEmitter<Hooks<TTarget, TEvent>>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, catalog: CommandCatalogService<TTarget, TEvent>, options?: ActivationOptions<TTarget, TEvent>): ActivationService<TTarget, TEvent>;
 export {};

package/src/services/active-key-cache.d.ts

@@ -0,0 +1,29 @@
+import type { ActiveKey, ActiveKeyOptions, KeymapEvent } from "../types.js";
+export interface ActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent> {
+    version: number;
+    notifyVersion: number;
+    focused: TTarget | null | undefined;
+    value: readonly ActiveKey<TTarget, TEvent>[];
+    targets: WeakMap<TTarget, {
+        version: number;
+        value: readonly ActiveKey<TTarget, TEvent>[];
+    }>;
+    nullTarget?: {
+        version: number;
+        value: readonly ActiveKey<TTarget, TEvent>[];
+    };
+}
+export interface ActiveKeysCaches<TTarget extends object, TEvent extends KeymapEvent> {
+    plain: ActiveKeysCache<TTarget, TEvent>;
+    bindings: ActiveKeysCache<TTarget, TEvent>;
+    metadata: ActiveKeysCache<TTarget, TEvent>;
+    bindingsAndMetadata: ActiveKeysCache<TTarget, TEvent>;
+}
+export declare function createActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(): ActiveKeysCache<TTarget, TEvent>;
+export declare function createActiveKeysCaches<TTarget extends object, TEvent extends KeymapEvent>(): ActiveKeysCaches<TTarget, TEvent>;
+export declare function getActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(caches: ActiveKeysCaches<TTarget, TEvent>, options?: ActiveKeyOptions): ActiveKeysCache<TTarget, TEvent>;
+export declare function getFocusedActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(cache: ActiveKeysCache<TTarget, TEvent>, cacheVersion: number, focused: TTarget | null): {
+    version: number;
+    value: readonly ActiveKey<TTarget, TEvent>[];
+} | undefined;
+export declare function setFocusedActiveKeysCache<TTarget extends object, TEvent extends KeymapEvent>(cache: ActiveKeysCache<TTarget, TEvent>, cacheVersion: number, focused: TTarget | null, value: readonly ActiveKey<TTarget, TEvent>[]): void;