On this page

@opentui/keymap

Every export of @opentui/keymap in the 0.6.0 release, from its type declarations. A version names the release that added an export after the module's first release.

Functions#

function stringifyKeySequence(input: readonly KeyStringifyInput[], options?: StringifyOptions): string
Core engine
function stringifyKeyStroke(input: KeyStringifyInput, options?: StringifyOptions): string
Core engine

Classes#

class Keymap<TTarget extends object, TEvent extends KeymapEvent = KeymapEvent>constructor Keymap(host: KeymapHost<TTarget, TEvent>)
Core engine
  • method Keymap.[KEYMAP_EXTENSION_CONTEXT](): KeymapExtensionContext<TTarget, TEvent>
  • method Keymap.acquireResource(key: symbol, setup: () => () => void): () => void
  • method Keymap.appendBindingExpander(expander: BindingExpander): () => void
  • method Keymap.appendBindingParser(parser: BindingParser): () => void
  • method Keymap.appendBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void
  • method Keymap.appendCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void
  • method Keymap.appendCommandTransformer(transformer: CommandTransformer<TTarget, TEvent>): () => void
  • method Keymap.appendDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void
  • method Keymap.appendEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void
  • method Keymap.appendLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void
  • method Keymap.appendLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void
  • method Keymap.clearBindingExpanders(): void
  • method Keymap.clearBindingParsers(): void
  • method Keymap.clearBindingTransformers(): void
  • method Keymap.clearCommandResolvers(): void
  • method Keymap.clearCommandTransformers(): void
  • method Keymap.clearDisambiguationResolvers(): void
  • method Keymap.clearEventMatchResolvers(): void
  • method Keymap.clearLayerAnalyzers(): void
  • method Keymap.clearLayerBindingsTransformers(): void
  • method Keymap.clearPendingSequence(): void
  • method Keymap.createKeyMatcher(key: KeyLike): (input: KeyStringifyInput | null | undefined) => boolean
  • method Keymap.dispatchCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>
  • method Keymap.formatKey(key: KeyLike, options?: StringifyOptions): string
  • method Keymap.getCommandBindings(query: CommandBindingsQuery<TTarget>): ReadonlyMap<string, readonly ActiveBinding<TTarget, TEvent>[]>
  • method Keymap.getCommandEntries(query?: CommandQuery<TTarget, TEvent>): readonly CommandEntry<TTarget, TEvent>[]
  • method Keymap.getCommands(query?: CommandQuery<TTarget, TEvent>): readonly Command<TTarget, TEvent>[]
  • method Keymap.getData(name: string): unknown
  • method Keymap.getHostMetadata(): Readonly<HostMetadata>
  • method Keymap.hasPendingSequence(): boolean
  • method Keymap.intercept(name: "key", fn: (ctx: KeyInputContext<TEvent>) => void, options?: KeyInterceptOptions): () => void
  • method Keymap.intercept(name: "key:after", fn: (ctx: KeyAfterInputContext<TTarget, TEvent>) => void, options?: KeyInterceptOptions): () => void
  • method Keymap.intercept(name: "raw", fn: (ctx: RawInputContext) => void, options?: RawInterceptOptions): () => void
  • method Keymap.on(name: "dispatch", fn: Listener<Events<TTarget, TEvent>["dispatch"]>): () => void
  • method Keymap.on(name: "error", fn: Listener<Events<TTarget, TEvent>["error"]>): () => void
  • method Keymap.on(name: "pendingSequence", fn: Listener<Events<TTarget, TEvent>["pendingSequence"]>): () => void
  • method Keymap.on(name: "state", fn: Listener<Events<TTarget, TEvent>["state"]>): () => void
  • method Keymap.on(name: "warning", fn: Listener<Events<TTarget, TEvent>["warning"]>): () => void
  • method Keymap.parseKeySequence(key: KeyLike): readonly KeySequencePart[]
  • method Keymap.popPendingSequence(): boolean
  • method Keymap.prependBindingExpander(expander: BindingExpander): () => void
  • method Keymap.prependBindingParser(parser: BindingParser): () => void
  • method Keymap.prependBindingTransformer(transformer: BindingTransformer<TTarget, TEvent>): () => void
  • method Keymap.prependCommandResolver(resolver: CommandResolver<TTarget, TEvent>): () => void
  • method Keymap.prependCommandTransformer(transformer: CommandTransformer<TTarget, TEvent>): () => void
  • method Keymap.prependDisambiguationResolver(resolver: KeyDisambiguationResolver<TTarget, TEvent>): () => void
  • method Keymap.prependEventMatchResolver(resolver: EventMatchResolver<TEvent>): () => void
  • method Keymap.prependLayerAnalyzer(analyzer: LayerAnalyzer<TTarget, TEvent>): () => void
  • method Keymap.prependLayerBindingsTransformer(transformer: LayerBindingsTransformer<TTarget, TEvent>): () => void
  • method Keymap.registerBindingFields(fields: Record<string, BindingFieldCompiler>): () => void
  • method Keymap.registerCommandFields(fields: Record<string, CommandFieldCompiler>): () => void
  • method Keymap.registerLayer(layer: Layer<TTarget, TEvent>): () => void
  • method Keymap.registerLayerFields(fields: Record<string, LayerFieldCompiler>): () => void
  • method Keymap.registerSequencePattern(pattern: SequencePattern<TEvent>): () => void
  • method Keymap.registerToken(token: KeyToken): () => void
  • method Keymap.runCommand(cmd: string, options?: RunCommandOptions<TTarget, TEvent>): RunCommandResult<TTarget, TEvent>
  • method Keymap.setData(name: string, value: unknown): void
  • property Keymap.getActiveKeys: (options?: ActiveKeyOptions) => readonly ActiveKey<TTarget, TEvent>[]
  • property Keymap.getPendingSequence: () => readonly KeySequencePart[]

