10827429861

Committed 12 Sep 2024 08:48AM UTC coverage: 98.007% (+0.02%) from 97.986%

Build # 10827429861

Build Type

push

github

Committed by

web-flow

Commit Message

refactor: Key bindings controller (#1358)

* Updated implementation to utilize a map for handling registered key combinations.
* Accordion: Eliminated keyboard handler workarounds.
* Implemented additional tests.

Run Details

3533 of 3728 branches covered (94.77%)

Branch coverage included in aggregate %.

65 of 66 new or added lines in 2 files covered. (98.48%)

1 existing line in 1 file now uncovered.

22430 of 22763 relevant lines covered (98.54%)

428.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.59

/src/components/common/controllers/key-bindings.ts

import type { ReactiveController, ReactiveControllerHost } from 'lit';
import type { Ref } from 'lit/directives/ref.js';

import { findElementFromEventPath } from '../util.js';

/* Common keys */
export const arrowLeft = 'ArrowLeft' as const;
export const arrowRight = 'ArrowRight' as const;
export const arrowUp = 'ArrowUp' as const;
export const arrowDown = 'ArrowDown' as const;
export const enterKey = 'Enter' as const;
export const spaceBar = ' ' as const;
export const escapeKey = 'Escape' as const;
export const homeKey = 'Home' as const;
export const endKey = 'End' as const;
export const pageUpKey = 'PageUp' as const;
export const pageDownKey = 'PageDown' as const;
export const tabKey = 'Tab' as const;

/* Modifiers */
export const altKey = 'Alt' as const;
export const ctrlKey = 'Ctrl' as const;
export const metaKey = 'Meta' as const;
export const shiftKey = 'Shift' as const;

/* Types */
export type KeyBindingHandler = (event: KeyboardEvent) => void;
export type KeyBindingObserverCleanup = { unsubscribe: () => void };

/**
 * Whether the current event should be ignored by the controller.
 *
 * @param node - The event target
 * @param event - The event object
 *
 * When `true` is returned, the current event is ignored.
 */
export type KeyBindingSkipCallback = (
  node: Element,
  event: KeyboardEvent
) => boolean;

/**
 * The event type which will trigger the bound handler.
 *
 * @remarks
 * `keydownRepeat` is similar to `keydown` with the exception
 * that after the handler is invoked the pressed state of the key is reset
 * in the controller.
 */
export type KeyBindingTrigger = 'keydown' | 'keyup' | 'keydownRepeat';

/**
 * Configuration object for the controller.
 * @ignore
 */
export interface KeyBindingControllerOptions {
  /**
   * By default, the controller listens for keypress events in the context of the host element.
   * If you pass a `ref`, you can limit the observation to a certain DOM part of the host scope.
   */
  ref?: Ref;
  /**
   * Option to ignore key press events.
   *
   * If passed an array of CSS selectors, it will ignore key presses originating from elements in the event composed path
   * that match one of the selectors.
   * Otherwise you can pass a {@link KeyBindingSkipCallback} function.
   *
   * Defaults to `['input', 'textarea', 'select']`.
   *
   * @example
   * ```ts
   * {
   *  // Skip events originating from elements with `readonly` attribute
   *  skip: ['[readonly]']
   * }
   * ...
   * {
   * // Same as above but with a callback
   *  skip: (node: Element) => node.hasAttribute('readonly')
   * }
   * ```
   */
  skip?: string[] | KeyBindingSkipCallback;
  /**
   * A set of KeyBindingOptions configuration which is applied to every handler
   * that is added to the controller.
   *
   * Any additional KeyBindingOptions values passed when `set` is called
   * will be merged with `bindingDefaults`.
   */
  bindingDefaults?: KeyBindingOptions;
}

/**
 * Configuration object for customizing the behavior of
 * the registered handler.
 */
export interface KeyBindingOptions {
  /**
   * The event type(s) on which the handler will be invoked.
   *
   * Defaults to `keydown` if not set.
   */
  triggers?: KeyBindingTrigger[];
  /**
   * Whether to call `preventDefault` on the target event before the handler is invoked.
   */
  preventDefault?: boolean;
  /**
   * Whether to call `stopPropagation` on the target event before the handler is invoked.
   */
  stopPropagation?: boolean;
}

interface KeyBinding {
  keys: string[];
  handler: KeyBindingHandler;
  options?: KeyBindingOptions;
  modifiers?: string[];
}

const Modifiers: Map<string, string> = new Map(
  [altKey, ctrlKey, metaKey, shiftKey].map((key) => {
    const mod = key.toLowerCase();
    return key === ctrlKey ? ['control', mod] : [mod, mod];
  })
);

const defaultOptions: KeyBindingControllerOptions = {
  skip: ['input', 'textarea', 'select'],
};

function normalizeKeys(keys: string | string[]) {
  return (Array.isArray(keys) ? keys : [keys]).map((key) => key.toLowerCase());
}

function isKeydown(event: Event) {
  return event.type === 'keydown';
}

function isKeyup(event: Event) {
  return event.type === 'keyup';
}

function isKeydownTrigger(triggers?: KeyBindingTrigger[]) {
  return triggers
    ? triggers.includes('keydown') || isKeydownRepeatTrigger(triggers)
    : false;
}

function isKeyupTrigger(triggers?: KeyBindingTrigger[]) {
  return triggers ? triggers.includes('keyup') : false;
}

function isKeydownRepeatTrigger(triggers?: KeyBindingTrigger[]) {
  return triggers ? triggers.includes('keydownRepeat') : false;
}

export function parseKeys(keys: string | string[]) {
  const parsed = normalizeKeys(keys);
  return {
    keys: parsed.filter((key) => !Modifiers.has(key)),
    modifiers: parsed.filter((key) => Modifiers.has(key)),
  };
}

function createCombinationKey(keys: string[], modifiers: string[]) {
  return Array.from(Modifiers.values())
    .filter((mod) => modifiers.includes(mod))
    .concat(keys)
    .join('+');
}

class KeyBindingController implements ReactiveController {
  protected _host: ReactiveControllerHost & Element;
  protected _ref?: Ref;
  protected _observedElement?: Element;
  protected _options?: KeyBindingControllerOptions;
  private bindings = new Map<string, KeyBinding>();
  private pressedKeys = new Set<string>();

  protected get _element() {
    if (this._observedElement) {
      return this._observedElement;
    }
    return this._ref ? this._ref.value : this._host;
  }

  /**
   * Sets the controller to listen for keyboard events on an arbitrary `element` in the page context.
   * All the configuration and event handlers are applied as well.
   *
   * Returns an object with an `unsubscribe` function which should be called when the observing of keyboard
   * events on the `element` should cease.
   */
  public observeElement(element: Element): KeyBindingObserverCleanup {
    element.addEventListener('keydown', this);
    element.addEventListener('keyup', this);
    this._observedElement = element;

    return {
      unsubscribe: () => {
        this._observedElement?.removeEventListener('keydown', this);
        this._observedElement?.removeEventListener('keyup', this);
        this._observedElement = undefined;
      },
    };
  }

  constructor(
    host: ReactiveControllerHost & Element,
    options?: KeyBindingControllerOptions
  ) {
    this._host = host;
    this._ref = options?.ref;
    this._options = { ...defaultOptions, ...options };
    host.addController(this);
  }

  /**
   * Checks and executes any event modifiers that are present in the matched binding.
   */
  private eventModifiersMatch(binding: KeyBinding, event: KeyboardEvent) {
    if (binding.options?.preventDefault) {
      event.preventDefault();
    }

    if (binding.options?.stopPropagation) {
      event.stopPropagation();
    }
  }

  private bindingMatches(binding: KeyBinding, event: KeyboardEvent) {
    const triggers = binding.options?.triggers ?? ['keydown'];

    if (isKeydown(event) && isKeydownTrigger(triggers)) {
      return true;
    }

    if (isKeyup(event) && isKeyupTrigger(triggers)) {
      return true;
    }

    return false;
  }

  private shouldSkip(event: KeyboardEvent) {
    const skip = this._options?.skip;

    if (!findElementFromEventPath((e) => e === this._element, event)) {
      return true;
    }

    if (!skip) {
      return false;
    }

    return Array.isArray(skip)
      ? findElementFromEventPath(skip.join(), event)
      : skip.call(this._host, event.target as Element, event);
  }

  public handleEvent(event: KeyboardEvent) {
    if (this.shouldSkip(event)) {
      return;
    }

    const key = event.key.toLowerCase();
    Modifiers.has(key) ? this.pressedKeys.clear() : this.pressedKeys.add(key);

    const pendingKeys = Array.from(this.pressedKeys);
    const modifiers = Array.from(Modifiers.values()).filter(
      (mod) => event[`${mod}Key` as keyof KeyboardEvent]
    );

    const binding = this.bindings.get(
      createCombinationKey(pendingKeys, modifiers)
    );

    if (binding && this.bindingMatches(binding, event)) {
      this.eventModifiersMatch(binding, event);
      binding.handler.call(this._host, event);

      if (isKeydownRepeatTrigger(binding.options?.triggers)) {
        this.pressedKeys.delete(key);
      }
    }

    if (isKeyup(event) && !Modifiers.has(key)) {
      this.pressedKeys.delete(key);
    }
  }

  /**
   * Registers a keybinding handler.
   */
  public set(
    key: string | string[],
    handler: KeyBindingHandler,
    options?: KeyBindingOptions
  ) {
    const { keys, modifiers } = parseKeys(key);
    const combination = createCombinationKey(keys, modifiers);
    const _options = { ...this._options?.bindingDefaults, ...options };

    this.bindings.set(combination, {
      keys,
      handler,
      options: _options,
      modifiers,
    });

    return this;
  }

  /**
   * Register a handler function which is called when the target receives a key
   * which "activates" it.
   *
   * In the browser context this is usually either an Enter and/or Space keypress.
   */
  public setActivateHandler(
    handler: KeyBindingHandler,
    options?: KeyBindingOptions
  ) {
    for (const key of [enterKey, spaceBar]) {
      this.set(key, handler, options);
    }

    return this;
  }

  public hostConnected(): void {
    this._host.addEventListener('keyup', this);
    this._host.addEventListener('keydown', this);
  }

  public hostDisconnected(): void {
    this._host.removeEventListener('keyup', this);
    this._host.removeEventListener('keydown', this);
  }
}

/**
 * Creates a keybinding controller and adds to it to the passed `element`
 * with the provided `options`.
 */
export function addKeybindings(
  element: ReactiveControllerHost & Element,
  options?: KeyBindingControllerOptions
) {
  return new KeyBindingController(element, options);
}

1	import type { ReactiveController, ReactiveControllerHost } from 'lit';	43✔
2	import type { Ref } from 'lit/directives/ref.js';	43✔
3		43✔
4	import { findElementFromEventPath } from '../util.js';	43✔
5		43✔
6	/* Common keys */	43✔
7	export const arrowLeft = 'ArrowLeft' as const;	43✔
8	export const arrowRight = 'ArrowRight' as const;	43✔
9	export const arrowUp = 'ArrowUp' as const;	43✔
10	export const arrowDown = 'ArrowDown' as const;	43✔
11	export const enterKey = 'Enter' as const;	43✔
12	export const spaceBar = ' ' as const;	43✔
13	export const escapeKey = 'Escape' as const;	43✔
14	export const homeKey = 'Home' as const;	43✔
15	export const endKey = 'End' as const;	43✔
16	export const pageUpKey = 'PageUp' as const;	43✔
17	export const pageDownKey = 'PageDown' as const;	43✔
18	export const tabKey = 'Tab' as const;	43✔
19		43✔
20	/* Modifiers */	43✔
21	export const altKey = 'Alt' as const;	43✔
22	export const ctrlKey = 'Ctrl' as const;	43✔
23	export const metaKey = 'Meta' as const;	43✔
24	export const shiftKey = 'Shift' as const;	43✔
25		43✔
26	/* Types */	43✔
27	export type KeyBindingHandler = (event: KeyboardEvent) => void;	43✔
28	export type KeyBindingObserverCleanup = { unsubscribe: () => void };	43✔
29		43✔
30	/**	43✔
31	* Whether the current event should be ignored by the controller.	43✔
32	*	43✔
33	* @param node - The event target	43✔
34	* @param event - The event object	43✔
35	*	43✔
36	* When `true` is returned, the current event is ignored.	43✔
37	*/	43✔
38	export type KeyBindingSkipCallback = (	43✔
39	node: Element,	43✔
40	event: KeyboardEvent	43✔
41	) => boolean;	43✔
42		43✔
43	/**	43✔
44	* The event type which will trigger the bound handler.	43✔
45	*	43✔
46	* @remarks	43✔
47	* `keydownRepeat` is similar to `keydown` with the exception	43✔
48	* that after the handler is invoked the pressed state of the key is reset	43✔
49	* in the controller.	43✔
50	*/	43✔
51	export type KeyBindingTrigger = 'keydown' \| 'keyup' \| 'keydownRepeat';	43✔
52		43✔
53	/**	43✔
54	* Configuration object for the controller.	43✔
55	* @ignore	43✔
56	*/	43✔
57	export interface KeyBindingControllerOptions {	43✔
58	/**	43✔
59	* By default, the controller listens for keypress events in the context of the host element.	43✔
60	* If you pass a `ref`, you can limit the observation to a certain DOM part of the host scope.	43✔
61	*/	43✔
62	ref?: Ref;	43✔
63	/**	43✔
64	* Option to ignore key press events.	43✔
65	*	43✔
66	* If passed an array of CSS selectors, it will ignore key presses originating from elements in the event composed path	43✔
67	* that match one of the selectors.	43✔
68	* Otherwise you can pass a {@link KeyBindingSkipCallback} function.	43✔
69	*	43✔
70	* Defaults to `['input', 'textarea', 'select']`.	43✔
71	*	43✔
72	* @example	43✔
73	* ```ts	43✔
74	* {	43✔
75	* // Skip events originating from elements with `readonly` attribute	43✔
76	* skip: ['[readonly]']	43✔
77	* }	43✔
78	* ...	43✔
79	* {	43✔
80	* // Same as above but with a callback	43✔
81	* skip: (node: Element) => node.hasAttribute('readonly')	43✔
82	* }	43✔
83	* ```	43✔
84	*/	43✔
85	skip?: string[] \| KeyBindingSkipCallback;	43✔
86	/**	43✔
87	* A set of KeyBindingOptions configuration which is applied to every handler	43✔
88	* that is added to the controller.	43✔
89	*	43✔
90	* Any additional KeyBindingOptions values passed when `set` is called	43✔
91	* will be merged with `bindingDefaults`.	43✔
92	*/	43✔
93	bindingDefaults?: KeyBindingOptions;	43✔
94	}	43✔
95		43✔
96	/**	43✔
97	* Configuration object for customizing the behavior of	43✔
98	* the registered handler.	43✔
99	*/	43✔
100	export interface KeyBindingOptions {	43✔
101	/**	43✔
102	* The event type(s) on which the handler will be invoked.	43✔
103	*	43✔
104	* Defaults to `keydown` if not set.	43✔
105	*/	43✔
106	triggers?: KeyBindingTrigger[];	43✔
107	/**	43✔
108	* Whether to call `preventDefault` on the target event before the handler is invoked.	43✔
109	*/	43✔
110	preventDefault?: boolean;	43✔
111	/**	43✔
112	* Whether to call `stopPropagation` on the target event before the handler is invoked.	43✔
113	*/	43✔
114	stopPropagation?: boolean;	43✔
115	}	43✔
116		43✔
117	interface KeyBinding {	43✔
118	keys: string[];	43✔
119	handler: KeyBindingHandler;	43✔
120	options?: KeyBindingOptions;	43✔
121	modifiers?: string[];	43✔
122	}	43✔
123		43✔
124	const Modifiers: Map<string, string> = new Map(	43✔
125	[altKey, ctrlKey, metaKey, shiftKey].map((key) => {	43✔
126	const mod = key.toLowerCase();	172✔
127	return key === ctrlKey ? ['control', mod] : [mod, mod];	172✔
128	})	172✔
129	);	43✔
130		43✔
131	const defaultOptions: KeyBindingControllerOptions = {	43✔
132	skip: ['input', 'textarea', 'select'],	43✔
133	};	43✔
134		43✔
135	function normalizeKeys(keys: string \| string[]) {	6,817✔
136	return (Array.isArray(keys) ? keys : [keys]).map((key) => key.toLowerCase());	6,817✔
137	}	6,817✔
138		43✔
139	function isKeydown(event: Event) {	488✔
140	return event.type === 'keydown';	488✔
141	}	488✔
142		43✔
143	function isKeyup(event: Event) {	872✔
144	return event.type === 'keyup';	872✔
145	}	872✔
146		43✔
147	function isKeydownTrigger(triggers?: KeyBindingTrigger[]) {	270✔
148	return triggers	270✔
149	? triggers.includes('keydown') \|\| isKeydownRepeatTrigger(triggers)	270✔
150	: false;	270!
151	}	270✔
152		43✔
153	function isKeyupTrigger(triggers?: KeyBindingTrigger[]) {	218✔
154	return triggers ? triggers.includes('keyup') : false;	218!
155	}	218✔
156		43✔
157	function isKeydownRepeatTrigger(triggers?: KeyBindingTrigger[]) {	456✔
158	return triggers ? triggers.includes('keydownRepeat') : false;	456✔
159	}	456✔
160		43✔
161	export function parseKeys(keys: string \| string[]) {	43✔
162	const parsed = normalizeKeys(keys);	6,817✔
163	return {	6,817✔
164	keys: parsed.filter((key) => !Modifiers.has(key)),	6,817✔
165	modifiers: parsed.filter((key) => Modifiers.has(key)),	6,817✔
166	};	6,817✔
167	}	6,817✔
168		43✔
169	function createCombinationKey(keys: string[], modifiers: string[]) {	7,224✔
170	return Array.from(Modifiers.values())	7,224✔
171	.filter((mod) => modifiers.includes(mod))	7,224✔
172	.concat(keys)	7,224✔
173	.join('+');	7,224✔
174	}	7,224✔
175		43✔
176	class KeyBindingController implements ReactiveController {	43✔
177	protected _host: ReactiveControllerHost & Element;	43✔
178	protected _ref?: Ref;	43✔
179	protected _observedElement?: Element;	43✔
180	protected _options?: KeyBindingControllerOptions;	43✔
181	private bindings = new Map<string, KeyBinding>();	43✔
182	private pressedKeys = new Set<string>();	43✔
183		43✔
184	protected get _element() {	43✔
185	if (this._observedElement) {	1,295✔
186	return this._observedElement;	10✔
187	}	10✔
188	return this._ref ? this._ref.value : this._host;	1,295✔
189	}	1,295✔
190		43✔
191	/**	43✔
192	* Sets the controller to listen for keyboard events on an arbitrary `element` in the page context.	43✔
193	* All the configuration and event handlers are applied as well.	43✔
194	*	43✔
195	* Returns an object with an `unsubscribe` function which should be called when the observing of keyboard	43✔
196	* events on the `element` should cease.	43✔
197	*/	43✔
198	public observeElement(element: Element): KeyBindingObserverCleanup {	43✔
199	element.addEventListener('keydown', this);	5✔
200	element.addEventListener('keyup', this);	5✔
201	this._observedElement = element;	5✔
202		5✔
203	return {	5✔
204	unsubscribe: () => {	5✔
205	this._observedElement?.removeEventListener('keydown', this);	8✔
206	this._observedElement?.removeEventListener('keyup', this);	8✔
207	this._observedElement = undefined;	8✔
208	},	5✔
209	};	5✔
210	}	5✔
211		43✔
212	constructor(	43✔
213	host: ReactiveControllerHost & Element,	1,091✔
214	options?: KeyBindingControllerOptions	1,091✔
215	) {	1,091✔
216	this._host = host;	1,091✔
217	this._ref = options?.ref;	1,091✔
218	this._options = { ...defaultOptions, ...options };	1,091✔
219	host.addController(this);	1,091✔
220	}	1,091✔
221		43✔
222	/**	43✔
223	* Checks and executes any event modifiers that are present in the matched binding.	43✔
224	*/	43✔
225	private eventModifiersMatch(binding: KeyBinding, event: KeyboardEvent) {	43✔
226	if (binding.options?.preventDefault) {	272✔
227	event.preventDefault();	260✔
228	}	260✔
229		272✔
230	if (binding.options?.stopPropagation) {	272✔
231	event.stopPropagation();	4✔
232	}	4✔
233	}	272✔
234		43✔
235	private bindingMatches(binding: KeyBinding, event: KeyboardEvent) {	43✔
236	const triggers = binding.options?.triggers ?? ['keydown'];	488✔
237		488✔
238	if (isKeydown(event) && isKeydownTrigger(triggers)) {	488✔
239	return true;	269✔
240	}	269✔
241		219✔
242	if (isKeyup(event) && isKeyupTrigger(triggers)) {	488✔
243	return true;	3✔
244	}	3✔
245		216✔
246	return false;	216✔
247	}	216✔
248		43✔
249	private shouldSkip(event: KeyboardEvent) {	43✔
250	const skip = this._options?.skip;	709✔
251		709✔
252	if (!findElementFromEventPath((e) => e === this._element, event)) {	709✔
253	return true;	30✔
254	}	30✔
255		679✔
256	if (!skip) {	709!
NEW 257	return false;	×
UNCOV 258	}	×
259		679✔
260	return Array.isArray(skip)	679✔
261	? findElementFromEventPath(skip.join(), event)	709✔
262	: skip.call(this._host, event.target as Element, event);	709✔
263	}	709✔
264		43✔
265	public handleEvent(event: KeyboardEvent) {	43✔
266	if (this.shouldSkip(event)) {	709✔
267	return;	56✔
268	}	56✔
269		653✔
270	const key = event.key.toLowerCase();	653✔
271	Modifiers.has(key) ? this.pressedKeys.clear() : this.pressedKeys.add(key);	709!
272		709✔
273	const pendingKeys = Array.from(this.pressedKeys);	709✔
274	const modifiers = Array.from(Modifiers.values()).filter(	709✔
275	(mod) => event[`${mod}Key` as keyof KeyboardEvent]	709✔
276	);	709✔
277		709✔
278	const binding = this.bindings.get(	709✔
279	createCombinationKey(pendingKeys, modifiers)	709✔
280	);	709✔
281		709✔
282	if (binding && this.bindingMatches(binding, event)) {	709✔
283	this.eventModifiersMatch(binding, event);	272✔
284	binding.handler.call(this._host, event);	272✔
285		272✔
286	if (isKeydownRepeatTrigger(binding.options?.triggers)) {	272✔
287	this.pressedKeys.delete(key);	183✔
288	}	183✔
289	}	272✔
290		653✔
291	if (isKeyup(event) && !Modifiers.has(key)) {	709✔
292	this.pressedKeys.delete(key);	302✔
293	}	302✔
294	}	709✔
295		43✔
296	/**	43✔
297	* Registers a keybinding handler.	43✔
298	*/	43✔
299	public set(	43✔
300	key: string \| string[],	6,571✔
301	handler: KeyBindingHandler,	6,571✔
302	options?: KeyBindingOptions	6,571✔
303	) {	6,571✔
304	const { keys, modifiers } = parseKeys(key);	6,571✔
305	const combination = createCombinationKey(keys, modifiers);	6,571✔
306	const _options = { ...this._options?.bindingDefaults, ...options };	6,571✔
307		6,571✔
308	this.bindings.set(combination, {	6,571✔
309	keys,	6,571✔
310	handler,	6,571✔
311	options: _options,	6,571✔
312	modifiers,	6,571✔
313	});	6,571✔
314		6,571✔
315	return this;	6,571✔
316	}	6,571✔
317		43✔
318	/**	43✔
319	* Register a handler function which is called when the target receives a key	43✔
320	* which "activates" it.	43✔
321	*	43✔
322	* In the browser context this is usually either an Enter and/or Space keypress.	43✔
323	*/	43✔
324	public setActivateHandler(	43✔
325	handler: KeyBindingHandler,	361✔
326	options?: KeyBindingOptions	361✔
327	) {	361✔
328	for (const key of [enterKey, spaceBar]) {	361✔
329	this.set(key, handler, options);	722✔
330	}	722✔
331		361✔
332	return this;	361✔
333	}	361✔
334		43✔
335	public hostConnected(): void {	43✔
336	this._host.addEventListener('keyup', this);	1,043✔
337	this._host.addEventListener('keydown', this);	1,043✔
338	}	1,043✔
339		43✔
340	public hostDisconnected(): void {	43✔
341	this._host.removeEventListener('keyup', this);	1,042✔
342	this._host.removeEventListener('keydown', this);	1,042✔
343	}	1,042✔
344	}	43✔
345		43✔
346	/**	43✔
347	* Creates a keybinding controller and adds to it to the passed `element`	43✔
348	* with the provided `options`.	43✔
349	*/	43✔
350	export function addKeybindings(	43✔
351	element: ReactiveControllerHost & Element,	1,091✔
352	options?: KeyBindingControllerOptions	1,091✔
353	) {	1,091✔
354	return new KeyBindingController(element, options);	1,091✔
355	}	1,091✔

IgniteUI / igniteui-webcomponents / 10827429861

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous