@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/utils/keys/keybinding.d.ts

@@ -1,4 +1,5 @@
-import type { Chord, KeyEventLike } from './chord.js';
+import { Chord, KeyEventLike } from "./chord.js";
+//#region ../utils/src/keys/keybinding.d.ts
 /**
  * One item in a sheet row's key rail or subline, in a mini-grammar the renderer resolves:
  * - a bare chord (`'mod+KeyC'`, `'ArrowUp'`) — parsed and formatted into chips
@@ -8,33 +9,72 @@ import type { Chord, KeyEventLike } from './chord.js';
  * - `'sep:X'` — literal `X` as a muted separator glyph
  */
 export type SheetDisplayEntry = string;
+/** Whole localized prose with named key-chip groups; never passed to the keybinding parser. */
+export type SheetDisplayText = {
+  message: string;
+  keys: Readonly<Record<string, readonly SheetDisplayEntry[]>>;
+};
+/**
+ * Another binding this row also presents keys for — typically the `sheet: 'hidden'` partner of a
+ * "previous / next" pair, so overriding either half's keys still shows up here.
+ */
+export type SheetPartner = {
+  id: string;
+  /** Display entries for this partner when it is NOT overridden — defaults to its keys. */
+  keys?: readonly SheetDisplayEntry[];
+};
 export type SheetEntry = {
-    group: string;
-    label: string;
-    order?: number;
-    keysOverride?: readonly SheetDisplayEntry[];
-    /** Second line rendered under the label — same display grammar as `keysOverride`. */
-    subline?: readonly SheetDisplayEntry[];
+  group: string;
+  label: string;
+  order?: number;
+  /** The visible binding's OWN keys — a partner's keys are never included here, see `with`. */
+  keysOverride?: readonly SheetDisplayEntry[];
+  /** Second line rendered under the label, with optional whole-message localization. */
+  subline?: readonly SheetDisplayEntry[];
+  /** Whole localized subline; takes precedence over legacy display entries. */
+  sublineText?: SheetDisplayText;
+  with?: readonly SheetPartner[];
 };
 export type KeyBindingDescriptor<TScope extends string, TEvent extends KeyEventLike = KeyEventLike> = {
-    keys: readonly string[];
-    scope: TScope;
-    order?: number;
-    when?: readonly ((e: TEvent) => boolean)[];
-    run: (e: TEvent) => boolean;
-    sheet: SheetEntry | 'hidden';
+  /**
+   * Stable dotted identifier, e.g. `'rows.stepPrevious'` — the key overrides are keyed by this.
+   * Present only on customizable bindings (those a user could collide with or reasonably want to
+   * change); user overrides key on it and the sheet shows it. Absent = fixed widget key: never
+   * overridden, never disabled.
+   */
+  id?: string;
+  keys: readonly string[];
+  scope: TScope;
+  order?: number;
+  when?: readonly ((e: TEvent) => boolean)[];
+  /**
+   * `chordIndex` is the index into this binding's effective `keys`/`chords` of the chord that
+   * matched the event — e.g. for `keys: ['Digit1', …, 'Digit0']`, pressing `Digit3` runs with
+   * `chordIndex === 2`.
+   */
+  run: (e: TEvent, chordIndex: number) => boolean;
+  sheet: SheetEntry | 'hidden';
 };
 /** A registered binding: descriptor + parsed chords (parse once at registration). */
 export type KeyBinding<TScope extends string, TEvent extends KeyEventLike = KeyEventLike> = KeyBindingDescriptor<TScope, TEvent> & {
-    chords: readonly Chord[];
+  chords: readonly Chord[]; /** True when the effective keys came from an override. */
+  overridden: boolean;
 };
+/**
+ * User overrides keyed by binding id: a replacement key list, or `false` to disable. A key ending in
+ * `.*` matches every id with that prefix (e.g. `'panels.*'`); an exact id wins over a wildcard, and a
+ * longer wildcard wins over a shorter one. `'*'` matches everything. A wildcard can only disable — a
+ * wildcard entry with a non-empty key list is ignored (see {@link resolveOverride}); only an exact id
+ * can rebind.
+ */
+export type KeyBindingOverrides = Readonly<Record<string, readonly string[] | false>>;
 export type OverlayEntry = {
-    id: string;
-    /**
-     * Close the surface. Returns false to decline (surface decides it wasn't actually open/closable),
-     * letting resolution continue to the next overlay down, then the focus chain.
-     */
-    onClose: () => boolean;
+  id: string;
+  /**
+   * Close the surface. Returns false to decline (surface decides it wasn't actually open/closable),
+   * letting resolution continue to the next overlay down, then the focus chain.
+   */
+  onClose: () => boolean;
 };
 /**
  * Pure candidate selection: which bindings could handle this event, in resolution order —
@@ -48,6 +88,42 @@ export declare function resolveKeydown<TScope extends string, TEvent extends Key
  * first. The dispatcher calls onClose top-down until one returns true.
  */
 export declare function resolveOverlayClose(stack: readonly OverlayEntry[]): OverlayEntry[];