Interfaces#

interface ActiveBinding<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property ActiveBinding.attrs?: Readonly<Attributes>
  • property ActiveBinding.command?: BindingCommand<TTarget, TEvent>
  • property ActiveBinding.commandAttrs?: Readonly<Attributes>
  • property ActiveBinding.event: BindingEvent
  • property ActiveBinding.fallthrough: boolean
  • property ActiveBinding.preventDefault: boolean
  • property ActiveBinding.sequence: KeySequencePart[]
interface ActiveKey<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property ActiveKey.bindingAttrs?: Readonly<Attributes>
  • property ActiveKey.bindings?: ActiveBinding<TTarget, TEvent>[]
  • property ActiveKey.command?: BindingCommand<TTarget, TEvent>
  • property ActiveKey.commandAttrs?: Readonly<Attributes>
  • property ActiveKey.continues: boolean
  • property ActiveKey.display: string
  • property ActiveKey.stroke: NormalizedKeyStroke
  • property ActiveKey.tokenName?: string
interface ActiveKeyOptions
Core engine
  • property ActiveKeyOptions.includeBindings?: boolean
  • property ActiveKeyOptions.includeMetadata?: boolean
interface BindingExpanderContext
Core engine
  • property BindingExpanderContext.displays?: readonly string[]
  • property BindingExpanderContext.input: string
  • property BindingExpanderContext.layer: Readonly<Record<string, unknown>>
interface BindingExpansion
Core engine
  • property BindingExpansion.displays?: readonly string[]
  • property BindingExpansion.key: string
interface BindingFieldContext
Core engine
  • method BindingFieldContext.activeWhen(matcher: (() => boolean) | ReactiveMatcher): void
  • method BindingFieldContext.attr(name: string, value: unknown): void
  • method BindingFieldContext.require(name: string, value: unknown): void
interface BindingParserContext
Core engine
  • method BindingParserContext.createMatch(id: string): KeyMatch
  • method BindingParserContext.normalizeTokenName(token: string): string
  • method BindingParserContext.parseObjectKey(key: KeyStrokeInput, options?: { display?: string; match?: KeyMatch; tokenName?: string; }): KeySequencePart
  • property BindingParserContext.index: number
  • property BindingParserContext.input: string
  • property BindingParserContext.layer: Readonly<Record<string, unknown>>
  • property BindingParserContext.patterns: ReadonlyMap<string, ResolvedSequencePattern>
  • property BindingParserContext.tokens: ReadonlyMap<string, ResolvedKeyToken>
interface BindingParserResult
Core engine
  • property BindingParserResult.nextIndex: number
  • property BindingParserResult.parts: KeySequencePart[]
  • property BindingParserResult.unknownTokens?: readonly string[]
  • property BindingParserResult.usedTokens?: readonly string[]
