@opentui/keymap 0.2.1 → 0.2.3

package/src/addons/universal/unresolved-commands.d.ts

@@ -1,4 +1,4 @@
-import type { Keymap, KeymapEvent } from "../../index.js";
+import type { Keymap, KeymapEvent } from "@opentui/keymap";
 /**
  * Warns when a string command name cannot be resolved by registered commands
  * or resolvers.

package/src/extras/binding-sections.d.ts

@@ -0,0 +1,18 @@
+import type { Binding, KeyLike, KeymapEvent } from "../types.js";
+export type BindingSectionItem<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = KeyLike | Binding<TTarget, TEvent>;
+export type BindingValue<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = false | "none" | BindingSectionItem<TTarget, TEvent> | readonly BindingSectionItem<TTarget, TEvent>[];
+export type BindingSectionConfig<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = Readonly<Record<string, BindingValue<TTarget, TEvent>>>;
+export type BindingSectionsConfig<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent> = Readonly<Record<string, BindingSectionConfig<TTarget, TEvent>>>;
+type LiteralStringKeys<T> = string extends Extract<keyof T, string> ? never : Extract<keyof T, string>;
+export interface ResolvedBindingSections<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent, TSection extends string = string> {
+    sections: Record<TSection, Binding<TTarget, TEvent>[]>;
+    get(section: string, cmd: string): readonly Binding<TTarget, TEvent>[] | undefined;
+}
+export interface ResolveBindingSectionsOptions<TSection extends string = string> {
+    sections?: readonly TSection[];
+}
+export declare function resolveBindingSections<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent, const TConfig extends BindingSectionsConfig<TTarget, TEvent> = BindingSectionsConfig<TTarget, TEvent>, const TSection extends string = string>(config: TConfig, options: ResolveBindingSectionsOptions<TSection> & {
+    sections: readonly TSection[];
+}): ResolvedBindingSections<TTarget, TEvent, TSection | LiteralStringKeys<TConfig>>;
+export declare function resolveBindingSections<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>(config: BindingSectionsConfig<TTarget, TEvent>, options?: ResolveBindingSectionsOptions): ResolvedBindingSections<TTarget, TEvent>;
+export {};

package/src/extras/command-bindings.d.ts

@@ -0,0 +1,19 @@
+import type { Binding, KeyLike, KeymapEvent } from "../types.js";
+export type CommandBindingMap = Record<string, KeyLike>;
+export interface CommandBindingsOverrideWarning {
+    code: "command-binding-override";
+    command: string;
+    previousKey: KeyLike;
+    nextKey: KeyLike;
+}
+export interface CommandBindingsError {
+    code: "invalid-command-binding";
+    command: string;
+    value: unknown;
+    reason: Error;
+}
+export interface CommandBindingsOptions {
+    onWarning?: (warning: CommandBindingsOverrideWarning) => void;
+    onError?: (error: CommandBindingsError) => void;
+}
+export declare function commandBindings<TTarget extends object = object, TEvent extends KeymapEvent = KeymapEvent>(bindings: Readonly<CommandBindingMap>, options?: CommandBindingsOptions): Binding<TTarget, TEvent>[];

package/src/extras/formatting.d.ts

@@ -0,0 +1,27 @@
+import type { KeySequencePart } from "../types.js";
+export type KeyModifierName = "ctrl" | "shift" | "meta" | "super" | "hyper";
+export interface KeySequenceFormatPart {
+    stroke: KeySequencePart["stroke"];
+    display: string;
+    match?: KeySequencePart["match"];
+    tokenName?: string;
+    patternName?: string;
+}
+export type TokenDisplayResolver = Readonly<Record<string, string>> | ((tokenName: string, part: KeySequenceFormatPart) => string | undefined);
+export type PatternDisplayResolver = Readonly<Record<string, string>> | ((patternName: string, part: KeySequenceFormatPart) => string | undefined);
+export interface FormatKeySequenceOptions {
+    tokenDisplay?: TokenDisplayResolver;
+    patternDisplay?: PatternDisplayResolver;
+    keyNameAliases?: Readonly<Record<string, string>>;
+    modifierAliases?: Partial<Record<KeyModifierName, string>>;
+    separator?: string;
+}
+export interface FormatCommandBindingsOptions extends FormatKeySequenceOptions {
+    bindingSeparator?: string;
+    dedupe?: boolean;
+}
+export interface SequenceBindingLike {
+    sequence: readonly KeySequenceFormatPart[];
+}
+export declare function formatKeySequence(parts: readonly KeySequenceFormatPart[] | undefined, options?: FormatKeySequenceOptions): string;
+export declare function formatCommandBindings(bindings: readonly SequenceBindingLike[] | undefined, options?: FormatCommandBindingsOptions): string | undefined;

package/src/extras/graph.d.ts

@@ -0,0 +1,9 @@
+import { type KeymapExtensionProvider } from "../services/extension-context.js";
+import type { KeymapEvent } from "../types.js";
+import type { GraphSnapshot, GraphSnapshotOptions } from "./lib/graph-types.js";
+export type { GraphBinding, GraphCommand, GraphInactiveReason, GraphLayer, GraphSequenceNode, GraphSnapshot, GraphSnapshotOptions, } from "./lib/graph-types.js";
+export interface KeymapGraphExtra<TTarget extends object, TEvent extends KeymapEvent> {
+    getGraphSnapshot(options?: GraphSnapshotOptions<TTarget>): GraphSnapshot<TTarget, TEvent>;
+}
+export declare function getGraphSnapshot<TTarget extends object, TEvent extends KeymapEvent>(keymap: KeymapExtensionProvider<TTarget, TEvent>, options?: GraphSnapshotOptions<TTarget>): GraphSnapshot<TTarget, TEvent>;
+export declare function createGraphExtra<TTarget extends object, TEvent extends KeymapEvent>(keymap: KeymapExtensionProvider<TTarget, TEvent>): KeymapGraphExtra<TTarget, TEvent>;

package/src/extras/graph.js

@@ -0,0 +1,373 @@
+// @bun
+import {
+  KEYMAP_EXTENSION_CONTEXT,
+  childNodes,
+  cloneKeySequence,
+  cloneKeyStroke,
+  getActivationPath,
+  getCaptureNode,
+  getFocusedTargetIfAvailable,
+  getNodePresentation,
+  getNodeSequence,
+  getSortedLayers,
+  isLayerActiveForFocused
+} from "../../chunks/index-frk6sdcd.js";
+
+// src/extras/lib/graph-snapshot.ts
+function hasOwnFocused(options) {
+  return !!options && Object.prototype.hasOwnProperty.call(options, "focused");
+}
+function layerId(layer) {
+  return `layer:${layer.order}`;
+}
+function bindingId(layer, index) {
+  return `binding:${layer.order}:${index}`;
+}
+function commandId(layer, index) {
+  return `command:${layer.order}:${index}`;
+}
+function nodeId(layer, index) {
+  return `node:${layer.order}:${index}`;
+}
+function getSequenceMatches(sequence) {
+  return sequence.map((part) => part.match);
+}
+function isPrefix(left, right) {
+  if (left.length > right.length) {
+    return false;
+  }
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function collectPendingNodes(pending, layerIds, nodeIds, roots) {
+  const pendingIds = new Set;
+  const pendingPathIds = new Set;
+  if (!pending) {
+    return { pending: pendingIds, pendingPath: pendingPathIds };
+  }
+  for (const capture of pending.captures) {
+    const layerGraphId = layerIds.get(capture.layer);
+    if (!layerGraphId) {
+      continue;
+    }
+    const root = roots.get(capture.layer);
+    if (!root) {
+      continue;
+    }
+    let current = getCaptureNode(root, capture) ?? null;
+    const capturedNodeId = current ? nodeIds.get(current) : undefined;
+    if (capturedNodeId) {
+      pendingIds.add(capturedNodeId);
+    }
+    while (current) {
+      const currentNodeId = nodeIds.get(current);
+      if (currentNodeId) {
+        pendingPathIds.add(currentNodeId);
+      }
+      current = current.parent;
+    }
+  }
+  return { pending: pendingIds, pendingPath: pendingPathIds };
+}
+function createGraphSnapshot(options) {
+  const { state, host, conditions, catalog, activation, snapshotOptions } = options;
+  const includeTargets = snapshotOptions?.includeTargets !== false;
+  const currentFocused = getFocusedTargetIfAvailable(host);
+  const focused = hasOwnFocused(snapshotOptions) ? snapshotOptions.focused ?? null : currentFocused;
+  const activeView = catalog.getActiveCommandView(focused);
+  const activeCommandStates = new Set(activeView.entries.map((entry) => entry.commandState));
+  const reachableCommandStates = new Set(activeView.reachable.map((entry) => entry.commandState));
+  const activationPath = getActivationPath(host, focused);
+  const sortedLayers = getSortedLayers(state.layers);
+  const layerStates = new Map;
+  const commandStates = new Map;
+  const bindingStates = new Map;
+  const commandIdsByCommand = new Map;
+  const commandIdsByName = new Map;
+  const nodeIds = new Map;
+  const layerIds = new Map;
+  const layerRoots = new Map;
+  const bindingNodeIds = new Map;
+  const sequenceNodes = [];
+  for (const layer of sortedLayers) {
+    layerRoots.set(layer, layer.root);
+  }
+  for (const layer of sortedLayers) {
+    const currentLayerId = layerId(layer);
+    const targetDestroyed = layer.target ? host.isTargetDestroyed(layer.target) : false;
+    const focusActive = isLayerActiveForFocused(host, layer, focused, activationPath);
+    const enabled = conditions.matchesConditions(layer);
+    const inactiveReasons = [];
+    if (targetDestroyed)
+      inactiveReasons.push("target-destroyed");
+    if (!focusActive)
+      inactiveReasons.push("focus");
+    if (!enabled)
+      inactiveReasons.push("layer-disabled");
+    layerIds.set(layer, currentLayerId);
+    layerStates.set(layer, {
+      layer,
+      id: currentLayerId,
+      focusActive,
+      enabled,
+      active: !targetDestroyed && focusActive && enabled,
+      inactiveReasons
+    });
+  }
+  for (const layer of sortedLayers) {
+    const currentLayerId = layerIds.get(layer);
+    for (const [index, command] of layer.commands.entries()) {
+      const currentCommandId = commandId(layer, index);
+      const idsByCommand = commandIdsByCommand.get(command.command);
+      if (idsByCommand) {
+        idsByCommand.push(currentCommandId);
+      } else {
+        commandIdsByCommand.set(command.command, [currentCommandId]);
+      }
+      const idsByName = commandIdsByName.get(command.command.name);
+      if (idsByName) {
+        idsByName.push(currentCommandId);
+      } else {
+        commandIdsByName.set(command.command.name, [currentCommandId]);
+      }
+      const layerState = layerStates.get(layer);
+      const enabled = conditions.matchesConditions(command);
+      const active = activeCommandStates.has(command);
+      const reachable = reachableCommandStates.has(command);
+      const inactiveReasons = [...layerState.inactiveReasons];
+      if (!enabled) {
+        inactiveReasons.push("command-disabled");
+      }
+      if (active && !reachable) {
+        inactiveReasons.push("shadowed");
+      }
+      commandStates.set(command, {
+        command,
+        id: currentCommandId,
+        layerState,
+        active,
+        reachable,
+        enabled,
+        inactiveReasons
+      });
+    }
+    let nextNodeIndex = 0;
+    const visitNode = (node, parentId) => {
+      const currentNodeId = nodeId(layer, nextNodeIndex);
+      nextNodeIndex += 1;
+      nodeIds.set(node, currentNodeId);
+      for (const binding of node.bindings) {
+        bindingNodeIds.set(binding, currentNodeId);
+      }
+      for (const child of childNodes(node)) {
+        visitNode(child, currentNodeId);
+      }
+    };
+    const root = layerRoots.get(layer);
+    visitNode(root, null);
+    if (!nodeIds.has(root)) {
+      nodeIds.set(root, `${currentLayerId}:root`);
+    }
+  }
+  const stoppedSequences = [];
+  for (const layer of sortedLayers) {
+    const layerState = layerStates.get(layer);
+    for (const [index, binding] of layer.bindings.entries()) {
+      const enabled = conditions.matchesConditions(binding);
+      const commandResolved = catalog.isBindingVisible(binding, focused, activeView);
+      const active = layerState.active && enabled && commandResolved;
+      const matches = getSequenceMatches(binding.sequence);
+      const shadowed = active && stoppedSequences.some((stop) => stop.event === binding.event && isPrefix(stop.matches, matches));
+      const inactiveReasons = [...layerState.inactiveReasons];
+      if (!enabled) {
+        inactiveReasons.push("binding-disabled");
+      }
+      if (!commandResolved) {
+        const unavailable = typeof binding.command === "string" ? catalog.getDispatchUnavailableCommandState(binding.command, focused, false) : undefined;
+        if (unavailable?.reason === "disabled") {
+          inactiveReasons.push("command-disabled");
+        } else if (unavailable?.reason === "inactive") {
+          inactiveReasons.push("command-inactive");
+        } else {
+          inactiveReasons.push("command-unresolved");
+        }
+      }
+      if (shadowed) {
+        inactiveReasons.push("shadowed");
+      }
+      const currentBindingState = {
+        binding,
+        id: bindingId(layer, index),
+        layerState,
+        commandIds: [],
+        enabled,
+        commandResolved,
+        active,
+        reachable: active && !shadowed,
+        shadowed,
+        inactiveReasons
+      };
+      bindingStates.set(binding, currentBindingState);
+      if (active && binding.command !== undefined && !binding.fallthrough) {
+        stoppedSequences.push({ event: binding.event, matches });
+      }
+    }
+  }
+  for (const state2 of bindingStates.values()) {
+    if (typeof state2.binding.command !== "string") {
+      continue;
+    }
+    const ids = new Set(commandIdsByName.get(state2.binding.command) ?? []);
+    const chain = catalog.getResolvedCommandChain(state2.binding.command, focused).entries;
+    for (const entry of chain ?? []) {
+      for (const id of commandIdsByCommand.get(entry.command) ?? []) {
+        ids.add(id);
+      }
+    }
+    state2.commandIds = [...ids];
+  }
+  const pending = focused === currentFocused ? activation.ensureValidPendingSequence() : undefined;
+  const pendingNodes = collectPendingNodes(pending ?? null, layerIds, nodeIds, layerRoots);
+  for (const layer of sortedLayers) {
+    const currentLayerId = layerIds.get(layer);
+    const visitNode = (node, parentId) => {
+      const currentNodeId = nodeIds.get(node);
+      const childIds = childNodes(node).map((child) => nodeIds.get(child)).filter(Boolean);
+      const bindingIds = node.bindings.map((binding) => bindingStates.get(binding)?.id).filter((id) => !!id);
+      const reachableBindingIds = node.reachableBindings.map((binding) => bindingStates.get(binding)?.id).filter((id) => !!id);
+      const sequence = getNodeSequence(node);
+      const presentation = getNodePresentation(node);
+      const active = node.reachableBindings.some((binding) => bindingStates.get(binding)?.active === true);
+      const reachable = node.reachableBindings.some((binding) => bindingStates.get(binding)?.reachable === true);
+      for (let index = 0;index < sequence.length; index += 1) {
+        const sourcePart = node.reachableBindings[0]?.sequence[index];
+        if (sourcePart) {
+          sequence[index] = { ...sourcePart, stroke: cloneKeyStroke(sourcePart.stroke) };
+        }
+      }
+      sequenceNodes.push({
+        id: currentNodeId,
+        layerId: currentLayerId,
+        parentId,
+        childIds,
+        bindingIds,
+        reachableBindingIds,
+        depth: node.depth,
+        sequence,
+        stroke: node.stroke ? cloneKeyStroke(node.stroke) : null,
+        match: node.match,
+        display: presentation.display,
+        tokenName: presentation.tokenName,
+        active,
+        reachable,
+        pending: pendingNodes.pending.has(currentNodeId),
+        pendingPath: pendingNodes.pendingPath.has(currentNodeId)
+      });
+      for (const child of childNodes(node)) {
+        visitNode(child, currentNodeId);
+      }
+    };
+    visitNode(layerRoots.get(layer), null);
+  }
+  const layers = sortedLayers.map((layer) => {
+    const state2 = layerStates.get(layer);
+    return {
+      id: state2.id,
+      order: layer.order,
+      priority: layer.priority,
+      target: includeTargets ? layer.target : undefined,
+      targetMode: layer.targetMode,
+      fields: layer.fields ?? {},
+      attrs: layer.attrs,
+      active: state2.active,
+      focusActive: state2.focusActive,
+      enabled: state2.enabled,
+      inactiveReasons: state2.inactiveReasons,
+      rootNodeId: nodeIds.get(layerRoots.get(layer)),
+      bindingIds: layer.bindings.map((binding) => bindingStates.get(binding).id),
+      commandIds: layer.commands.map((command) => commandStates.get(command).id)
+    };
+  });
+  const commands = [];
+  for (const state2 of commandStates.values()) {
+    commands.push({
+      id: state2.id,
+      layerId: state2.layerState.id,
+      name: state2.command.command.name,
+      command: state2.command.command,
+      fields: state2.command.fields,
+      attrs: state2.command.attrs,
+      target: includeTargets ? state2.layerState.layer.target : undefined,
+      active: state2.active,
+      reachable: state2.reachable,
+      enabled: state2.enabled,
+      inactiveReasons: state2.inactiveReasons
+    });
+  }
+  const bindings = [];
+  for (const state2 of bindingStates.values()) {
+    const binding = state2.binding;
+    bindings.push({
+      id: state2.id,
+      layerId: state2.layerState.id,
+      sourceLayerOrder: binding.sourceLayerOrder,
+      bindingIndex: binding.bindingIndex,
+      nodeId: bindingNodeIds.get(binding),
+      commandIds: state2.commandIds,
+      sequence: cloneKeySequence(binding.sequence),
+      command: binding.command,
+      commandAttrs: catalog.getBindingCommandAttrs(binding, focused, activeView),
+      attrs: binding.attrs,
+      event: binding.event,
+      preventDefault: binding.preventDefault,
+      fallthrough: binding.fallthrough,
+      active: state2.active,
+      reachable: state2.reachable,
+      enabled: state2.enabled,
+      commandResolved: state2.commandResolved,
+      shadowed: state2.shadowed,
+      inactiveReasons: state2.inactiveReasons
+    });
+  }
+  const activeKeys = activation.getActiveKeysForFocused(focused, { includeBindings: true, includeMetadata: true });
+  return {
+    focused: includeTargets ? focused : undefined,
+    pendingSequence: focused === currentFocused ? activation.getPendingSequence() : [],
+    activeKeys,
+    layers,
+    commands,
+    bindings,
+    sequenceNodes
+  };
+}
+
+// src/extras/graph.ts
+function getGraphSnapshot(keymap, options) {
+  const context = keymap[KEYMAP_EXTENSION_CONTEXT]();
+  return createGraphSnapshot({
+    state: context.state,
+    host: context.host,
+    conditions: context.conditions,
+    catalog: context.catalog,
+    activation: context.activation,
+    snapshotOptions: options
+  });
+}
+function createGraphExtra(keymap) {
+  return {
+    getGraphSnapshot(options) {
+      return getGraphSnapshot(keymap, options);
+    }
+  };
+}
+export {
+  getGraphSnapshot,
+  createGraphExtra
+};
+
+//# debugId=68A22ECA1358D66B64756E2164756E21
+//# sourceMappingURL=graph.js.map

package/src/extras/graph.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/extras/lib/graph-snapshot.ts", "../src/extras/graph.ts"],
+  "sourcesContent": [
+    "import type { ActivationService } from \"../../services/activation.js\"\nimport type { CommandCatalogService } from \"../../services/command-catalog.js\"\nimport type { ConditionService } from \"../../services/conditions.js\"\nimport type { State } from \"../../services/state.js\"\nimport type {\n  BindingState,\n  CommandState,\n  KeymapEvent,\n  KeymapHost,\n  KeySequencePart,\n  RegisteredLayer,\n  SequenceNode,\n} from \"../../types.js\"\nimport type {\n  GraphBinding,\n  GraphCommand,\n  GraphInactiveReason,\n  GraphLayer,\n  GraphSequenceNode,\n  GraphSnapshot,\n  GraphSnapshotOptions,\n} from \"./graph-types.js\"\nimport { cloneKeySequence, cloneKeyStroke } from \"../../services/keys.js\"\nimport {\n  getActivationPath,\n  getFocusedTargetIfAvailable,\n  getSortedLayers,\n  isLayerActiveForFocused,\n} from \"../../services/primitives/active-layers.js\"\nimport { childNodes, getCaptureNode, getNodePresentation, getNodeSequence } from \"../../services/sequence-index.js\"\n\ninterface LayerGraphState<TTarget extends object, TEvent extends KeymapEvent> {\n  layer: RegisteredLayer<TTarget, TEvent>\n  id: string\n  focusActive: boolean\n  enabled: boolean\n  active: boolean\n  inactiveReasons: GraphInactiveReason[]\n}\n\ninterface BindingGraphState<TTarget extends object, TEvent extends KeymapEvent> {\n  binding: BindingState<TTarget, TEvent>\n  id: string\n  layerState: LayerGraphState<TTarget, TEvent>\n  commandIds: string[]\n  enabled: boolean\n  commandResolved: boolean\n  active: boolean\n  reachable: boolean\n  shadowed: boolean\n  inactiveReasons: GraphInactiveReason[]\n}\n\ninterface CommandGraphState<TTarget extends object, TEvent extends KeymapEvent> {\n  command: CommandState<TTarget, TEvent>\n  id: string\n  layerState: LayerGraphState<TTarget, TEvent>\n  active: boolean\n  reachable: boolean\n  enabled: boolean\n  inactiveReasons: GraphInactiveReason[]\n}\n\ninterface SequenceStop {\n  event: string\n  matches: readonly string[]\n}\n\nfunction hasOwnFocused<TTarget extends object>(\n  options: GraphSnapshotOptions<TTarget> | undefined,\n): options is GraphSnapshotOptions<TTarget> & { focused: TTarget | null | undefined } {\n  return !!options && Object.prototype.hasOwnProperty.call(options, \"focused\")\n}\n\nfunction layerId<TTarget extends object, TEvent extends KeymapEvent>(layer: RegisteredLayer<TTarget, TEvent>): string {\n  return `layer:${layer.order}`\n}\n\nfunction bindingId<TTarget extends object, TEvent extends KeymapEvent>(\n  layer: RegisteredLayer<TTarget, TEvent>,\n  index: number,\n): string {\n  return `binding:${layer.order}:${index}`\n}\n\nfunction commandId<TTarget extends object, TEvent extends KeymapEvent>(\n  layer: RegisteredLayer<TTarget, TEvent>,\n  index: number,\n): string {\n  return `command:${layer.order}:${index}`\n}\n\nfunction nodeId<TTarget extends object, TEvent extends KeymapEvent>(\n  layer: RegisteredLayer<TTarget, TEvent>,\n  index: number,\n): string {\n  return `node:${layer.order}:${index}`\n}\n\nfunction getSequenceMatches(sequence: readonly KeySequencePart[]): string[] {\n  return sequence.map((part) => part.match)\n}\n\nfunction isPrefix(left: readonly string[], right: readonly string[]): boolean {\n  if (left.length > right.length) {\n    return false\n  }\n\n  for (let index = 0; index < left.length; index += 1) {\n    if (left[index] !== right[index]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nfunction collectPendingNodes<TTarget extends object, TEvent extends KeymapEvent>(\n  pending: State<TTarget, TEvent>[\"pending\"],\n  layerIds: ReadonlyMap<RegisteredLayer<TTarget, TEvent>, string>,\n  nodeIds: ReadonlyMap<SequenceNode<TTarget, TEvent>, string>,\n  roots: ReadonlyMap<RegisteredLayer<TTarget, TEvent>, SequenceNode<TTarget, TEvent>>,\n): { pending: Set<string>; pendingPath: Set<string> } {\n  const pendingIds = new Set<string>()\n  const pendingPathIds = new Set<string>()\n\n  if (!pending) {\n    return { pending: pendingIds, pendingPath: pendingPathIds }\n  }\n\n  for (const capture of pending.captures) {\n    const layerGraphId = layerIds.get(capture.layer)\n    if (!layerGraphId) {\n      continue\n    }\n\n    const root = roots.get(capture.layer)\n    if (!root) {\n      continue\n    }\n\n    let current: SequenceNode<TTarget, TEvent> | null = getCaptureNode(root, capture) ?? null\n    const capturedNodeId = current ? nodeIds.get(current) : undefined\n    if (capturedNodeId) {\n      pendingIds.add(capturedNodeId)\n    }\n\n    while (current) {\n      const currentNodeId = nodeIds.get(current)\n      if (currentNodeId) {\n        pendingPathIds.add(currentNodeId)\n      }\n      current = current.parent\n    }\n  }\n\n  return { pending: pendingIds, pendingPath: pendingPathIds }\n}\n\nexport function createGraphSnapshot<TTarget extends object, TEvent extends KeymapEvent>(options: {\n  state: State<TTarget, TEvent>\n  host: KeymapHost<TTarget, TEvent>\n  conditions: ConditionService<TTarget, TEvent>\n  catalog: CommandCatalogService<TTarget, TEvent>\n  activation: ActivationService<TTarget, TEvent>\n  snapshotOptions?: GraphSnapshotOptions<TTarget>\n}): GraphSnapshot<TTarget, TEvent> {\n  const { state, host, conditions, catalog, activation, snapshotOptions } = options\n  const includeTargets = snapshotOptions?.includeTargets !== false\n  const currentFocused = getFocusedTargetIfAvailable(host)\n  const focused = hasOwnFocused(snapshotOptions) ? (snapshotOptions.focused ?? null) : currentFocused\n  const activeView = catalog.getActiveCommandView(focused)\n  const activeCommandStates = new Set(activeView.entries.map((entry) => entry.commandState))\n  const reachableCommandStates = new Set(activeView.reachable.map((entry) => entry.commandState))\n  const activationPath = getActivationPath(host, focused)\n  const sortedLayers = getSortedLayers(state.layers)\n  const layerStates = new Map<RegisteredLayer<TTarget, TEvent>, LayerGraphState<TTarget, TEvent>>()\n  const commandStates = new Map<CommandState<TTarget, TEvent>, CommandGraphState<TTarget, TEvent>>()\n  const bindingStates = new Map<BindingState<TTarget, TEvent>, BindingGraphState<TTarget, TEvent>>()\n  const commandIdsByCommand = new Map<CommandState<TTarget, TEvent>[\"command\"], string[]>()\n  const commandIdsByName = new Map<string, string[]>()\n  const nodeIds = new Map<SequenceNode<TTarget, TEvent>, string>()\n  const layerIds = new Map<RegisteredLayer<TTarget, TEvent>, string>()\n  const layerRoots = new Map<RegisteredLayer<TTarget, TEvent>, SequenceNode<TTarget, TEvent>>()\n  const bindingNodeIds = new Map<BindingState<TTarget, TEvent>, string>()\n  const sequenceNodes: GraphSequenceNode[] = []\n\n  for (const layer of sortedLayers) {\n    layerRoots.set(layer, layer.root)\n  }\n\n  for (const layer of sortedLayers) {\n    const currentLayerId = layerId(layer)\n    const targetDestroyed = layer.target ? host.isTargetDestroyed(layer.target) : false\n    const focusActive = isLayerActiveForFocused(host, layer, focused, activationPath)\n    const enabled = conditions.matchesConditions(layer)\n    const inactiveReasons: GraphInactiveReason[] = []\n    if (targetDestroyed) inactiveReasons.push(\"target-destroyed\")\n    if (!focusActive) inactiveReasons.push(\"focus\")\n    if (!enabled) inactiveReasons.push(\"layer-disabled\")\n\n    layerIds.set(layer, currentLayerId)\n    layerStates.set(layer, {\n      layer,\n      id: currentLayerId,\n      focusActive,\n      enabled,\n      active: !targetDestroyed && focusActive && enabled,\n      inactiveReasons,\n    })\n  }\n\n  for (const layer of sortedLayers) {\n    const currentLayerId = layerIds.get(layer)!\n    for (const [index, command] of layer.commands.entries()) {\n      const currentCommandId = commandId(layer, index)\n      const idsByCommand = commandIdsByCommand.get(command.command)\n      if (idsByCommand) {\n        idsByCommand.push(currentCommandId)\n      } else {\n        commandIdsByCommand.set(command.command, [currentCommandId])\n      }\n\n      const idsByName = commandIdsByName.get(command.command.name)\n      if (idsByName) {\n        idsByName.push(currentCommandId)\n      } else {\n        commandIdsByName.set(command.command.name, [currentCommandId])\n      }\n\n      const layerState = layerStates.get(layer)!\n      const enabled = conditions.matchesConditions(command)\n      const active = activeCommandStates.has(command)\n      const reachable = reachableCommandStates.has(command)\n      const inactiveReasons = [...layerState.inactiveReasons]\n      if (!enabled) {\n        inactiveReasons.push(\"command-disabled\")\n      }\n      if (active && !reachable) {\n        inactiveReasons.push(\"shadowed\")\n      }\n      commandStates.set(command, {\n        command,\n        id: currentCommandId,\n        layerState,\n        active,\n        reachable,\n        enabled,\n        inactiveReasons,\n      })\n    }\n\n    let nextNodeIndex = 0\n    const visitNode = (node: SequenceNode<TTarget, TEvent>, parentId: string | null): void => {\n      const currentNodeId = nodeId(layer, nextNodeIndex)\n      nextNodeIndex += 1\n      nodeIds.set(node, currentNodeId)\n\n      for (const binding of node.bindings) {\n        bindingNodeIds.set(binding, currentNodeId)\n      }\n\n      for (const child of childNodes(node)) {\n        visitNode(child, currentNodeId)\n      }\n    }\n\n    const root = layerRoots.get(layer)!\n    visitNode(root, null)\n    if (!nodeIds.has(root)) {\n      nodeIds.set(root, `${currentLayerId}:root`)\n    }\n  }\n\n  const stoppedSequences: SequenceStop[] = []\n  for (const layer of sortedLayers) {\n    const layerState = layerStates.get(layer)!\n    for (const [index, binding] of layer.bindings.entries()) {\n      const enabled = conditions.matchesConditions(binding)\n      const commandResolved = catalog.isBindingVisible(binding, focused, activeView)\n      const active = layerState.active && enabled && commandResolved\n      const matches = getSequenceMatches(binding.sequence)\n      const shadowed =\n        active && stoppedSequences.some((stop) => stop.event === binding.event && isPrefix(stop.matches, matches))\n      const inactiveReasons = [...layerState.inactiveReasons]\n      if (!enabled) {\n        inactiveReasons.push(\"binding-disabled\")\n      }\n      if (!commandResolved) {\n        const unavailable =\n          typeof binding.command === \"string\"\n            ? catalog.getDispatchUnavailableCommandState(binding.command, focused, false)\n            : undefined\n        if (unavailable?.reason === \"disabled\") {\n          inactiveReasons.push(\"command-disabled\")\n        } else if (unavailable?.reason === \"inactive\") {\n          inactiveReasons.push(\"command-inactive\")\n        } else {\n          inactiveReasons.push(\"command-unresolved\")\n        }\n      }\n      if (shadowed) {\n        inactiveReasons.push(\"shadowed\")\n      }\n\n      const currentBindingState: BindingGraphState<TTarget, TEvent> = {\n        binding,\n        id: bindingId(layer, index),\n        layerState,\n        commandIds: [],\n        enabled,\n        commandResolved,\n        active,\n        reachable: active && !shadowed,\n        shadowed,\n        inactiveReasons,\n      }\n      bindingStates.set(binding, currentBindingState)\n\n      if (active && binding.command !== undefined && !binding.fallthrough) {\n        stoppedSequences.push({ event: binding.event, matches })\n      }\n    }\n  }\n\n  for (const state of bindingStates.values()) {\n    if (typeof state.binding.command !== \"string\") {\n      continue\n    }\n\n    const ids = new Set(commandIdsByName.get(state.binding.command) ?? [])\n    const chain = catalog.getResolvedCommandChain(state.binding.command, focused).entries\n    for (const entry of chain ?? []) {\n      for (const id of commandIdsByCommand.get(entry.command) ?? []) {\n        ids.add(id)\n      }\n    }\n    state.commandIds = [...ids]\n  }\n\n  const pending = focused === currentFocused ? activation.ensureValidPendingSequence() : undefined\n  const pendingNodes = collectPendingNodes(pending ?? null, layerIds, nodeIds, layerRoots)\n\n  for (const layer of sortedLayers) {\n    const currentLayerId = layerIds.get(layer)!\n    const visitNode = (node: SequenceNode<TTarget, TEvent>, parentId: string | null): void => {\n      const currentNodeId = nodeIds.get(node)!\n      const childIds = childNodes(node)\n        .map((child) => nodeIds.get(child)!)\n        .filter(Boolean)\n      const bindingIds = node.bindings\n        .map((binding) => bindingStates.get(binding)?.id)\n        .filter((id): id is string => !!id)\n      const reachableBindingIds = node.reachableBindings\n        .map((binding) => bindingStates.get(binding)?.id)\n        .filter((id): id is string => !!id)\n      const sequence = getNodeSequence(node)\n      const presentation = getNodePresentation(node)\n      const active = node.reachableBindings.some((binding) => bindingStates.get(binding)?.active === true)\n      const reachable = node.reachableBindings.some((binding) => bindingStates.get(binding)?.reachable === true)\n\n      for (let index = 0; index < sequence.length; index += 1) {\n        const sourcePart = node.reachableBindings[0]?.sequence[index]\n        if (sourcePart) {\n          sequence[index] = { ...sourcePart, stroke: cloneKeyStroke(sourcePart.stroke) }\n        }\n      }\n\n      sequenceNodes.push({\n        id: currentNodeId,\n        layerId: currentLayerId,\n        parentId,\n        childIds,\n        bindingIds,\n        reachableBindingIds,\n        depth: node.depth,\n        sequence,\n        stroke: node.stroke ? cloneKeyStroke(node.stroke) : null,\n        match: node.match,\n        display: presentation.display,\n        tokenName: presentation.tokenName,\n        active,\n        reachable,\n        pending: pendingNodes.pending.has(currentNodeId),\n        pendingPath: pendingNodes.pendingPath.has(currentNodeId),\n      })\n\n      for (const child of childNodes(node)) {\n        visitNode(child, currentNodeId)\n      }\n    }\n\n    visitNode(layerRoots.get(layer)!, null)\n  }\n\n  const layers: GraphLayer<TTarget>[] = sortedLayers.map((layer) => {\n    const state = layerStates.get(layer)!\n    return {\n      id: state.id,\n      order: layer.order,\n      priority: layer.priority,\n      target: includeTargets ? layer.target : undefined,\n      targetMode: layer.targetMode,\n      fields: layer.fields ?? {},\n      attrs: layer.attrs,\n      active: state.active,\n      focusActive: state.focusActive,\n      enabled: state.enabled,\n      inactiveReasons: state.inactiveReasons,\n      rootNodeId: nodeIds.get(layerRoots.get(layer)!)!,\n      bindingIds: layer.bindings.map((binding) => bindingStates.get(binding)!.id),\n      commandIds: layer.commands.map((command) => commandStates.get(command)!.id),\n    }\n  })\n\n  const commands: GraphCommand<TTarget, TEvent>[] = []\n  for (const state of commandStates.values()) {\n    commands.push({\n      id: state.id,\n      layerId: state.layerState.id,\n      name: state.command.command.name,\n      command: state.command.command,\n      fields: state.command.fields,\n      attrs: state.command.attrs,\n      target: includeTargets ? state.layerState.layer.target : undefined,\n      active: state.active,\n      reachable: state.reachable,\n      enabled: state.enabled,\n      inactiveReasons: state.inactiveReasons,\n    })\n  }\n\n  const bindings: GraphBinding<TTarget, TEvent>[] = []\n  for (const state of bindingStates.values()) {\n    const binding = state.binding\n    bindings.push({\n      id: state.id,\n      layerId: state.layerState.id,\n      sourceLayerOrder: binding.sourceLayerOrder,\n      bindingIndex: binding.bindingIndex,\n      nodeId: bindingNodeIds.get(binding),\n      commandIds: state.commandIds,\n      sequence: cloneKeySequence(binding.sequence),\n      command: binding.command,\n      commandAttrs: catalog.getBindingCommandAttrs(binding, focused, activeView),\n      attrs: binding.attrs,\n      event: binding.event,\n      preventDefault: binding.preventDefault,\n      fallthrough: binding.fallthrough,\n      active: state.active,\n      reachable: state.reachable,\n      enabled: state.enabled,\n      commandResolved: state.commandResolved,\n      shadowed: state.shadowed,\n      inactiveReasons: state.inactiveReasons,\n    })\n  }\n\n  const activeKeys = activation.getActiveKeysForFocused(focused, { includeBindings: true, includeMetadata: true })\n\n  return {\n    focused: includeTargets ? focused : undefined,\n    pendingSequence: focused === currentFocused ? activation.getPendingSequence() : [],\n    activeKeys,\n    layers,\n    commands,\n    bindings,\n    sequenceNodes,\n  }\n}\n",
+    "import { KEYMAP_EXTENSION_CONTEXT, type KeymapExtensionProvider } from \"../services/extension-context.js\"\nimport { createGraphSnapshot } from \"./lib/graph-snapshot.js\"\nimport type { KeymapEvent } from \"../types.js\"\nimport type { GraphSnapshot, GraphSnapshotOptions } from \"./lib/graph-types.js\"\n\nexport type {\n  GraphBinding,\n  GraphCommand,\n  GraphInactiveReason,\n  GraphLayer,\n  GraphSequenceNode,\n  GraphSnapshot,\n  GraphSnapshotOptions,\n} from \"./lib/graph-types.js\"\n\nexport interface KeymapGraphExtra<TTarget extends object, TEvent extends KeymapEvent> {\n  getGraphSnapshot(options?: GraphSnapshotOptions<TTarget>): GraphSnapshot<TTarget, TEvent>\n}\n\nexport function getGraphSnapshot<TTarget extends object, TEvent extends KeymapEvent>(\n  keymap: KeymapExtensionProvider<TTarget, TEvent>,\n  options?: GraphSnapshotOptions<TTarget>,\n): GraphSnapshot<TTarget, TEvent> {\n  const context = keymap[KEYMAP_EXTENSION_CONTEXT]()\n  return createGraphSnapshot({\n    state: context.state,\n    host: context.host,\n    conditions: context.conditions,\n    catalog: context.catalog,\n    activation: context.activation,\n    snapshotOptions: options,\n  })\n}\n\nexport function createGraphExtra<TTarget extends object, TEvent extends KeymapEvent>(\n  keymap: KeymapExtensionProvider<TTarget, TEvent>,\n): KeymapGraphExtra<TTarget, TEvent> {\n  return {\n    getGraphSnapshot(options) {\n      return getGraphSnapshot(keymap, options)\n    },\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "68A22ECA1358D66B64756E2164756E21",
+  "names": []
+}

package/src/extras/index.d.ts

@@ -0,0 +1,6 @@
+export { resolveBindingSections } from "./binding-sections.js";
+export { commandBindings } from "./command-bindings.js";
+export { formatCommandBindings, formatKeySequence } from "./formatting.js";
+export type { BindingSectionConfig, BindingSectionItem, BindingSectionsConfig, BindingValue, ResolveBindingSectionsOptions, ResolvedBindingSections, } from "./binding-sections.js";
+export type { FormatCommandBindingsOptions, FormatKeySequenceOptions, KeySequenceFormatPart, KeyModifierName, SequenceBindingLike, TokenDisplayResolver, } from "./formatting.js";
+export type { CommandBindingMap, CommandBindingsOptions, CommandBindingsOverrideWarning, CommandBindingsError, } from "./command-bindings.js";