@opentui/keymap 0.2.2 → 0.2.4

package/src/services/layers.d.ts

@@ -2,41 +2,32 @@ import type { CompilerService } from "./compiler.js";
 import type { CommandCatalogService } from "./command-catalog.js";
 import type { ConditionService } from "./conditions.js";
 import type { ActivationService } from "./activation.js";
-import type { KeymapEvent, KeymapHost, Layer, LayerAnalyzer, ResolvedKeyToken } from "../types.js";
+import type { Binding, BindingState, KeymapEvent, KeymapHost, Layer, ResolvedKeyToken, CommandState } from "../types.js";
 import type { State } from "./state.js";
 import type { NotificationService } from "./notify.js";
 interface LayersOptions<TTarget extends object, TEvent extends KeymapEvent> {
     compiler: CompilerService<TTarget, TEvent>;
     commands: CommandCatalogService<TTarget, TEvent>;
     host: KeymapHost<TTarget, TEvent>;
+    diagnostics?: LayerDiagnostics<TTarget, TEvent>;
     warnUnknownField: (kind: "binding" | "layer", fieldName: string) => void;
 }
-export declare class LayerService<TTarget extends object, TEvent extends KeymapEvent> {
-    private readonly state;
-    private readonly notify;
-    private readonly conditions;
-    private readonly activation;
-    private readonly options;
-    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, options: LayersOptions<TTarget, TEvent>);
+export interface AnalyzeLayerOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    target?: TTarget;
+    order: number;
+    commands: readonly CommandState<TTarget, TEvent>[];
+    sourceBindings: readonly Binding<TTarget, TEvent>[];
+    bindings: readonly BindingState<TTarget, TEvent>[];
+    hasTokenBindings: boolean;
+}
+export interface LayerDiagnostics<TTarget extends object, TEvent extends KeymapEvent> {
+    analyzeLayer(options: AnalyzeLayerOptions<TTarget, TEvent>): void;
+}
+export interface LayerService<TTarget extends object, TEvent extends KeymapEvent> {
     registerLayer(layer: Layer<TTarget, TEvent>): () => void;
     applyTokenState(nextTokens: Map<string, ResolvedKeyToken>): void;
     recompileBindings(): void;
-    prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
-    appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void;
-    clearLayerAnalyzers(): void;
     cleanup(): void;
-    private normalizeTargetMode;
-    private applyLayerBindingsTransformers;
-    private runLayerAnalyzers;
-    private compileLayerRuntimeState;
-    private compileLayerBindings;
-    private applyCompiledBindings;
-    private indexLayer;
-    private removeLayerFromIndex;
-    private unregisterLayer;
-    private connectRuntimeMatchable;
-    private disconnectRuntimeMatchable;
-    private attachReactiveMatchers;
-    private detachReactiveMatchers;
 }
+export declare function createLayerService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>, options: LayersOptions<TTarget, TEvent>): LayerService<TTarget, TEvent>;
 export {};

package/src/services/notify.d.ts

@@ -1,19 +1,17 @@
 import type { Events, HookName, Hooks, KeymapEvent } from "../types.js";
+import type { RuntimeEmitter } from "../lib/runtime-utils.js";
 import type { State } from "./state.js";
-import { Emitter } from "../lib/emitter.js";
 type DiagnosticEvents<TTarget extends object, TEvent extends KeymapEvent> = Pick<Events<TTarget, TEvent>, "warning" | "error">;
 export declare const MAX_STATE_CHANGE_FLUSH_ITERATIONS = 1000;
-export declare class NotificationService<TTarget extends object, TEvent extends KeymapEvent> {
-    private readonly state;
-    private readonly events;
-    private readonly hooks;
-    constructor(state: State<TTarget, TEvent>, events: Emitter<DiagnosticEvents<TTarget, TEvent>>, hooks: Emitter<Hooks<TTarget, TEvent>>);
+export interface NotificationService<TTarget extends object, TEvent extends KeymapEvent> {
     runWithStateChangeBatch<T>(fn: () => T): T;
-    queueStateChange(): void;
+    queueStateChange(options?: {
+        invalidateCaches?: boolean;
+    }): void;
     emitWarning(code: string, warning: unknown, message: string): void;
     emitError(code: string, error: unknown, message: string): void;
     reportListenerError(name: HookName, error: unknown): void;
     warnOnce(key: string, code: string, warning: unknown, message: string): void;
-    private flushStateChange;
 }
+export declare function createNotificationService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, events: RuntimeEmitter<DiagnosticEvents<TTarget, TEvent>>, hooks: RuntimeEmitter<Hooks<TTarget, TEvent>>): NotificationService<TTarget, TEvent>;
 export {};

