@opentui/keymap 0.2.2 → 0.2.4

package/src/keymap.d.ts

@@ -1,49 +1,33 @@
-import type { ActiveBinding, ActiveKey, ActiveKeyOptions, BindingExpander, BindingParser, BindingFieldCompiler, LayerBindingsTransformer, BindingTransformer, Events, CommandFieldCompiler, CommandBindingsQuery, CommandEntry, CommandQuery, CommandRecord, KeymapEvent, KeymapHost, LayerAnalyzer, Listener, RunCommandOptions, RunCommandResult, CommandResolver, KeyInterceptOptions, KeyInputContext, Layer, LayerFieldCompiler, KeyDisambiguationResolver, RawInterceptOptions, RawInputContext, EventMatchResolver, KeyStringifyInput, KeyToken, KeyLike, KeySequencePart, StringifyOptions } 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>[];
+    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;
@@ -53,10 +37,14 @@ export declare class Keymap<TTarget extends object, TEvent extends KeymapEvent =
     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;
@@ -74,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>;