-/** Parses a descriptor's keys into chords, throwing on the first malformed key. */
-export declare function registerBinding<TScope extends string, TEvent extends KeyEventLike = KeyEventLike>(descriptor: KeyBindingDescriptor<TScope, TEvent>, isMac: boolean): KeyBinding<TScope, TEvent>;
+/**
+ * Resolves what a binding's effective keys should be given an override map: the replacement key
+ * list, `false` if disabled, or `undefined` if nothing in `overrides` applies. An exact id match
+ * always wins (and may rebind or disable); otherwise the longest matching `'<prefix>.*'` wildcard
+ * wins, with bare `'*'` (an empty prefix) matching everything as the fallback — but a wildcard can
+ * ONLY disable: a wildcard entry whose value is a non-empty key list is ignored entirely (it never
+ * becomes a candidate), falling through to the next matching wildcard, then `undefined`. An override
+ * value that is an empty array is treated the same as `false`.
+ */
+export declare function resolveOverride(id: string, overrides: KeyBindingOverrides | undefined): readonly string[] | false | undefined;
+/**
+ * True when every chord in `chords` that has `shift === false` has a twin elsewhere in the list
+ * identical in `token`/`matchOn`/`ctrl`/`alt`/`meta` with `shift === true` — e.g. `['ArrowUp',
+ * 'shift+ArrowUp']`. Chords with `shift === 'implicit'` (a single printable-character token, whose
+ * shifted form already encodes the shift state) are ignored, both as candidates needing a twin and
+ * as candidate twins.
+ */
+export declare function isShiftClosed(chords: readonly Chord[]): boolean;
+/** Appends a `shift: true` twin right after every `shift: false` chord in `chords`; chords with
+ *  `shift === true` or `'implicit'` pass through unchanged with no twin added. */
+export declare function withShiftTwins(chords: readonly Chord[]): Chord[];
+/**
+ * Parses a descriptor's keys into chords, applying `overrides` (keyed by {@link KeyBindingDescriptor.id})
+ * first. A binding with no `id` is fixed — it never consults `overrides` at all, so it can't be
+ * rebound or disabled (not even by a `'*'` wildcard). A disabled binding (`false`) is never
+ * registered — this returns `undefined` and the caller skips it. A malformed replacement chord is
+ * reported to `onWarn` (naming the id and the bad key) and the descriptor's default keys are used
+ * instead. Malformed default keys still throw, as before.
+ *
+ * When an override applies and the descriptor's DEFAULT chords are "Shift-closed" (see
+ * {@link isShiftClosed}) — e.g. `['ArrowUp', 'shift+ArrowUp']`, where Shift extends the selection
+ * along the same axis — every `shift: false` chord in the override gets a `shift: true` twin added
+ * to the parsed chords (see {@link withShiftTwins}), so rebinding the plain key preserves the
+ * Shift-extend variant. The displayed `keys` stay exactly what the user specified; only `chords`
+ * (used for matching) gain the twin.
+ */
+export declare function registerBinding<TScope extends string, TEvent extends KeyEventLike = KeyEventLike>(descriptor: KeyBindingDescriptor<TScope, TEvent>, isMac: boolean, overrides?: KeyBindingOverrides, onWarn?: (message: string) => void): KeyBinding<TScope, TEvent> | undefined;
+//#endregion
 //# sourceMappingURL=keybinding.d.ts.map

package/dist/utils/keys/keybinding.js