package/src/services/pending-sequence.d.ts

@@ -0,0 +1,4 @@
+import type { KeymapEvent, KeySequencePart, PendingSequenceCapture, PendingSequenceState } from "../types.js";
+export declare function isSamePendingSequence<TTarget extends object, TEvent extends KeymapEvent>(current: PendingSequenceState<TTarget, TEvent> | null, next: PendingSequenceState<TTarget, TEvent> | null): boolean;
+export declare function popCapture<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function collectSequencePartsFromPending<TTarget extends object, TEvent extends KeymapEvent>(pending: PendingSequenceState<TTarget, TEvent>): KeySequencePart[];

package/src/services/primitives/active-layers.d.ts

@@ -1,8 +1,7 @@
 import type { KeymapEvent, KeymapHost, RegisteredLayer } from "../../types.js";
-import type { LayersState } from "../state.js";
 export declare function getFocusedTargetIfAvailable<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>): TTarget | null;
 export declare function forEachActivationTarget<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, focused: TTarget | null, visit: (target: TTarget, isFocusedTarget: boolean) => boolean | void): void;
 export declare function getActivationPath<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): Set<TTarget>;
-export declare function getActiveLayersForFocused<TTarget extends object, TEvent extends KeymapEvent>(state: LayersState<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): readonly RegisteredLayer<TTarget, TEvent>[];
-export declare function invalidateCachedActiveLayers<TTarget extends object, TEvent extends KeymapEvent>(state: LayersState<TTarget, TEvent>): void;
+export declare function getActiveLayersForFocused<TTarget extends object, TEvent extends KeymapEvent>(layers: readonly RegisteredLayer<TTarget, TEvent>[] | ReadonlySet<RegisteredLayer<TTarget, TEvent>>, host: KeymapHost<TTarget, TEvent>, focused: TTarget | null): readonly RegisteredLayer<TTarget, TEvent>[];
+export declare function getSortedLayers<TTarget extends object, TEvent extends KeymapEvent>(layers: ReadonlySet<RegisteredLayer<TTarget, TEvent>>): RegisteredLayer<TTarget, TEvent>[];
 export declare function isLayerActiveForFocused<TTarget extends object, TEvent extends KeymapEvent>(host: KeymapHost<TTarget, TEvent>, layer: RegisteredLayer<TTarget, TEvent>, focused: TTarget | null, activationPath?: ReadonlySet<TTarget>): boolean;

package/src/services/primitives/bindings.d.ts

@@ -0,0 +1,4 @@
+import type { Binding, BindingsValidationResult, Bindings, KeymapEvent, ParsedBinding } from "../../types.js";
+export declare function validateBindings(bindings: unknown): BindingsValidationResult;
+export declare function snapshotBindings<TTarget extends object, TEvent extends KeymapEvent>(bindings: Bindings<TTarget, TEvent>): Binding<TTarget, TEvent>[];
+export declare function snapshotParsedBinding<TTarget extends object, TEvent extends KeymapEvent>(binding: ParsedBinding<TTarget, TEvent>): ParsedBinding<TTarget, TEvent>;

package/src/services/primitives/field-invariants.d.ts

@@ -1,3 +1,18 @@
-import type { Attributes, EventData } from "../../types.js";
+import type { Attributes, BindingFieldContext, CommandFieldContext, EventData, KeymapEvent, LayerFieldContext, RuntimeMatcher } from "../../types.js";
+import type { ConditionService } from "../conditions.js";
 export declare function mergeRequirement(target: EventData, name: string, value: unknown, source: string): void;
 export declare function mergeAttribute(target: Attributes, name: string, value: unknown, source: string): void;
+interface FieldCompilerContextOptions<TTarget extends object, TEvent extends KeymapEvent> {
+    fieldName: string;
+    conditions: ConditionService<TTarget, TEvent>;
+    requirements: EventData;
+    matchers: RuntimeMatcher[];
+    attrs?: Attributes;
+}
+export declare function createFieldCompilerContext<TTarget extends object, TEvent extends KeymapEvent>(options: FieldCompilerContextOptions<TTarget, TEvent> & {
+    attrs: Attributes;
+}): BindingFieldContext & CommandFieldContext & LayerFieldContext;
+export declare function createFieldCompilerContext<TTarget extends object, TEvent extends KeymapEvent>(options: FieldCompilerContextOptions<TTarget, TEvent> & {
+    attrs?: undefined;
+}): LayerFieldContext;
+export {};

package/src/services/primitives/pending-captures.d.ts