interface BindingTransformerContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method BindingTransformerContext.add(binding: ParsedBinding<TTarget, TEvent>): void
  • method BindingTransformerContext.parseKey(key: KeyLike): KeySequencePart
  • method BindingTransformerContext.skipOriginal(): void
  • property BindingTransformerContext.layer: Readonly<Record<string, unknown>>
interface CommandBindingsQuery<TTarget extends object = object>
Core engine
  • property CommandBindingsQuery.commands: readonly string[]
  • property CommandBindingsQuery.focused?: TTarget | null
  • property CommandBindingsQuery.visibility?: "reachable" | "active" | "registered"
interface CommandContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent, TPayload = unknown>
Core engine
  • property CommandContext.command?: Command<TTarget, TEvent, TPayload>
  • property CommandContext.data: Readonly<EventData>
  • property CommandContext.event: TEvent
  • property CommandContext.focused: TTarget | null
  • property CommandContext.input: string
  • property CommandContext.keymap: Keymap<TTarget, TEvent>
  • property CommandContext.payload: TPayload
  • property CommandContext.target: TTarget | null
interface CommandEntry<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property CommandEntry.bindings: readonly ActiveBinding<TTarget, TEvent>[]
  • property CommandEntry.command: Command<TTarget, TEvent>
interface CommandFieldContext
Core engine
  • method CommandFieldContext.activeWhen(matcher: (() => boolean) | ReactiveMatcher): void
  • method CommandFieldContext.attr(name: string, value: unknown): void
  • method CommandFieldContext.require(name: string, value: unknown): void
interface CommandQuery<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property CommandQuery.filter?: CommandFilter<TTarget, TEvent>
  • property CommandQuery.focused?: TTarget | null
  • property CommandQuery.limit?: number
  • property CommandQuery.namespace?: string | readonly string[]
  • property CommandQuery.search?: string
  • property CommandQuery.searchIn?: readonly string[]
  • property CommandQuery.visibility?: "reachable" | "active" | "registered"
interface CommandResolverContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method CommandResolverContext.getCommand(name: string): Command<TTarget, TEvent> | undefined
  • method CommandResolverContext.setInput(input: string): void
  • method CommandResolverContext.setPayload(payload: unknown): void
  • readonly property CommandResolverContext.input: string
  • readonly property CommandResolverContext.payload: unknown
interface CommandTransformerContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method CommandTransformerContext.add(command: Command<TTarget, TEvent>): void
  • method CommandTransformerContext.skipOriginal(): void
  • property CommandTransformerContext.layer: Readonly<Layer<TTarget, TEvent>>
interface DispatchBinding<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> extends ActiveBinding<TTarget, TEvent>
Core engine
  • property DispatchBinding.bindingIndex: number
  • property DispatchBinding.sourceLayerOrder: number
interface DispatchEvent<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property DispatchEvent.binding?: DispatchBinding<TTarget, TEvent>
  • property DispatchEvent.command?: BindingCommand<TTarget, TEvent>
  • property DispatchEvent.event: BindingEvent
  • property DispatchEvent.focused: TTarget | null
  • property DispatchEvent.layer?: DispatchLayer<TTarget>
  • property DispatchEvent.phase: DispatchPhase
  • property DispatchEvent.sequence: readonly KeySequencePart[]
interface DispatchLayer<TTarget extends object = object>
Core engine
  • property DispatchLayer.order: number
  • property DispatchLayer.priority: number
  • property DispatchLayer.target?: TTarget
  • property DispatchLayer.targetMode?: TargetMode
interface ErrorEvent
Core engine
  • property ErrorEvent.code: string
  • property ErrorEvent.error: unknown
  • property ErrorEvent.message: string
interface EventMatchResolverContext
Core engine
  • method EventMatchResolverContext.resolveKey(key: KeyLike): KeyMatch
interface HostMetadata
Core engine
  • property HostMetadata.modifiers: Record<HostModifier, HostCapability>
  • property HostMetadata.platform: HostPlatform
  • property HostMetadata.primaryModifier: "ctrl" | "super" | "unknown"