@@ -1,58 +1,156 @@
-import { matchesChord, parseChord } from './chord.js';
+import { matchesChord, parseChord } from "./chord.js";
+//#region ../utils/src/keys/keybinding.ts
 /**
- * Pure candidate selection: which bindings could handle this event, in resolution order —
- * scope chain innermost→outermost (chain[0] = innermost), `order` ascending within a scope
- * (undefined order sorts last), registration (array) order as the final tiebreak. Does NOT
- * evaluate `when` guards or call `run` — the dispatcher does that so scope guards can sit between.
- */
-export function resolveKeydown(bindings, scopeChain, e) {
-    const matches = [];
-    for (let i = 0; i < bindings.length; i++) {
-        const binding = bindings[i];
-        const scopeIndex = scopeChain.indexOf(binding.scope);
-        if (scopeIndex === -1)
-            continue;
-        if (!binding.chords.some(chord => matchesChord(chord, e)))
-            continue;
-        matches.push({ binding: binding, scopeIndex: scopeIndex, registrationIndex: i });
-    }
-    matches.sort((a, b) => {
-        if (a.scopeIndex !== b.scopeIndex)
-            return a.scopeIndex - b.scopeIndex;
-        const orderA = a.binding.order;
-        const orderB = b.binding.order;
-        if (orderA !== orderB) {
-            if (orderA == null)
-                return 1;
-            if (orderB == null)
-                return -1;
-            return orderA - orderB;
-        }
-        return a.registrationIndex - b.registrationIndex;
-    });
-    return matches.map(m => m.binding);
+* Pure candidate selection: which bindings could handle this event, in resolution order —
+* scope chain innermost→outermost (chain[0] = innermost), `order` ascending within a scope
+* (undefined order sorts last), registration (array) order as the final tiebreak. Does NOT
+* evaluate `when` guards or call `run` — the dispatcher does that so scope guards can sit between.
+*/
+function resolveKeydown(bindings, scopeChain, e) {
+	const matches = [];
+	for (let i = 0; i < bindings.length; i++) {
+		const binding = bindings[i];
+		const scopeIndex = scopeChain.indexOf(binding.scope);
+		if (scopeIndex === -1) continue;
+		if (!binding.chords.some((chord) => matchesChord(chord, e))) continue;
+		matches.push({
+			binding,
+			scopeIndex,
+			registrationIndex: i
+		});
+	}
+	matches.sort((a, b) => {
+		if (a.scopeIndex !== b.scopeIndex) return a.scopeIndex - b.scopeIndex;
+		const orderA = a.binding.order;
+		const orderB = b.binding.order;
+		if (orderA !== orderB) {
+			if (orderA == null) return 1;
+			if (orderB == null) return -1;
+			return orderA - orderB;
+		}
+		return a.registrationIndex - b.registrationIndex;
+	});
+	return matches.map((m) => m.binding);
 }
 /**
- * Pure overlay resolution for a close request (Esc): returns the entries to try, top of stack
- * first. The dispatcher calls onClose top-down until one returns true.
- */
-export function resolveOverlayClose(stack) {
-    return [...stack].reverse();
-}
-/** Parses a descriptor's keys into chords, throwing on the first malformed key. */
-export function registerBinding(descriptor, isMac) {
-    const chords = [];
-    for (const key of descriptor.keys) {
-        try {
-            chords.push(parseChord(key, isMac));
-        }
-        catch (ex) {
-            const reason = ex instanceof Error ? ex.message : String(ex);
-            throw new Error(`Invalid key binding for scope '${descriptor.scope}', key '${key}': ${reason}`, {
-                cause: ex,
-            });
-        }
-    }
-    return { ...descriptor, chords: chords };
+* Pure overlay resolution for a close request (Esc): returns the entries to try, top of stack
+* first. The dispatcher calls onClose top-down until one returns true.
+*/
+function resolveOverlayClose(stack) {
+	return [...stack].reverse();
 }
+/**
+* Resolves what a binding's effective keys should be given an override map: the replacement key
+* list, `false` if disabled, or `undefined` if nothing in `overrides` applies. An exact id match
+* always wins (and may rebind or disable); otherwise the longest matching `'<prefix>.*'` wildcard
+* wins, with bare `'*'` (an empty prefix) matching everything as the fallback — but a wildcard can
+* ONLY disable: a wildcard entry whose value is a non-empty key list is ignored entirely (it never
+* becomes a candidate), falling through to the next matching wildcard, then `undefined`. An override
+* value that is an empty array is treated the same as `false`.
+*/
+function resolveOverride(id, overrides) {
+	if (!overrides) return void 0;
+	if (Object.hasOwn(overrides, id)) return normalizeOverrideValue(overrides[id]);
+	let bestPrefixLength;
+	let bestValue;
+	for (const key of Object.keys(overrides)) {
+		let prefix;
+		if (key === "*") prefix = "";
+		else if (key.endsWith(".*")) {
+			prefix = key.slice(0, -2);
+			if (!id.startsWith(`${prefix}.`)) continue;
+		} else continue;
+		const raw = overrides[key];
+		if (raw !== false && raw.length > 0) continue;
+		if (bestPrefixLength === void 0 || prefix.length > bestPrefixLength) {
+			bestPrefixLength = prefix.length;
+			bestValue = normalizeOverrideValue(raw);
+		}
+	}
+	return bestValue;
+}
+function normalizeOverrideValue(value) {
+	return value === false || value.length === 0 ? false : value;
+}
+/**
+* True when every chord in `chords` that has `shift === false` has a twin elsewhere in the list
+* identical in `token`/`matchOn`/`ctrl`/`alt`/`meta` with `shift === true` — e.g. `['ArrowUp',
+* 'shift+ArrowUp']`. Chords with `shift === 'implicit'` (a single printable-character token, whose
+* shifted form already encodes the shift state) are ignored, both as candidates needing a twin and
+* as candidate twins.
+*/
+function isShiftClosed(chords) {
+	for (const chord of chords) {
+		if (chord.shift !== false) continue;
+		if (!chords.some((other) => other !== chord && other.shift === true && other.token === chord.token && other.matchOn === chord.matchOn && other.ctrl === chord.ctrl && other.alt === chord.alt && other.meta === chord.meta)) return false;
+	}
+	return true;
+}
+/** Appends a `shift: true` twin right after every `shift: false` chord in `chords`; chords with
+*  `shift === true` or `'implicit'` pass through unchanged with no twin added. */
+function withShiftTwins(chords) {
+	const result = [];
+	for (const chord of chords) {
+		result.push(chord);
+		if (chord.shift === false) result.push({
+			...chord,
+			shift: true
+		});
+	}
+	return result;
+}
+/** Parses a list of keys into chords, throwing on the first malformed key. */
+function parseKeys(keys, errorContext, isMac) {
+	const chords = [];
+	for (const key of keys) try {
+		chords.push(parseChord(key, isMac));
+	} catch (ex) {
+		const reason = ex instanceof Error ? ex.message : String(ex);
+		throw new Error(`${errorContext}, key '${key}': ${reason}`, { cause: ex });
+	}
+	return chords;
+}
+/**
+* Parses a descriptor's keys into chords, applying `overrides` (keyed by {@link KeyBindingDescriptor.id})
+* first. A binding with no `id` is fixed — it never consults `overrides` at all, so it can't be
+* rebound or disabled (not even by a `'*'` wildcard). A disabled binding (`false`) is never
+* registered — this returns `undefined` and the caller skips it. A malformed replacement chord is
+* reported to `onWarn` (naming the id and the bad key) and the descriptor's default keys are used
+* instead. Malformed default keys still throw, as before.
+*
+* When an override applies and the descriptor's DEFAULT chords are "Shift-closed" (see
+* {@link isShiftClosed}) — e.g. `['ArrowUp', 'shift+ArrowUp']`, where Shift extends the selection
+* along the same axis — every `shift: false` chord in the override gets a `shift: true` twin added
+* to the parsed chords (see {@link withShiftTwins}), so rebinding the plain key preserves the
+* Shift-extend variant. The displayed `keys` stay exactly what the user specified; only `chords`
+* (used for matching) gain the twin.
+*/
+function registerBinding(descriptor, isMac, overrides, onWarn) {
+	const defaultChords = parseKeys(descriptor.keys, `Invalid key binding for scope '${descriptor.scope}'`, isMac);
+	if (descriptor.id != null) {
+		const resolved = resolveOverride(descriptor.id, overrides);
+		if (resolved === false) return void 0;
+		if (resolved !== void 0) try {
+			let chords = parseKeys(resolved, `Invalid key override for id '${descriptor.id}'`, isMac);
+			if (isShiftClosed(defaultChords)) chords = withShiftTwins(chords);
+			return {
+				...descriptor,
+				keys: resolved,
+				chords,
+				overridden: true
+			};
+		} catch (ex) {
+			const reason = ex instanceof Error ? ex.message : String(ex);
+			onWarn?.(reason);
+		}
+	}
+	return {
+		...descriptor,
+		chords: defaultChords,
+		overridden: false
+	};
+}
+//#endregion
+export { isShiftClosed, registerBinding, resolveKeydown, resolveOverlayClose, resolveOverride, withShiftTwins };
+
 //# sourceMappingURL=keybinding.js.map

package/dist/utils/keys/keybinding.js.map

@@ -1 +1 @@
-{"version":3,"file":"keybinding.js","sourceRoot":"","sources":["../../../src/utils/keys/keybinding.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA6CtD;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAC7B,QAA+C,EAC/C,UAA6B,EAC7B,CAAe;IAEf,MAAM,OAAO,GAA6F,EAAE,CAAC;IAE7G,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAE5B,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACrD,IAAI,UAAU,KAAK,CAAC,CAAC;YAAE,SAAS;QAEhC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAAE,SAAS;QAEpE,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC,CAAC;IAClF,CAAC;IAED,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACrB,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU;YAAE,OAAO,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC;QAEtE,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAC/B,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;QAC/B,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACvB,IAAI,MAAM,IAAI,IAAI;gBAAE,OAAO,CAAC,CAAC;YAC7B,IAAI,MAAM,IAAI,IAAI;gBAAE,OAAO,CAAC,CAAC,CAAC;YAE9B,OAAO,MAAM,GAAG,MAAM,CAAC;QACxB,CAAC;QAED,OAAO,CAAC,CAAC,iBAAiB,GAAG,CAAC,CAAC,iBAAiB,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAA8B;IACjE,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;AAC7B,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,eAAe,CAC9B,UAAgD,EAChD,KAAc;IAEd,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,KAAK,MAAM,GAAG,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC;QACnC,IAAI,CAAC;YACJ,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;QACrC,CAAC;QAAC,OAAO,EAAE,EAAE,CAAC;YACb,MAAM,MAAM,GAAG,EAAE,YAAY,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAC7D,MAAM,IAAI,KAAK,CAAC,kCAAkC,UAAU,CAAC,KAAK,WAAW,GAAG,MAAM,MAAM,EAAE,EAAE;gBAC/F,KAAK,EAAE,EAAE;aACT,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;IAED,OAAO,EAAE,GAAG,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC1C,CAAC"}
+{"version":3,"file":"keybinding.js","names":[],"sources":["../../../../utils/src/keys/keybinding.ts"],"sourcesContent":["import type { Chord, KeyEventLike } from './chord.js';\nimport { matchesChord, parseChord } from './chord.js';\n\n/**\n * One item in a sheet row's key rail or subline, in a mini-grammar the renderer resolves:\n * - a bare chord (`'mod+KeyC'`, `'ArrowUp'`) — parsed and formatted into chips\n * - `'raw:X'` — literal `X` in a key chip\n * - `'mod:X'` — literal `X` in a modifier chip\n * - `'text:X'` — literal `X` as plain inline text, verbatim (leading/trailing spaces included)\n * - `'sep:X'` — literal `X` as a muted separator glyph\n */\nexport type SheetDisplayEntry = string;\n\n/** Whole localized prose with named key-chip groups; never passed to the keybinding parser. */\nexport type SheetDisplayText = {\n\tmessage: string;\n\tkeys: Readonly<Record<string, readonly SheetDisplayEntry[]>>;\n};\n\n/**\n * Another binding this row also presents keys for — typically the `sheet: 'hidden'` partner of a\n * \"previous / next\" pair, so overriding either half's keys still shows up here.\n */\nexport type SheetPartner = {\n\tid: string;\n\t/** Display entries for this partner when it is NOT overridden — defaults to its keys. */\n\tkeys?: readonly SheetDisplayEntry[];\n};\n\nexport type SheetEntry = {\n\tgroup: string;\n\tlabel: string;\n\torder?: number;\n\t/** The visible binding's OWN keys — a partner's keys are never included here, see `with`. */\n\tkeysOverride?: readonly SheetDisplayEntry[];\n\t/** Second line rendered under the label, with optional whole-message localization. */\n\tsubline?: readonly SheetDisplayEntry[];\n\t/** Whole localized subline; takes precedence over legacy display entries. */\n\tsublineText?: SheetDisplayText;\n\twith?: readonly SheetPartner[];\n};\n\nexport type KeyBindingDescriptor<TScope extends string, TEvent extends KeyEventLike = KeyEventLike> = {\n\t/**\n\t * Stable dotted identifier, e.g. `'rows.stepPrevious'` — the key overrides are keyed by this.\n\t * Present only on customizable bindings (those a user could collide with or reasonably want to\n\t * change); user overrides key on it and the sheet shows it. Absent = fixed widget key: never\n\t * overridden, never disabled.\n\t */\n\tid?: string;\n\tkeys: readonly string[];\n\tscope: TScope;\n\torder?: number;\n\twhen?: readonly ((e: TEvent) => boolean)[];\n\t/**\n\t * `chordIndex` is the index into this binding's effective `keys`/`chords` of the chord that\n\t * matched the event — e.g. for `keys: ['Digit1', …, 'Digit0']`, pressing `Digit3` runs with\n\t * `chordIndex === 2`.\n\t */\n\trun: (e: TEvent, chordIndex: number) => boolean;\n\tsheet: SheetEntry | 'hidden';\n};\n\n/** A registered binding: descriptor + parsed chords (parse once at registration). */\nexport type KeyBinding<TScope extends string, TEvent extends KeyEventLike = KeyEventLike> = KeyBindingDescriptor<\n\tTScope,\n\tTEvent\n> & { chords: readonly Chord[]; /** True when the effective keys came from an override. */ overridden: boolean };\n\n/**\n * User overrides keyed by binding id: a replacement key list, or `false` to disable. A key ending in\n * `.*` matches every id with that prefix (e.g. `'panels.*'`); an exact id wins over a wildcard, and a\n * longer wildcard wins over a shorter one. `'*'` matches everything. A wildcard can only disable — a\n * wildcard entry with a non-empty key list is ignored (see {@link resolveOverride}); only an exact id\n * can rebind.\n */\nexport type KeyBindingOverrides = Readonly<Record<string, readonly string[] | false>>;\n\nexport type OverlayEntry = {\n\tid: string;\n\t/**\n\t * Close the surface. Returns false to decline (surface decides it wasn't actually open/closable),\n\t * letting resolution continue to the next overlay down, then the focus chain.\n\t */\n\tonClose: () => boolean;\n};\n\n/**\n * Pure candidate selection: which bindings could handle this event, in resolution order —\n * scope chain innermost→outermost (chain[0] = innermost), `order` ascending within a scope\n * (undefined order sorts last), registration (array) order as the final tiebreak. Does NOT\n * evaluate `when` guards or call `run` — the dispatcher does that so scope guards can sit between.\n */\nexport function resolveKeydown<TScope extends string, TEvent extends KeyEventLike>(\n\tbindings: readonly KeyBinding<TScope, TEvent>[],\n\tscopeChain: readonly TScope[],\n\te: KeyEventLike,\n): KeyBinding<TScope, TEvent>[] {\n\tconst matches: { binding: KeyBinding<TScope, TEvent>; scopeIndex: number; registrationIndex: number }[] = [];\n\n\tfor (let i = 0; i < bindings.length; i++) {\n\t\tconst binding = bindings[i];\n\n\t\tconst scopeIndex = scopeChain.indexOf(binding.scope);\n\t\tif (scopeIndex === -1) continue;\n\n\t\tif (!binding.chords.some(chord => matchesChord(chord, e))) continue;\n\n\t\tmatches.push({ binding: binding, scopeIndex: scopeIndex, registrationIndex: i });\n\t}\n\n\tmatches.sort((a, b) => {\n\t\tif (a.scopeIndex !== b.scopeIndex) return a.scopeIndex - b.scopeIndex;\n\n\t\tconst orderA = a.binding.order;\n\t\tconst orderB = b.binding.order;\n\t\tif (orderA !== orderB) {\n\t\t\tif (orderA == null) return 1;\n\t\t\tif (orderB == null) return -1;\n\n\t\t\treturn orderA - orderB;\n\t\t}\n\n\t\treturn a.registrationIndex - b.registrationIndex;\n\t});\n\n\treturn matches.map(m => m.binding);\n}\n\n/**\n * Pure overlay resolution for a close request (Esc): returns the entries to try, top of stack\n * first. The dispatcher calls onClose top-down until one returns true.\n */\nexport function resolveOverlayClose(stack: readonly OverlayEntry[]): OverlayEntry[] {\n\treturn [...stack].reverse();\n}\n\n/**\n * Resolves what a binding's effective keys should be given an override map: the replacement key\n * list, `false` if disabled, or `undefined` if nothing in `overrides` applies. An exact id match\n * always wins (and may rebind or disable); otherwise the longest matching `'<prefix>.*'` wildcard\n * wins, with bare `'*'` (an empty prefix) matching everything as the fallback — but a wildcard can\n * ONLY disable: a wildcard entry whose value is a non-empty key list is ignored entirely (it never\n * becomes a candidate), falling through to the next matching wildcard, then `undefined`. An override\n * value that is an empty array is treated the same as `false`.\n */\nexport function resolveOverride(\n\tid: string,\n\toverrides: KeyBindingOverrides | undefined,\n): readonly string[] | false | undefined {\n\tif (!overrides) return undefined;\n\n\tif (Object.hasOwn(overrides, id)) return normalizeOverrideValue(overrides[id]);\n\n\tlet bestPrefixLength: number | undefined;\n\tlet bestValue: readonly string[] | false | undefined;\n\n\tfor (const key of Object.keys(overrides)) {\n\t\tlet prefix: string;\n\t\tif (key === '*') {\n\t\t\tprefix = '';\n\t\t} else if (key.endsWith('.*')) {\n\t\t\tprefix = key.slice(0, -2);\n\t\t\tif (!id.startsWith(`${prefix}.`)) continue;\n\t\t} else {\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst raw = overrides[key];\n\t\t// Wildcards can only disable — one with a non-empty key list can't rebind, so it's ignored.\n\t\tif (raw !== false && raw.length > 0) continue;\n\n\t\tif (bestPrefixLength === undefined || prefix.length > bestPrefixLength) {\n\t\t\tbestPrefixLength = prefix.length;\n\t\t\tbestValue = normalizeOverrideValue(raw);\n\t\t}\n\t}\n\n\treturn bestValue;\n}\n\nfunction normalizeOverrideValue(value: readonly string[] | false): readonly string[] | false {\n\treturn value === false || value.length === 0 ? false : value;\n}\n\n/**\n * True when every chord in `chords` that has `shift === false` has a twin elsewhere in the list\n * identical in `token`/`matchOn`/`ctrl`/`alt`/`meta` with `shift === true` — e.g. `['ArrowUp',\n * 'shift+ArrowUp']`. Chords with `shift === 'implicit'` (a single printable-character token, whose\n * shifted form already encodes the shift state) are ignored, both as candidates needing a twin and\n * as candidate twins.\n */\nexport function isShiftClosed(chords: readonly Chord[]): boolean {\n\tfor (const chord of chords) {\n\t\tif (chord.shift !== false) continue;\n\n\t\tconst hasTwin = chords.some(\n\t\t\tother =>\n\t\t\t\tother !== chord &&\n\t\t\t\tother.shift === true &&\n\t\t\t\tother.token === chord.token &&\n\t\t\t\tother.matchOn === chord.matchOn &&\n\t\t\t\tother.ctrl === chord.ctrl &&\n\t\t\t\tother.alt === chord.alt &&\n\t\t\t\tother.meta === chord.meta,\n\t\t);\n\t\tif (!hasTwin) return false;\n\t}\n\n\treturn true;\n}\n\n/** Appends a `shift: true` twin right after every `shift: false` chord in `chords`; chords with\n *  `shift === true` or `'implicit'` pass through unchanged with no twin added. */\nexport function withShiftTwins(chords: readonly Chord[]): Chord[] {\n\tconst result: Chord[] = [];\n\tfor (const chord of chords) {\n\t\tresult.push(chord);\n\t\tif (chord.shift === false) {\n\t\t\tresult.push({ ...chord, shift: true });\n\t\t}\n\t}\n\n\treturn result;\n}\n\n/** Parses a list of keys into chords, throwing on the first malformed key. */\nfunction parseKeys(keys: readonly string[], errorContext: string, isMac: boolean): Chord[] {\n\tconst chords: Chord[] = [];\n\n\tfor (const key of keys) {\n\t\ttry {\n\t\t\tchords.push(parseChord(key, isMac));\n\t\t} catch (ex) {\n\t\t\tconst reason = ex instanceof Error ? ex.message : String(ex);\n\t\t\tthrow new Error(`${errorContext}, key '${key}': ${reason}`, { cause: ex });\n\t\t}\n\t}\n\n\treturn chords;\n}\n\n/**\n * Parses a descriptor's keys into chords, applying `overrides` (keyed by {@link KeyBindingDescriptor.id})\n * first. A binding with no `id` is fixed — it never consults `overrides` at all, so it can't be\n * rebound or disabled (not even by a `'*'` wildcard). A disabled binding (`false`) is never\n * registered — this returns `undefined` and the caller skips it. A malformed replacement chord is\n * reported to `onWarn` (naming the id and the bad key) and the descriptor's default keys are used\n * instead. Malformed default keys still throw, as before.\n *\n * When an override applies and the descriptor's DEFAULT chords are \"Shift-closed\" (see\n * {@link isShiftClosed}) — e.g. `['ArrowUp', 'shift+ArrowUp']`, where Shift extends the selection\n * along the same axis — every `shift: false` chord in the override gets a `shift: true` twin added\n * to the parsed chords (see {@link withShiftTwins}), so rebinding the plain key preserves the\n * Shift-extend variant. The displayed `keys` stay exactly what the user specified; only `chords`\n * (used for matching) gain the twin.\n */\nexport function registerBinding<TScope extends string, TEvent extends KeyEventLike = KeyEventLike>(\n\tdescriptor: KeyBindingDescriptor<TScope, TEvent>,\n\tisMac: boolean,\n\toverrides?: KeyBindingOverrides,\n\tonWarn?: (message: string) => void,\n): KeyBinding<TScope, TEvent> | undefined {\n\t// Defaults are parsed first so malformed defaults still throw as before, and so an override can\n\t// inherit their Shift-closure.\n\tconst defaultChords = parseKeys(descriptor.keys, `Invalid key binding for scope '${descriptor.scope}'`, isMac);\n\n\tif (descriptor.id != null) {\n\t\tconst resolved = resolveOverride(descriptor.id, overrides);\n\n\t\tif (resolved === false) return undefined;\n\n\t\tif (resolved !== undefined) {\n\t\t\ttry {\n\t\t\t\tlet chords = parseKeys(resolved, `Invalid key override for id '${descriptor.id}'`, isMac);\n\t\t\t\tif (isShiftClosed(defaultChords)) {\n\t\t\t\t\tchords = withShiftTwins(chords);\n\t\t\t\t}\n\n\t\t\t\treturn { ...descriptor, keys: resolved, chords: chords, overridden: true };\n\t\t\t} catch (ex) {\n\t\t\t\tconst reason = ex instanceof Error ? ex.message : String(ex);\n\t\t\t\tonWarn?.(reason);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { ...descriptor, chords: defaultChords, overridden: false };\n}\n"],"mappings":"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"}

package/dist/utils/keys/keymapDispatcher.d.ts

@@ -0,0 +1,66 @@
+import { Disposable } from "../disposable.js";
+import { KeyBindingDescriptor, KeyBindingOverrides, OverlayEntry, SheetDisplayEntry, SheetDisplayText } from "./keybinding.js";
+//#region ../utils/src/keys/keymapDispatcher.d.ts
+/** Where a scope is "active": rooted at a specific element, or matched by a CSS selector against the
+ *  keydown's composed path. */
+export type ScopeRegistration = {
+  root: Element;
+} | {
+  selector: string;
+};
+/** A row for a rendered shortcut sheet — one binding's group/label/keys, in display form. */
+export type KeymapSheetRow = {
+  group: string;
+  label: string;
+  order?: number;
+  keys: readonly SheetDisplayEntry[];
+  subline?: readonly SheetDisplayEntry[];
+  /** Whole localized subline; takes precedence over legacy display entries. */
+  sublineText?: SheetDisplayText;
+  /** The row's own id (if any) followed by each contributing partner's id — for the row tooltip.
+   *  Absent (rather than empty) when the row has no ids at all — a fixed/residual row. */
+  ids?: readonly string[];
+};
+/** Owns a document-level keydown listener and dispatches it to registered bindings by scope, honoring
+ *  an overlay-close stack (Escape) ahead of any binding match. Framework-agnostic — consumers register
+ *  scopes/bindings/overlays and call {@link KeymapDispatcher.attach} once. */
+export declare class KeymapDispatcher<TScope extends string> {
+  private readonly isMac;
+  private readonly onWarn;
+  private readonly scopes;
+  private alwaysOrder;
+  /** Registered descriptor groups, in registration order — kept so bindings can be rebuilt whenever
+   *  a group is added/removed or the overrides change. */
+  private registrationGroups;
+  private overrides;
+  private bindings;
+  /** Every registered descriptor's outcome, `undefined` when disabled by an override — lets
+   *  {@link sheetEntries} walk descriptors in registration order (not just the survivors) so a
+   *  disabled owner's row can still surface via a registered `with` partner. */
+  private bindingByDescriptor;
+  private overlayStack;
+  private attached;
+  constructor(options: {
+    isMac: boolean;
+    onWarn?: (message: string) => void;
+  });
+  registerScope(id: TScope, registration: ScopeRegistration | 'always', guards?: readonly ((e: KeyboardEvent) => boolean)[]): Disposable;
+  registerBindings(descriptors: readonly KeyBindingDescriptor<TScope, KeyboardEvent>[]): Disposable;
+  /** Replaces the active override map and rebuilds the effective binding list. Cheap enough to call
+   *  on every config push. */
+  setOverrides(overrides: KeyBindingOverrides | undefined): void;
+  /** Wildcards can only disable (see `resolveOverride`) — warns once per offending wildcard key so
+   *  a user who tried to rebind via `'panels.*'`/`'*'` learns why it didn't take. */
+  private warnIgnoredWildcards;
+  private rebuildBindings;
+  /** Closes the topmost overlay willing to close, exactly as an Escape keydown would — for hosts whose
+   *  widgets consume Esc locally but still want the stack to outrank their own fallback action. */
+  closeTopOverlay(): boolean;
+  pushOverlay(entry: OverlayEntry): Disposable;
+  attach(): void;
+  dispose(): void;
+  sheetEntries(): readonly KeymapSheetRow[];
+  private readonly _onKeydown;
+}
+//#endregion
+//# sourceMappingURL=keymapDispatcher.d.ts.map

package/dist/utils/keys/keymapDispatcher.js

@@ -0,0 +1,187 @@
+import { createDisposable } from "../disposable.js";
+import { matchesChord } from "./chord.js";
+import { registerBinding, resolveKeydown, resolveOverlayClose } from "./keybinding.js";
+//#region ../utils/src/keys/keymapDispatcher.ts
+/** Owns a document-level keydown listener and dispatches it to registered bindings by scope, honoring
+*  an overlay-close stack (Escape) ahead of any binding match. Framework-agnostic — consumers register
+*  scopes/bindings/overlays and call {@link KeymapDispatcher.attach} once. */
+var KeymapDispatcher = class {
+	isMac;
+	onWarn;
+	scopes = /* @__PURE__ */ new Map();
+	alwaysOrder = [];
+	/** Registered descriptor groups, in registration order — kept so bindings can be rebuilt whenever
+	*  a group is added/removed or the overrides change. */
+	registrationGroups = [];
+	overrides;
+	bindings = [];
+	/** Every registered descriptor's outcome, `undefined` when disabled by an override — lets
+	*  {@link sheetEntries} walk descriptors in registration order (not just the survivors) so a
+	*  disabled owner's row can still surface via a registered `with` partner. */
+	bindingByDescriptor = /* @__PURE__ */ new Map();
+	overlayStack = [];
+	attached = false;
+	constructor(options) {
+		this.isMac = options.isMac;
+		this.onWarn = options.onWarn;
+	}
+	registerScope(id, registration, guards = []) {
+		const entry = {
+			registration,
+			guards
+		};
+		this.scopes.set(id, entry);
+		if (registration === "always") this.alwaysOrder.push(id);
+		return createDisposable(() => {
+			if (this.scopes.get(id) === entry) this.scopes.delete(id);
+			this.alwaysOrder = this.alwaysOrder.filter((scopeId) => scopeId !== id);
+		});
+	}
+	registerBindings(descriptors) {
+		this.registrationGroups.push(descriptors);
+		this.rebuildBindings();
+		return createDisposable(() => {
+			const index = this.registrationGroups.indexOf(descriptors);
+			if (index === -1) return;
+			this.registrationGroups.splice(index, 1);
+			this.rebuildBindings();
+		});
+	}
+	/** Replaces the active override map and rebuilds the effective binding list. Cheap enough to call
+	*  on every config push. */
+	setOverrides(overrides) {
+		this.overrides = overrides;
+		this.warnIgnoredWildcards(overrides);
+		this.rebuildBindings();
+	}
+	/** Wildcards can only disable (see `resolveOverride`) — warns once per offending wildcard key so
+	*  a user who tried to rebind via `'panels.*'`/`'*'` learns why it didn't take. */
+	warnIgnoredWildcards(overrides) {
+		if (!overrides || this.onWarn == null) return;
+		for (const key of Object.keys(overrides)) {
+			if (key !== "*" && !key.endsWith(".*")) continue;
+			const value = overrides[key];
+			if (value === false || value.length === 0) continue;
+			this.onWarn(`Ignoring shortcut override '${key}': a wildcard can only disable (false), not rebind`);
+		}
+	}
+	rebuildBindings() {
+		const bindings = [];
+		const byDescriptor = /* @__PURE__ */ new Map();
+		for (const group of this.registrationGroups) for (const descriptor of group) {
+			const binding = registerBinding(descriptor, this.isMac, this.overrides, this.onWarn);
+			byDescriptor.set(descriptor, binding);
+			if (binding == null) continue;
+			bindings.push(binding);
+		}
+		this.bindings = bindings;
+		this.bindingByDescriptor = byDescriptor;
+	}
+	/** Closes the topmost overlay willing to close, exactly as an Escape keydown would — for hosts whose
+	*  widgets consume Esc locally but still want the stack to outrank their own fallback action. */
+	closeTopOverlay() {
+		const candidates = resolveOverlayClose(this.overlayStack);
+		for (const entry of candidates) {
+			if (!entry.onClose()) continue;
+			const index = this.overlayStack.indexOf(entry);
+			if (index !== -1) this.overlayStack.splice(index, 1);
+			return true;
+		}
+		return false;
+	}
+	pushOverlay(entry) {
+		this.overlayStack.push(entry);
+		return createDisposable(() => {
+			const index = this.overlayStack.indexOf(entry);
+			if (index === -1) return;
+			this.overlayStack.splice(index, 1);
+		});
+	}
+	attach() {
+		if (this.attached) return;
+		document.addEventListener("keydown", this._onKeydown, false);
+		this.attached = true;
+	}
+	dispose() {
+		if (this.attached) {
+			document.removeEventListener("keydown", this._onKeydown, false);
+			this.attached = false;
+		}
+		this.scopes.clear();
+		this.alwaysOrder = [];
+		this.registrationGroups = [];
+		this.overrides = void 0;
+		this.bindings = [];
+		this.bindingByDescriptor = /* @__PURE__ */ new Map();
+		this.overlayStack = [];
+	}
+	sheetEntries() {
+		const byId = /* @__PURE__ */ new Map();
+		for (const binding of this.bindings) {
+			if (binding.id == null) continue;
+			byId.set(binding.id, binding);
+		}
+		const partnerSegment = (partnerBinding, partner) => partnerBinding.overridden ? partnerBinding.keys : partner.keys ?? partnerBinding.keys;
+		const rows = [];
+		for (const group of this.registrationGroups) for (const descriptor of group) {
+			if (descriptor.sheet === "hidden") continue;
+			const sheet = descriptor.sheet;
+			const binding = this.bindingByDescriptor.get(descriptor);
+			const keys = [];
+			const ids = [];
+			if (binding != null) {
+				const self = binding.overridden ? binding.keys : sheet.keysOverride ?? binding.keys;
+				keys.push(...self);
+				if (binding.id != null) ids.push(binding.id);
+			}
+			for (const partner of sheet.with ?? []) {
+				const partnerBinding = byId.get(partner.id);
+				if (partnerBinding == null) continue;
+				if (keys.length > 0) keys.push("sep:/");
+				keys.push(...partnerSegment(partnerBinding, partner));
+				ids.push(partner.id);
+			}
+			if (binding == null && ids.length === 0) continue;
+			rows.push({
+				group: sheet.group,
+				label: sheet.label,
+				order: sheet.order,
+				keys,
+				subline: sheet.subline,
+				sublineText: sheet.sublineText,
+				ids: ids.length > 0 ? ids : void 0
+			});
+		}
+		return rows;
+	}
+	_onKeydown = (e) => {
+		if (e.defaultPrevented) return;
+		if (e.key === "Escape" && this.overlayStack.length > 0 && this.closeTopOverlay()) {
+			e.preventDefault();
+			e.stopPropagation();
+			return;
+		}
+		const chain = [];
+		for (const element of e.composedPath()) for (const [id, entry] of this.scopes) {
+			if (entry.registration === "always") continue;
+			if (chain.includes(id)) continue;
+			const registration = entry.registration;
+			if ("root" in registration && registration.root === element || "selector" in registration && element instanceof Element && element.matches(registration.selector)) chain.push(id);
+		}
+		for (const id of this.alwaysOrder) if (!chain.includes(id)) chain.push(id);
+		const candidates = resolveKeydown(this.bindings, chain, e);
+		for (const candidate of candidates) {
+			if ((this.scopes.get(candidate.scope)?.guards ?? []).some((guard) => !guard(e))) continue;
+			if (candidate.when?.some((when) => !when(e))) continue;
+			const chordIndex = candidate.chords.findIndex((chord) => matchesChord(chord, e));
+			if (!candidate.run(e, chordIndex)) continue;
+			e.preventDefault();
+			e.stopPropagation();
+			return;
+		}
+	};
+};
+//#endregion
+export { KeymapDispatcher };
+
+//# sourceMappingURL=keymapDispatcher.js.map