@@ -0,0 +1,5 @@
+import type { KeymapEvent, PendingSequenceCapture, ResolvedSequencePattern } from "../../types.js";
+export declare function patternCaptureCount<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>): number;
+export declare function captureHasMinimum<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, missingPatternResult?: boolean): boolean;
+export declare function captureHasContinuations<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, missingPatternMinimum?: boolean): boolean;
+export declare function captureIsExact<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): boolean;

package/src/services/runtime-view.d.ts

@@ -0,0 +1,5 @@
+import type { ConditionService } from "./conditions.js";
+import type { ActiveCommandView, CommandView, State } from "./state.js";
+import type { KeymapEvent, KeymapHost } from "../types.js";
+export declare function getRegisteredCommandView<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>): CommandView<TTarget, TEvent>;
+export declare function getActiveCommandView<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, host: KeymapHost<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, focused: TTarget | null): ActiveCommandView<TTarget, TEvent>;

package/src/services/runtime.d.ts

@@ -1,15 +1,10 @@
 import type { EventData, KeymapEvent } from "../types.js";
 import type { ActivationService } from "./activation.js";
-import type { ConditionService } from "./conditions.js";
 import type { NotificationService } from "./notify.js";
 import type { State } from "./state.js";
-export declare class RuntimeService<TTarget extends object, TEvent extends KeymapEvent> {
-    private readonly state;
-    private readonly notify;
-    private readonly conditions;
-    private readonly activation;
-    constructor(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, conditions: ConditionService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>);
+export interface RuntimeService<TTarget extends object, TEvent extends KeymapEvent> {
     getData(name: string): unknown;
     setData(name: string, value: unknown): void;
     getReadonlyData(): Readonly<EventData>;
 }
+export declare function createRuntimeService<TTarget extends object, TEvent extends KeymapEvent>(state: State<TTarget, TEvent>, notify: NotificationService<TTarget, TEvent>, activation: ActivationService<TTarget, TEvent>): RuntimeService<TTarget, TEvent>;

package/src/services/sequence-index.d.ts

@@ -0,0 +1,24 @@
+import type { BindingState, KeymapEvent, KeySequencePart, KeyMatch, PendingSequenceCapture, PendingSequencePatternCapture, RegisteredLayer, ResolvedSequencePattern, SequenceNode, SequencePatternMatch } from "../types.js";
+export interface SequenceActiveOption<TTarget extends object, TEvent extends KeymapEvent> {
+    part: KeySequencePart;
+    binding: BindingState<TTarget, TEvent>;
+    index: number;
+    exact: boolean;
+    continues: boolean;
+}
+export declare function createSequenceNode<TTarget extends object, TEvent extends KeymapEvent>(parent: SequenceNode<TTarget, TEvent> | null, stroke: KeySequencePart["stroke"] | null, match: KeySequencePart["match"] | null, pattern?: ResolvedSequencePattern<TEvent>): SequenceNode<TTarget, TEvent>;
+export declare function buildSequenceTree<TTarget extends object, TEvent extends KeymapEvent>(bindings: readonly BindingState<TTarget, TEvent>[], patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): SequenceNode<TTarget, TEvent>;
+export declare function getCaptureNode<TTarget extends object, TEvent extends KeymapEvent>(root: SequenceNode<TTarget, TEvent>, capture: import("../types.js").PendingSequenceCapture<TTarget, TEvent>): SequenceNode<TTarget, TEvent> | undefined;
+export declare function getNodeSequence<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): KeySequencePart[];
+export declare function getNodePresentation<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): {
+    display: string;
+    tokenName?: string;
+};
+export declare function firstNodeForMatch<TTarget extends object, TEvent extends KeymapEvent>(root: SequenceNode<TTarget, TEvent>, match: KeyMatch): SequenceNode<TTarget, TEvent> | undefined;
+export declare function childNodes<TTarget extends object, TEvent extends KeymapEvent>(node: SequenceNode<TTarget, TEvent>): SequenceNode<TTarget, TEvent>[];
+export declare function activeOptionsForBindings<TTarget extends object, TEvent extends KeymapEvent>(bindings: readonly BindingState<TTarget, TEvent>[]): SequenceActiveOption<TTarget, TEvent>[];
+export declare function activeOptionsForCaptures<TTarget extends object, TEvent extends KeymapEvent>(captures: readonly PendingSequenceCapture<TTarget, TEvent>[], patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>): SequenceActiveOption<TTarget, TEvent>[];
+export declare function capturePriority<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, matchKeys: readonly KeyMatch[]): number;
+export declare function advanceSequenceBinding<TTarget extends object, TEvent extends KeymapEvent>(layer: RegisteredLayer<TTarget, TEvent>, binding: BindingState<TTarget, TEvent>, index: number, parts: readonly KeySequencePart[], patterns: readonly PendingSequencePatternCapture[] | undefined, matchKeys: readonly KeyMatch[], event: TEvent, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function advanceSequenceCapture<TTarget extends object, TEvent extends KeymapEvent>(capture: PendingSequenceCapture<TTarget, TEvent>, matchKeys: readonly KeyMatch[], event: TEvent, patterns: ReadonlyMap<string, ResolvedSequencePattern<TEvent>>, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent> | undefined;
+export declare function collectRootSequenceCaptures<TTarget extends object, TEvent extends KeymapEvent>(layer: RegisteredLayer<TTarget, TEvent>, matchKeys: readonly KeyMatch[], event: TEvent, matchPattern: (patternName: string, event: TEvent) => SequencePatternMatch | undefined, createPatternPart: (event: TEvent, patternName: string, match: SequencePatternMatch) => KeySequencePart): PendingSequenceCapture<TTarget, TEvent>[];

package/src/services/state.d.ts

@@ -1,116 +1,70 @@
-import type { ActiveKey, BindingExpander, BindingFieldCompiler, LayerBindingsTransformer, BindingParser, BindingTransformer, CommandFieldCompiler, CommandResolver, EventData, KeyDisambiguationResolver, EventMatchResolver, KeyInputContext, KeySequencePart, KeymapEvent, LayerAnalyzer, LayerFieldCompiler, PendingSequenceState, RawInputContext, RegisteredCommand, RegisteredLayer, ResolvedBindingCommand, RuntimeMatchable } from "../types.js";
-import { OrderedRegistry, PriorityRegistry } from "../lib/registry.js";
-export interface CoreState {
-    order: number;
-}
-export interface EnvironmentState<TTarget extends object, TEvent extends KeymapEvent> {
-    tokens: Map<string, import("../types.js").ResolvedKeyToken>;
-    layerFields: Map<string, LayerFieldCompiler>;
-    layerBindingsTransformers: OrderedRegistry<LayerBindingsTransformer<TTarget, TEvent>>;
-    bindingExpanders: OrderedRegistry<BindingExpander>;
-    bindingParsers: OrderedRegistry<BindingParser>;
-    bindingTransformers: OrderedRegistry<BindingTransformer<TTarget, TEvent>>;
-    bindingFields: Map<string, BindingFieldCompiler>;
-    commandFields: Map<string, CommandFieldCompiler>;
-}
-export interface DispatchState<TTarget extends object, TEvent extends KeymapEvent> {
-    eventMatchResolvers: OrderedRegistry<EventMatchResolver<TEvent>>;
-    disambiguationResolvers: OrderedRegistry<KeyDisambiguationResolver<TTarget, TEvent>>;
-    keyHooks: PriorityRegistry<(ctx: KeyInputContext<TEvent>) => void, {
-        priority: number;
-        release: boolean;
-    }>;
-    rawHooks: PriorityRegistry<(ctx: RawInputContext) => void, {
-        priority: number;
-    }>;
-}
-export interface LayersState<TTarget extends object, TEvent extends KeymapEvent> {
-    layers: Set<RegisteredLayer<TTarget, TEvent>>;
-    sortedLayers: RegisteredLayer<TTarget, TEvent>[];
-    activeLayersVersion: number;
-    activeLayersCacheVersion: number;
-    activeLayersCacheFocused: TTarget | null | undefined;
-    activeLayersCache: readonly RegisteredLayer<TTarget, TEvent>[];
-    layersWithConditions: number;
-    layersWithCommands: number;
-    layerAnalyzers: OrderedRegistry<LayerAnalyzer<TTarget, TEvent>>;
-}
+import type { Attributes, BindingExpander, BindingFieldCompiler, LayerBindingsTransformer, BindingParser, BindingTransformer, Command, CommandFieldCompiler, CommandTransformer, CommandResolver, EventData, KeyDisambiguationResolver, EventMatchResolver, KeyAfterInputContext, KeyInputContext, KeymapEvent, LayerFieldCompiler, PendingSequenceState, RawInputContext, ResolvedSequencePattern, CommandState, RegisteredLayer } from "../types.js";
+import { type RuntimeOrderedRegistry, type RuntimePriorityRegistry } from "../lib/runtime-utils.js";
 export interface LayerCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
     layer: RegisteredLayer<TTarget, TEvent>;
-    command: RegisteredCommand<TTarget, TEvent>;
+    commandState: CommandState<TTarget, TEvent>;
 }
 export interface ResolvedCommandEntry<TTarget extends object, TEvent extends KeymapEvent> {
     target?: TTarget;
-    resolved: ResolvedBindingCommand<TTarget, TEvent>;
-}
-export interface CommandChainCacheState<TTarget extends object, TEvent extends KeymapEvent> {
-    resolvedWithoutRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
-    resolvedWithRecordChains: Map<string, readonly ResolvedCommandEntry<TTarget, TEvent>[]>;
-    fallbackWithoutRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
-    fallbackWithRecord: Map<string, ResolvedBindingCommand<TTarget, TEvent> | null>;
-    fallbackWithoutRecordErrors: Set<string>;
-    fallbackWithRecordErrors: Set<string>;
+    command: Command<TTarget, TEvent>;
+    attrs?: Readonly<Attributes>;
+    input?: string;
+    payload?: unknown;
 }
-export interface ActiveCommandView<TTarget extends object, TEvent extends KeymapEvent> extends CommandChainCacheState<TTarget, TEvent> {
-    cacheable: boolean;
+export interface ActiveCommandView<TTarget extends object, TEvent extends KeymapEvent> {
+    layers: readonly RegisteredLayer<TTarget, TEvent>[];
     entries: readonly LayerCommandEntry<TTarget, TEvent>[];
     reachable: readonly LayerCommandEntry<TTarget, TEvent>[];
     reachableByName: ReadonlyMap<string, LayerCommandEntry<TTarget, TEvent>>;
     chainsByName: ReadonlyMap<string, readonly LayerCommandEntry<TTarget, TEvent>[]>;
 }
-export interface RegisteredCommandView<TTarget extends object, TEvent extends KeymapEvent> extends CommandChainCacheState<TTarget, TEvent> {
+export interface CommandView<TTarget extends object, TEvent extends KeymapEvent> {
     entries: readonly LayerCommandEntry<TTarget, TEvent>[];
     chainsByName: ReadonlyMap<string, readonly LayerCommandEntry<TTarget, TEvent>[]>;
 }
-export interface CommandsState<TTarget extends object, TEvent extends KeymapEvent> {
-    commandMetadataVersion: number;
-    registeredNames: Map<string, number>;
-    commandResolvers: OrderedRegistry<CommandResolver<TTarget, TEvent>>;
-    activeCommandViewVersion: number;
-    activeCommandView?: ActiveCommandView<TTarget, TEvent>;
-    registeredCommandViewVersion: number;
-    registeredCommandView?: RegisteredCommandView<TTarget, TEvent>;
-    registeredCommandEntriesCacheVersion: number;
-    registeredCommandEntriesCache: readonly LayerCommandEntry<TTarget, TEvent>[];
-}
-export interface ProjectionState<TTarget extends object, TEvent extends KeymapEvent> {
-    pendingSequence: PendingSequenceState<TTarget, TEvent> | null;
-    pendingSequenceCacheVersion: number;
-    pendingSequenceCache: readonly KeySequencePart[];
-    activeKeysPlainCacheVersion: number;
-    activeKeysPlainCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysBindingsCacheVersion: number;
-    activeKeysBindingsCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysMetadataCacheVersion: number;
-    activeKeysMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
-    activeKeysBindingsAndMetadataCacheVersion: number;
-    activeKeysBindingsAndMetadataCache: readonly ActiveKey<TTarget, TEvent>[];
-}
-export interface ConditionsState {
-    runtimeKeyDependents: Map<string, Set<RuntimeMatchable>>;
-}
-export interface RuntimeState {
+export interface State<TTarget extends object, TEvent extends KeymapEvent> {
+    order: number;
+    tokens: Map<string, import("../types.js").ResolvedKeyToken>;
+    patterns: Map<string, ResolvedSequencePattern<TEvent>>;
+    layerFields: Map<string, LayerFieldCompiler>;
+    layerBindingsTransformers: RuntimeOrderedRegistry<LayerBindingsTransformer<TTarget, TEvent>>;
+    bindingExpanders: RuntimeOrderedRegistry<BindingExpander>;
+    bindingParsers: RuntimeOrderedRegistry<BindingParser>;
+    bindingTransformers: RuntimeOrderedRegistry<BindingTransformer<TTarget, TEvent>>;
+    bindingFields: Map<string, BindingFieldCompiler>;
+    commandTransformers: RuntimeOrderedRegistry<CommandTransformer<TTarget, TEvent>>;
+    commandFields: Map<string, CommandFieldCompiler>;
+    eventMatchResolvers: RuntimeOrderedRegistry<EventMatchResolver<TEvent>>;
+    disambiguationResolvers: RuntimeOrderedRegistry<KeyDisambiguationResolver<TTarget, TEvent>>;
+    keyHooks: RuntimePriorityRegistry<(ctx: KeyInputContext<TEvent>) => void, {
+        priority: number;
+        release: boolean;
+    }>;
+    keyAfterHooks: RuntimePriorityRegistry<(ctx: KeyAfterInputContext<TTarget, TEvent>) => void, {
+        priority: number;
+        release: boolean;
+    }>;
+    rawHooks: RuntimePriorityRegistry<(ctx: RawInputContext) => void, {
+        priority: number;
+    }>;
+    layers: Set<RegisteredLayer<TTarget, TEvent>>;
+    sortedLayers: RegisteredLayer<TTarget, TEvent>[];
+    activeLayersCacheVersion: number;
+    activeLayersCacheFocused: TTarget | null | undefined;
+    activeLayersCache: RegisteredLayer<TTarget, TEvent>[];
+    activeKeyCacheBlockers: number;
+    activeCommandViewCacheBlockers: number;
+    commandResolvers: RuntimeOrderedRegistry<CommandResolver<TTarget, TEvent>>;
+    pending: PendingSequenceState<TTarget, TEvent> | null;
     data: EventData;
     dataVersion: number;
     readonlyDataVersion: number;
     readonlyData: Readonly<EventData>;
-}
-export interface NotifyState {
-    derivedStateVersion: number;
+    cacheVersion: number;
+    derivedVersion: number;
     stateChangeDepth: number;
     stateChangePending: boolean;
     flushingStateChange: boolean;
     usedWarningKeys: Set<string>;
 }
-export interface State<TTarget extends object, TEvent extends KeymapEvent> {
-    core: CoreState;
-    environment: EnvironmentState<TTarget, TEvent>;
-    dispatch: DispatchState<TTarget, TEvent>;
-    layers: LayersState<TTarget, TEvent>;
-    commands: CommandsState<TTarget, TEvent>;
-    projection: ProjectionState<TTarget, TEvent>;
-    conditions: ConditionsState;
-    runtime: RuntimeState;
-    notify: NotifyState;
-}
 export declare function createKeymapState<TTarget extends object, TEvent extends KeymapEvent>(): State<TTarget, TEvent>;

package/src/solid/index.d.ts

@@ -1,5 +1,5 @@
 import type { KeyEvent, Renderable } from "@opentui/core";
-import { type Keymap, type LayerFields, type ReactiveMatcher } from "../index.js";
+import { type Keymap, type Layer, type ReactiveMatcher, type TargetMode } from "../index.js";
 import { type Accessor, type JSX } from "solid-js";
 type OpenTuiKeymap = Keymap<Renderable, KeyEvent>;
 export interface KeymapProviderProps {
@@ -8,31 +8,17 @@ export interface KeymapProviderProps {
 }
 export declare function KeymapProvider(props: KeymapProviderProps): JSX.Element;
 export type UseBindingsTarget<TRenderable extends Renderable = Renderable> = () => TRenderable | null | undefined;
-type UseBindingsLayerBase = LayerFields<Renderable, KeyEvent>;
-export interface UseGlobalBindingsLayer extends UseBindingsLayerBase {
-    target?: undefined;
+export interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<Layer<Renderable, KeyEvent>, "target" | "targetMode"> {
+    target?: UseBindingsTarget<TRenderable>;
+    targetMode?: TargetMode;
 }
-export interface UseFocusBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode: "focus";
-    target: UseBindingsTarget<TRenderable>;
-}
-export interface UseFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    targetMode?: "focus-within";
-    target: UseBindingsTarget<TRenderable>;
-}
-export interface UseInferredFocusWithinBindingsLayer<TRenderable extends Renderable = Renderable> extends UseBindingsLayerBase {
-    target: UseBindingsTarget<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;
 /**
  * Reactively derives any view from the current keymap by re-running `selector`
  * on each batched keymap state change.
  */
 export declare const useKeymapSelector: <T>(selector: (keymap: OpenTuiKeymap) => T) => Accessor<T>;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseGlobalBindingsLayer): void;
-export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseTargetBindingsLayer<TRenderable>): void;
+export declare function useBindings<TRenderable extends Renderable = Renderable>(createLayer: () => UseBindingsLayer<TRenderable>): void;
 /**
  * Adapts a Solid accessor to `ReactiveMatcher`. The subscription
  * lives in a disposable reactive root so unregistering the layer tears it

package/src/solid/index.js

@@ -115,3 +115,6 @@ export {
   reactiveMatcherFromSignal,
   KeymapProvider
 };
+
+//# debugId=A624A2E448C2557164756E2164756E21
+//# sourceMappingURL=index.js.map

package/src/solid/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/solid/index.ts"],
+  "sourcesContent": [
+    "import type { KeyEvent, Renderable } from \"@opentui/core\"\nimport { type Keymap, type Layer, type ReactiveMatcher, type TargetMode } from \"../index.js\"\nimport {\n  createComponent,\n  createContext,\n  createEffect,\n  createMemo,\n  createRoot,\n  createSignal,\n  on,\n  onCleanup,\n  onMount,\n  useContext,\n  type Accessor,\n  type JSX,\n} from \"solid-js\"\n\ntype OpenTuiKeymap = Keymap<Renderable, KeyEvent>\n\nconst KeymapContext = createContext<OpenTuiKeymap>()\n\nexport interface KeymapProviderProps {\n  keymap: OpenTuiKeymap\n  children: JSX.Element\n}\n\nexport function KeymapProvider(props: KeymapProviderProps): JSX.Element {\n  return createComponent(KeymapContext.Provider, {\n    get value() {\n      return props.keymap\n    },\n    get children() {\n      return props.children\n    },\n  })\n}\n\nexport type UseBindingsTarget<TRenderable extends Renderable = Renderable> = () => TRenderable | null | undefined\n\nexport interface UseBindingsLayer<TRenderable extends Renderable = Renderable> extends Omit<\n  Layer<Renderable, KeyEvent>,\n  \"target\" | \"targetMode\"\n> {\n  target?: UseBindingsTarget<TRenderable>\n  targetMode?: TargetMode\n}\n\nfunction resolveBindingsTarget(target: UseBindingsTarget | undefined): Renderable | undefined {\n  return target?.() ?? 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\nfunction useKeymapStateVersion(keymap: OpenTuiKeymap): Accessor<number> {\n  const [version, setVersion] = createSignal(0)\n  let dispose: (() => void) | undefined\n\n  onMount(() => {\n    dispose = keymap.on(\"state\", () => {\n      setVersion((value) => value + 1)\n    })\n\n    setVersion((value) => value + 1)\n  })\n\n  onCleanup(() => {\n    dispose?.()\n  })\n\n  return version\n}\n\n/**\n * Reactively derives any view from the current keymap by re-running `selector`\n * on each batched keymap state change.\n */\nexport const useKeymapSelector = <T>(selector: (keymap: OpenTuiKeymap) => T): Accessor<T> => {\n  const keymap = useKeymap()\n  const version = useKeymapStateVersion(keymap)\n\n  return createMemo((previous) => {\n    version()\n    try {\n      return selector(keymap)\n    } catch (error) {\n      if (\n        previous !== undefined &&\n        error instanceof Error &&\n        error.message === \"Cannot use a keymap after its host was destroyed\"\n      ) {\n        return previous\n      }\n\n      throw error\n    }\n  })\n}\n\nexport function useBindings<TRenderable extends Renderable = Renderable>(\n  createLayer: () => UseBindingsLayer<TRenderable>,\n): void {\n  const keymap = useKeymap()\n\n  createEffect(() => {\n    const layer = createLayer()\n    const hasExplicitTarget = layer.target !== undefined\n    const explicitTarget = resolveBindingsTarget(layer.target)\n    const nextTargetMode: TargetMode | undefined = layer.targetMode ?? (hasExplicitTarget ? \"focus-within\" : undefined)\n\n    const { target: _target, targetMode: _targetMode, ...baseLayer } = layer\n    if (!nextTargetMode) {\n      const dispose = keymap.registerLayer({\n        ...baseLayer,\n      })\n\n      onCleanup(() => {\n        dispose()\n      })\n\n      return\n    }\n\n    if (!hasExplicitTarget) {\n      throw new Error(\"useBindings local bindings need a target accessor\")\n    }\n\n    if (!explicitTarget) {\n      return\n    }\n\n    const dispose = keymap.registerLayer({\n      ...baseLayer,\n      target: explicitTarget,\n      targetMode: nextTargetMode,\n    })\n\n    onCleanup(() => {\n      dispose()\n    })\n  })\n}\n\n/**\n * Adapts a Solid accessor to `ReactiveMatcher`. The subscription\n * lives in a disposable reactive root so unregistering the layer tears it\n * down. Pass `predicate` when the accessor value is not already boolean.\n */\nexport function reactiveMatcherFromSignal<T>(\n  accessor: Accessor<T>,\n  predicate?: (value: T) => boolean,\n): ReactiveMatcher {\n  return {\n    get() {\n      return predicate ? predicate(accessor()) : Boolean(accessor())\n    },\n    subscribe(onChange) {\n      return createRoot((dispose) => {\n        createEffect(on(accessor, () => onChange(), { defer: true }))\n        return dispose\n      })\n    },\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "A624A2E448C2557164756E2164756E21",
+  "names": []
+}

package/src/testing/index.d.ts

@@ -0,0 +1,90 @@
+import { Keymap } from "@opentui/keymap";
+import type { ErrorEvent, HostMetadata, KeymapEvent, KeymapHost, WarningEvent } from "@opentui/keymap";
+export type TestKeyModifierOptions = Partial<Pick<KeymapEvent, "ctrl" | "shift" | "meta" | "super" | "hyper">>;
+export type TestHostMetadataOptions = Partial<Omit<HostMetadata, "modifiers">> & {
+    modifiers?: Partial<HostMetadata["modifiers"]>;
+};
+export interface CreateTestKeymapHostOptions {
+    metadata?: HostMetadata | TestHostMetadataOptions;
+}
+export interface CreateTestKeymapOptions extends CreateTestKeymapHostOptions {
+    defaultKeys?: boolean;
+}
+export interface TestDiagnosticCapture {
+    readonly warnings: readonly string[];
+    readonly errors: readonly string[];
+    readonly warningEvents: readonly WarningEvent[];
+    readonly errorEvents: readonly ErrorEvent[];
+    takeWarnings(): {
+        warnings: string[];
+        warningEvents: WarningEvent[];
+    };
+    takeErrors(): {
+        errors: string[];
+        errorEvents: ErrorEvent[];
+    };
+    clear(): void;
+    dispose(): void;
+}
+export interface TestKeymapHarness {
+    keymap: Keymap<TestKeymapTarget, TestKeymapEvent>;
+    host: TestKeymapHost;
+    root: TestKeymapTarget;
+    diagnostics: TestDiagnosticCapture;
+    cleanup(): void;
+}
+export declare const DEFAULT_TEST_HOST_METADATA: HostMetadata;
+export declare class TestKeymapTarget {
+    readonly id: string;
+    parent: TestKeymapTarget | null;
+    isDestroyed: boolean;
+    constructor(id: string);
+    append(child: TestKeymapTarget): TestKeymapTarget;
+}
+export declare class TestKeymapEvent implements KeymapEvent {
+    readonly name: string;
+    readonly ctrl: boolean;
+    readonly shift: boolean;
+    readonly meta: boolean;
+    readonly super: boolean;
+    readonly hyper?: boolean;
+    propagationStopped: boolean;
+    defaultPrevented: boolean;
+    constructor(name: string, modifiers?: TestKeyModifierOptions);
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export declare class TestKeymapHost implements KeymapHost<TestKeymapTarget, TestKeymapEvent> {
+    readonly metadata: HostMetadata;
+    readonly rootTarget: TestKeymapTarget;
+    isDestroyed: boolean;
+    private focusedTarget;
+    private readonly keyPressListeners;
+    private readonly keyReleaseListeners;
+    private readonly focusListeners;
+    private readonly destroyListeners;
+    private readonly rawListeners;
+    private readonly targetDestroyListeners;
+    constructor(options?: CreateTestKeymapHostOptions);
+    createTarget(id: string): TestKeymapTarget;
+    getFocusedTarget(): TestKeymapTarget | null;
+    getParentTarget(target: TestKeymapTarget): TestKeymapTarget | null;
+    isTargetDestroyed(target: TestKeymapTarget): boolean;
+    onKeyPress(listener: (event: TestKeymapEvent) => void): () => void;
+    onKeyRelease(listener: (event: TestKeymapEvent) => void): () => void;
+    onFocusChange(listener: (target: TestKeymapTarget | null) => void): () => void;
+    onDestroy(listener: () => void): () => void;
+    onTargetDestroy(target: TestKeymapTarget, listener: () => void): () => void;
+    onRawInput(listener: (sequence: string) => boolean): () => void;
+    createCommandEvent(): TestKeymapEvent;
+    focus(target: TestKeymapTarget | null): void;
+    press(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent;
+    release(name: string, modifiers?: TestKeyModifierOptions): TestKeymapEvent;
+    raw(sequence: string): boolean;
+    destroyTarget(target: TestKeymapTarget): void;
+    destroy(): void;
+}
+export declare function createTestHostMetadata(options?: HostMetadata | TestHostMetadataOptions): HostMetadata;
+export declare function createTestKeymapHost(options?: CreateTestKeymapHostOptions): TestKeymapHost;
+export declare function createTestKeymap(options?: CreateTestKeymapOptions): TestKeymapHarness;
+export declare function captureKeymapDiagnostics(keymap: Keymap<any, any>): TestDiagnosticCapture;