interface KeyAfterInputContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property KeyAfterInputContext.consume: (options?: { preventDefault?: boolean; stopPropagation?: boolean; }) => void
  • property KeyAfterInputContext.event: TEvent
  • property KeyAfterInputContext.eventType: BindingEvent
  • property KeyAfterInputContext.focused: TTarget | null
  • property KeyAfterInputContext.getData: (name: string) => unknown
  • property KeyAfterInputContext.handled: boolean
  • property KeyAfterInputContext.pendingSequence: readonly KeySequencePart[]
  • property KeyAfterInputContext.reason: KeyAfterReason
  • property KeyAfterInputContext.sequence: readonly KeySequencePart[]
  • property KeyAfterInputContext.setData: (name: string, value: unknown) => void
interface KeyDeferredDisambiguationContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method KeyDeferredDisambiguationContext.clear(): KeyDeferredDisambiguationDecision
  • method KeyDeferredDisambiguationContext.continueSequence(): KeyDeferredDisambiguationDecision
  • method KeyDeferredDisambiguationContext.runExact(): KeyDeferredDisambiguationDecision
  • method KeyDeferredDisambiguationContext.sleep(ms: number): Promise<boolean>
  • readonly property KeyDeferredDisambiguationContext.focused: TTarget | null
  • readonly property KeyDeferredDisambiguationContext.sequence: readonly KeySequencePart[]
  • readonly property KeyDeferredDisambiguationContext.signal: AbortSignal
interface KeyDeferredDisambiguationDecision
Core engine
  • readonly property KeyDeferredDisambiguationDecision.[KEY_DEFERRED_DISAMBIGUATION_DECISION]: true
interface KeyDisambiguationContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method KeyDisambiguationContext.clear(): KeyDisambiguationDecision
  • method KeyDisambiguationContext.continueSequence(): KeyDisambiguationDecision
  • method KeyDisambiguationContext.defer(run: KeyDeferredDisambiguationHandler<TTarget, TEvent>): KeyDisambiguationDecision
  • method KeyDisambiguationContext.getData(name: string): unknown
  • method KeyDisambiguationContext.runExact(): KeyDisambiguationDecision
  • method KeyDisambiguationContext.setData(name: string, value: unknown): void
  • readonly property KeyDisambiguationContext.continuations: readonly ActiveKey<TTarget, TEvent>[]
  • readonly property KeyDisambiguationContext.event: Readonly<Omit<TEvent, "preventDefault" | "stopPropagation">>
  • readonly property KeyDisambiguationContext.exact: readonly ActiveBinding<TTarget, TEvent>[]
  • readonly property KeyDisambiguationContext.focused: TTarget | null
  • readonly property KeyDisambiguationContext.sequence: readonly KeySequencePart[]
  • readonly property KeyDisambiguationContext.stroke: KeySequencePart
interface KeyDisambiguationDecision
Core engine
  • readonly property KeyDisambiguationDecision.[KEY_DISAMBIGUATION_DECISION]: true
interface KeyInputContext<TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property KeyInputContext.consume: (options?: { preventDefault?: boolean; stopPropagation?: boolean; }) => void
  • property KeyInputContext.event: TEvent
  • property KeyInputContext.getData: (name: string) => unknown
  • property KeyInputContext.setData: (name: string, value: unknown) => void
interface KeyInterceptOptions
Core engine
  • property KeyInterceptOptions.priority?: number
  • property KeyInterceptOptions.release?: boolean
interface KeymapEvent
Core engine
  • method KeymapEvent.preventDefault(): void
  • method KeymapEvent.stopPropagation(): void
  • property KeymapEvent.ctrl: boolean
  • property KeymapEvent.hyper?: boolean
  • property KeymapEvent.meta: boolean
  • property KeymapEvent.name: string
  • property KeymapEvent.shift: boolean
  • property KeymapEvent.super?: boolean
  • readonly property KeymapEvent.propagationStopped: boolean
interface KeymapExtensionContext<TTarget extends object, TEvent extends KeymapEvent>
Core engine
  • property KeymapExtensionContext.activation: ActivationService<TTarget, TEvent>
  • property KeymapExtensionContext.catalog: CommandCatalogService<TTarget, TEvent>
  • property KeymapExtensionContext.conditions: ConditionService<TTarget, TEvent>
  • property KeymapExtensionContext.host: KeymapHost<TTarget, TEvent>
  • property KeymapExtensionContext.state: State<TTarget, TEvent>
interface KeymapExtensionProvider<TTarget extends object, TEvent extends KeymapEvent>
Core engine
  • method KeymapExtensionProvider.[KEYMAP_EXTENSION_CONTEXT](): KeymapExtensionContext<TTarget, TEvent>
interface KeymapHost<TTarget extends object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method KeymapHost.createCommandEvent(): TEvent
  • method KeymapHost.getFocusedTarget(): TTarget | null
  • method KeymapHost.getParentTarget(target: TTarget): TTarget | null
  • method KeymapHost.isTargetDestroyed(target: TTarget): boolean
  • method KeymapHost.onDestroy?(listener: () => void): () => void
  • method KeymapHost.onFocusChange(listener: (target: TTarget | null) => void): () => void
  • method KeymapHost.onKeyPress(listener: (event: TEvent) => void): () => void
  • method KeymapHost.onKeyRelease(listener: (event: TEvent) => void): () => void
  • method KeymapHost.onRawInput?(listener: (sequence: string) => boolean): () => void
  • method KeymapHost.onTargetDestroy(target: TTarget, listener: () => void): () => void
  • readonly property KeymapHost.isDestroyed: boolean
  • readonly property KeymapHost.metadata: HostMetadata
  • readonly property KeymapHost.rootTarget: TTarget
interface KeySequencePart
Core engine
  • property KeySequencePart.display: string
  • property KeySequencePart.match: KeyMatch
  • property KeySequencePart.patternName?: string
  • property KeySequencePart.payloadKey?: string
  • property KeySequencePart.stroke: NormalizedKeyStroke
  • property KeySequencePart.tokenName?: string
interface KeyStrokeInput
Core engine
  • property KeyStrokeInput.ctrl?: boolean
  • property KeyStrokeInput.hyper?: boolean
  • property KeyStrokeInput.meta?: boolean
  • property KeyStrokeInput.name: string
  • property KeyStrokeInput.shift?: boolean
  • property KeyStrokeInput.super?: boolean
interface KeyToken
Core engine
  • property KeyToken.key: KeyLike
  • property KeyToken.name: string
interface LayerAnalysisContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method LayerAnalysisContext.checkCommandResolution(command: string): CommandResolutionStatus
  • method LayerAnalysisContext.error(code: string, error: unknown, message: string): void
  • method LayerAnalysisContext.warn(code: string, warning: unknown, message: string): void
  • method LayerAnalysisContext.warnOnce(key: string, code: string, warning: unknown, message: string): void
  • property LayerAnalysisContext.bindings: readonly LayerBindingAnalysis<TTarget, TEvent>[]
  • property LayerAnalysisContext.hasTokenBindings: boolean
  • property LayerAnalysisContext.order: number
  • property LayerAnalysisContext.sourceBindings: readonly Binding<TTarget, TEvent>[]
  • property LayerAnalysisContext.target?: TTarget
interface LayerBindingAnalysis<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property LayerBindingAnalysis.attrs?: Readonly<Attributes>
  • property LayerBindingAnalysis.bindingIndex: number
  • property LayerBindingAnalysis.command?: BindingCommand<TTarget, TEvent>
  • property LayerBindingAnalysis.event: BindingEvent
  • property LayerBindingAnalysis.fallthrough: boolean
  • property LayerBindingAnalysis.hasCommandAtSequence: boolean
  • property LayerBindingAnalysis.hasContinuations: boolean
  • property LayerBindingAnalysis.parsedBinding: ParsedBinding<TTarget, TEvent>
  • property LayerBindingAnalysis.preventDefault: boolean
  • property LayerBindingAnalysis.sequence: KeySequencePart[]
  • property LayerBindingAnalysis.sourceLayerOrder: number
  • property LayerBindingAnalysis.sourceTarget?: TTarget
interface LayerBindingsTransformerContext<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method LayerBindingsTransformerContext.validateBindings(bindings: unknown): BindingsValidationResult
  • property LayerBindingsTransformerContext.layer: Readonly<Layer<TTarget, TEvent>>
interface LayerFieldContext
Core engine
  • method LayerFieldContext.activeWhen(matcher: (() => boolean) | ReactiveMatcher): void
  • method LayerFieldContext.attr(name: string, value: unknown): void
  • method LayerFieldContext.require(name: string, value: unknown): void
interface NormalizedKeyStroke extends KeyStrokeInput
Core engine
  • property NormalizedKeyStroke.ctrl: boolean
  • property NormalizedKeyStroke.meta: boolean
  • property NormalizedKeyStroke.shift: boolean
  • property NormalizedKeyStroke.super: boolean
interface ParsedCommand
Core engine
  • property ParsedCommand.args: string[]
  • property ParsedCommand.input: string
  • property ParsedCommand.name: string
interface RawInputContext
Core engine
  • property RawInputContext.sequence: string
  • property RawInputContext.stop: () => void
interface RawInterceptOptions
Core engine
  • property RawInterceptOptions.priority?: number
interface ReactiveMatcher
Core engine
  • method ReactiveMatcher.get(): boolean
  • method ReactiveMatcher.subscribe(onChange: () => void): () => void
interface ResolvedKeyToken
Core engine
  • property ResolvedKeyToken.match: KeyMatch
  • property ResolvedKeyToken.stroke: NormalizedKeyStroke
interface ResolvedSequencePattern<TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method ResolvedSequencePattern.matcher(event: TEvent): SequencePatternMatch | undefined
  • property ResolvedSequencePattern.display?: string
  • property ResolvedSequencePattern.finalize?: (values: readonly unknown[]) => unknown
  • property ResolvedSequencePattern.match: KeyMatch
  • property ResolvedSequencePattern.max: number
  • property ResolvedSequencePattern.min: number
  • property ResolvedSequencePattern.name: string
  • property ResolvedSequencePattern.payloadKey: string
interface RunCommandOptions<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property RunCommandOptions.event?: TEvent
  • property RunCommandOptions.focused?: TTarget | null
  • property RunCommandOptions.includeCommand?: boolean
  • property RunCommandOptions.payload?: unknown
  • property RunCommandOptions.target?: TTarget | null
interface SequencePattern<TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • method SequencePattern.finalize?(values: readonly unknown[]): unknown
  • method SequencePattern.match(event: TEvent): SequencePatternMatch | undefined
  • property SequencePattern.display?: string
  • property SequencePattern.max?: number
  • property SequencePattern.min?: number
  • property SequencePattern.name: string
  • property SequencePattern.payloadKey?: string
interface SequencePatternMatch
Core engine
  • property SequencePatternMatch.display?: string
  • property SequencePatternMatch.value?: unknown
interface StringifyOptions
Core engine
  • property StringifyOptions.preferDisplay?: boolean
  • property StringifyOptions.separator?: string
interface WarningEvent
Core engine
  • property WarningEvent.code: string
  • property WarningEvent.message: string
  • property WarningEvent.warning: unknown

Types#

type Attributes = Record<string, unknown>
Core engine
type BindingCommand<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = string | CommandHandler<TTarget, TEvent>
Core engine
type BindingEvent = "press" | "release"
Core engine
type BindingExpander = (ctx: BindingExpanderContext) => readonly BindingExpansion[] | undefined
Core engine
type BindingFieldCompiler = (value: unknown, ctx: BindingFieldContext) => void
Core engine
type BindingParser = (ctx: BindingParserContext) => BindingParserResult | undefined
Core engine
type Bindings<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = readonly Binding<TTarget, TEvent>[]
Core engine
type BindingsValidationResult = { ok: true; } | { ok: false; reason: string; }
Core engine
type BindingTransformer<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (binding: ParsedBinding<TTarget, TEvent>, ctx: BindingTransformerContext<TTarget, TEvent>) => void
Core engine
type CommandFieldCompiler = (value: unknown, ctx: CommandFieldContext) => void
Core engine
type CommandFilter<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = Readonly<Record<string, CommandQueryValue<TTarget, TEvent>>> | ((command: Command<TTarget, TEvent>) => boolean)
Core engine
type CommandHandler<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent, TPayload = unknown> = (ctx: CommandContext<TTarget, TEvent, TPayload>) => CommandResult<TTarget, TEvent>
Core engine
type CommandQueryValue<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = unknown | readonly unknown[] | ((value: unknown, command: Command<TTarget, TEvent>) => boolean)
Core engine
type CommandResolver<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (command: string, ctx: CommandResolverContext<TTarget, TEvent>) => Command<TTarget, TEvent> | undefined
Core engine
type CommandResult<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = boolean | void | RunCommandResult<TTarget, TEvent> | Promise<boolean | void | RunCommandResult<TTarget, TEvent>>
Core engine
type CommandTransformer<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (command: Command<TTarget, TEvent>, ctx: CommandTransformerContext<TTarget, TEvent>) => void
Core engine
type DispatchPhase = "sequence-start" | "sequence-advance" | "sequence-clear" | "binding-execute" | "binding-reject"
Core engine
type EventData = Record<string, unknown>
Core engine
type EventMatchResolver<TEvent extends KeymapEvent = KeymapEvent> = (event: TEvent, ctx: EventMatchResolverContext) => readonly KeyMatch[] | undefined
Core engine
type EventName = keyof Events
Core engine
type Events<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = Hooks<TTarget, TEvent> & { warning: WarningEvent; error: ErrorEvent; }
Core engine
type HostCapability = "supported" | "unsupported" | "unknown"
Core engine
type HostModifier = "ctrl" | "shift" | "meta" | "super" | "hyper"
Core engine
type HostPlatform = "macos" | "windows" | "linux" | "unknown"
Core engine
type InterceptName = keyof Intercepts
Core engine
type Intercepts<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = { key: KeyInputContext<TEvent>; "key:after": KeyAfterInputContext<TTarget, TEvent>; raw: RawInputContext; }
Core engine
type KeyAfterReason = "intercept-consumed" | "binding-handled" | "binding-rejected" | "no-match" | "sequence-pending" | "sequence-miss" | "sequence-cleared"
Core engine
type KeyDeferredDisambiguationHandler<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (ctx: KeyDeferredDisambiguationContext<TTarget, TEvent>) => KeyDeferredDisambiguationDecision | void | Promise<KeyDeferredDisambiguationDecision | void>
Core engine
type KeyDisambiguationResolver<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (ctx: KeyDisambiguationContext<TTarget, TEvent>) => KeyDisambiguationDecision | undefined
Core engine
type KeyLike = string | KeyStrokeInput
Core engine
type KeyMatch = string
Core engine
type KeyStringifyInput = KeyStrokeInput | NormalizedKeyStroke | KeySequencePart | { stroke: NormalizedKeyStroke; display?: string; }
Core engine
type LayerAnalyzer<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (ctx: LayerAnalysisContext<TTarget, TEvent>) => void
Core engine
type LayerBindingsTransformer<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = (bindings: readonly Binding<TTarget, TEvent>[], ctx: LayerBindingsTransformerContext<TTarget, TEvent>) => readonly Binding<TTarget, TEvent>[] | void
Core engine
type LayerFieldCompiler = (value: unknown, ctx: LayerFieldContext) => void
Core engine
type Listener<TValue> = [ TValue ] extends [ void ] ? () => void : (value: TValue) => void
Core engine
type RunCommandResult<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = { ok: true; command?: Command<TTarget, TEvent>; } | { ok: false; reason: "not-found"; } | { ok: false; reason: "inactive" | "disabled" | "invalid-args" | "rejected" | "error"; command?: Command<TTarget, TEvent>; }
Core engine
type TargetMode = "focus" | "focus-within"
Core engine

Constants and variables#

const KEYMAP_EXTENSION_CONTEXT: unique symbol
Core engine

Namespaces and re-exports#

index Binding[key: string]: unknowninterface Binding<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property Binding.cmd?: BindingCommand<TTarget, TEvent>
  • property Binding.event?: BindingEvent
  • property Binding.fallthrough?: boolean
  • property Binding.key: KeyLike
  • property Binding.preventDefault?: boolean
index Command[key: string]: unknowninterface Command<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent, TPayload = unknown>
Core engine
  • method Command.run(ctx: CommandContext<TTarget, TEvent, TPayload>): CommandResult<TTarget, TEvent>
  • property Command.name: string
index Layer[key: string]: unknowninterface Layer<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property Layer.bindings?: Bindings<TTarget, TEvent>
  • property Layer.commands?: readonly Command<TTarget, TEvent, any>[]
  • property Layer.priority?: number
  • property Layer.target?: TTarget
  • property Layer.targetMode?: TargetMode
index ParsedBinding[key: string]: unknowninterface ParsedBinding<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>
Core engine
  • property ParsedBinding.cmd?: BindingCommand<TTarget, TEvent>
  • property ParsedBinding.event?: BindingEvent
  • property ParsedBinding.fallthrough?: boolean
  • property ParsedBinding.key: KeyLike
  • property ParsedBinding.preventDefault?: boolean
  • property ParsedBinding.sequence: KeySequencePart[]