@m3e/core 1.0.0-rc.1 → 1.0.0-rc.2

package/src/shared/controllers/FocusController.ts

@@ -1,60 +0,0 @@
-import { ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** The callback function invoked when the focused state of an element changes. */
-export type FocusControllerCallback = (focused: boolean, focusVisible: boolean, target: HTMLElement) => void;
-
-/** Encapsulates options used to configure a `FocusController`. */
-export interface FocusControllerOptions extends MonitorControllerOptions {
-  /** The callback invoked when the focused state of an element changes. */
-  callback: FocusControllerCallback;
-}
-
-/** A `ReactiveController` used to monitor the focused state of one or more elements. */
-export class FocusController extends MonitorControllerBase {
-  /** @private */ readonly #callback: FocusControllerCallback;
-  /** @private */ readonly #focusInHandler = (e: Event) => this.#handleFocusIn(e);
-  /** @private */ readonly #focusOutHandler = (e: Event) => this.#handleFocusOut(e);
-
-  /**
-   * Initializes a new instance of this class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {FocusControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: FocusControllerOptions) {
-    super(host, options);
-    this.#callback = options.callback;
-  }
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected override _observe(target: HTMLElement): void {
-    target.addEventListener("keydown", this.#focusInHandler);
-    target.addEventListener("focusin", this.#focusInHandler);
-    target.addEventListener("focusout", this.#focusOutHandler);
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected override _unobserve(target: HTMLElement): void {
-    target.removeEventListener("keydown", this.#focusInHandler);
-    target.removeEventListener("focusin", this.#focusInHandler);
-    target.removeEventListener("focusout", this.#focusOutHandler);
-  }
-
-  /** @private */
-  #handleFocusIn(e: Event): void {
-    const target = e.target as HTMLElement;
-    this.#callback(true, target.matches(":focus-visible") || matchMedia("(forced-colors: active)").matches, target);
-  }
-
-  /** @private */
-  #handleFocusOut(e: Event): void {
-    this.#callback(false, false, e.target as HTMLElement);
-  }
-}

package/src/shared/controllers/HoverController.ts

@@ -1,140 +0,0 @@
-import { ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** The callback function invoked when the hover state of an element changes. */
-export type HoverControllerCallback = (hovering: boolean, target: HTMLElement) => void;
-
-/** Encapsulates options used to configure a `HoverController`. */
-export interface HoverControllerOptions extends MonitorControllerOptions {
-  /** The callback invoked when the hover state of an element changes. */
-  callback: HoverControllerCallback;
-
-  /** The delay, in milliseconds, before reporting hover start. */
-  startDelay?: number;
-
-  /** The delay, in milliseconds, before reporting hover end. */
-  endDelay?: number;
-}
-
-/** A `ReactiveController` used to monitor the hover state of one or more elements. */
-export class HoverController extends MonitorControllerBase {
-  /** @private */ readonly #callback: HoverControllerCallback;
-  /** @private */ readonly #startDelays = new Map<HTMLElement, number>();
-  /** @private */ readonly #endDelays = new Map<HTMLElement, number>();
-  /** @private */ readonly #pointerInHandler = (e: Event) => this.#handlePointerEnter(e);
-  /** @private */ readonly #pointerLeaveHandler = (e: Event) => this.#handlePointerLeave(e);
-
-  /** The delay, in milliseconds, before reporting hover start. */
-  startDelay: number;
-
-  /** The delay, in milliseconds, before reporting hover end. */
-  endDelay: number;
-
-  /**
-   * Initializes a new instance of this class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {HoverControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: HoverControllerOptions) {
-    super(host, options);
-    this.#callback = options.callback;
-    this.startDelay = options.startDelay ?? 0;
-    this.endDelay = options.endDelay ?? 0;
-  }
-
-  /** Clears any hover delays for all targets. */
-  clearDelays(): void {
-    for (const target of this.targets) {
-      this.#clearDelays(target);
-    }
-  }
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected override _observe(target: HTMLElement): void {
-    target.addEventListener("pointerenter", this.#pointerInHandler);
-    target.addEventListener("pointerleave", this.#pointerLeaveHandler);
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected override _unobserve(target: HTMLElement): void {
-    target.removeEventListener("pointerenter", this.#pointerInHandler);
-    target.removeEventListener("pointerleave", this.#pointerLeaveHandler);
-  }
-
-  /** @private */
-  #clearDelays(target: HTMLElement): void {
-    this.#clearStartDelay(target);
-    this.#clearEndDelay(target);
-  }
-
-  /** @private */
-  #clearStartDelay(target: HTMLElement): boolean {
-    if (this.#startDelays.has(target)) {
-      clearTimeout(this.#startDelays.get(target));
-      return this.#startDelays.delete(target);
-    }
-    return false;
-  }
-
-  /** @private */
-  #clearEndDelay(target: HTMLElement): boolean {
-    if (this.#endDelays.has(target)) {
-      clearTimeout(this.#endDelays.get(target));
-      return this.#endDelays.delete(target);
-    }
-    return false;
-  }
-
-  /** @private */
-  #handlePointerEnter(e: Event): void {
-    const target = e.target as HTMLElement;
-
-    // If there is a pending end delay, cancel it.
-    this.#clearEndDelay(target);
-
-    // Otherwise, if there is a pending start delay, cancel it and start a new one.
-    if (this.startDelay > 0) {
-      this.#clearStartDelay(target);
-      this.#startDelays.set(
-        target,
-        setTimeout(() => {
-          this.#startDelays.delete(target);
-          this.#callback(true, target);
-        }, this.startDelay)
-      );
-    } else {
-      // Otherwise, report the start.
-      this.#callback(true, target);
-    }
-  }
-
-  /** @private */
-  #handlePointerLeave(e: Event): void {
-    const target = e.target as HTMLElement;
-
-    // If there is a pending start delay, cancel it and do not report the end.
-    if (this.#clearStartDelay(target)) return;
-
-    // Otherwise, if there is a pending end delay, cancel it and start a new one.
-    if (this.endDelay > 0) {
-      this.#clearEndDelay(target);
-      this.#endDelays.set(
-        target,
-        setTimeout(() => {
-          this.#endDelays.delete(target);
-          this.#callback(false, target);
-        }, this.endDelay)
-      );
-    } else {
-      // Otherwise, report the end.
-      this.#callback(false, target);
-    }
-  }
-}

package/src/shared/controllers/IntersectionController.ts

@@ -1,81 +0,0 @@
-import { isServer, ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** The callback function for a `IntersectionController`. */
-export type IntersectionControllerCallback = (...args: Parameters<IntersectionObserverCallback>) => void;
-
-/** Encapsulates options used to configure a `IntersectionController`. */
-export interface IntersectionControllerOptions extends MonitorControllerOptions {
-  /** The callback used to process detected changes. */
-  callback: IntersectionControllerCallback;
-
-  /**
-   * By default, the `callback` is invoked without changes when a
-   * target is observed in order to help maintain initial state. Use
-   * `skipInitial` to skip this step.
-   */
-  skipInitial?: boolean;
-
-  /** The configuration object for the underlying `IntersectionObserver`. */
-  init?: IntersectionObserverInit;
-}
-
-/** A `ReactiveController` used to monitor changes in the intersection of a target element with an ancestor element. */
-export class IntersectionController extends MonitorControllerBase {
-  /** @private */ #host: ReactiveControllerHost;
-  /** @private */ #callback: IntersectionControllerCallback;
-  /** @private */ #skipInitial = false;
-  /** @private */ #observer?: IntersectionObserver;
-  /** @private */ #unobservedUpdate = true;
-
-  /**
-   * Initializes a new instance of the `IntersectionController` class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {IntersectionControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: IntersectionControllerOptions) {
-    super(host, options);
-
-    this.#host = host;
-    this.#callback = options.callback;
-    this.#skipInitial = options.skipInitial ?? false;
-
-    if (isServer) return;
-    if (!window.IntersectionObserver) {
-      console.warn("IntersectionController error: the browser does not support IntersectionObserver.");
-      return;
-    }
-
-    this.#observer = new IntersectionObserver((entries, observer) => {
-      this.#callback(entries, observer);
-      this.#host.requestUpdate();
-    }, options.init);
-  }
-
-  /** @inheritdoc */
-  override async hostUpdated(): Promise<void> {
-    if (this.#observer && !this.#skipInitial && this.#unobservedUpdate) {
-      this.#callback([], this.#observer);
-    }
-    this.#unobservedUpdate = false;
-  }
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected override _observe(target: HTMLElement): void {
-    this.#observer?.observe(target);
-    this.#unobservedUpdate = true;
-    this.#host.requestUpdate();
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected override _unobserve(target: HTMLElement): void {
-    this.#observer?.unobserve(target);
-  }
-}

package/src/shared/controllers/LongPressController.ts

@@ -1,87 +0,0 @@
-import { ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** The callback function invoked when a long press gesture is detected. */
-export type LongPressControllerCallback = (pressed: boolean, target: HTMLElement) => void;
-
-/** Encapsulates options used to configure a `LongPressController`. */
-export interface LongPressControllerOptions extends MonitorControllerOptions {
-  /** The callback invoked when the pressed state of an element changes. */
-  callback: LongPressControllerCallback;
-
-  /** The amount of time, in milliseconds, a touch gesture must be held. */
-  threshold?: number;
-}
-
-/** A `ReactiveController` used to detect a long press gesture. */
-export class LongPressController extends MonitorControllerBase {
-  /** @private */ readonly #callback: LongPressControllerCallback;
-  /** @private */ readonly #threshold: number;
-  /** @private */ readonly #pressedTargets = new Set<HTMLElement>();
-  /** @private */ readonly #pressedTimeouts = new Map<HTMLElement, number>();
-
-  /** @private */ readonly #touchStartHandler = (e: TouchEvent) => this.#handleTouchStart(e);
-  /** @private */ readonly #touchEndOrCancelHandler = (e: TouchEvent) => this.#handleTouchEndOrCancel(e);
-
-  /**
-   * Initializes a new instance of this class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {LongPressControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: LongPressControllerOptions) {
-    super(host, options);
-    this.#callback = options.callback;
-    this.#threshold = options.threshold ?? 500;
-  }
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected override _observe(target: HTMLElement): void {
-    target.addEventListener("touchstart", this.#touchStartHandler);
-    target.addEventListener("touchend", this.#touchEndOrCancelHandler);
-    target.addEventListener("touchcancel", this.#touchEndOrCancelHandler);
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected override _unobserve(target: HTMLElement): void {
-    target.removeEventListener("touchstart", this.#touchStartHandler);
-    target.removeEventListener("touchend", this.#touchEndOrCancelHandler);
-    target.removeEventListener("touchcancel", this.#touchEndOrCancelHandler);
-  }
-
-  /** @private */
-  #handleTouchStart(e: TouchEvent): void {
-    if (e.currentTarget instanceof HTMLElement && this.isObserving(e.currentTarget)) {
-      const target = e.currentTarget;
-      this.#pressedTimeouts.set(
-        target,
-        setTimeout(() => {
-          this.#pressedTargets.add(target);
-          this.#pressedTimeouts.delete(target);
-          this.#callback(true, target);
-        }, this.#threshold)
-      );
-    }
-  }
-
-  /** @private */
-  #handleTouchEndOrCancel(e: TouchEvent): void {
-    if (e.currentTarget instanceof HTMLElement && this.isObserving(e.currentTarget)) {
-      const target = e.currentTarget;
-      if (this.#pressedTargets.has(target)) {
-        this.#callback(false, target);
-        this.#pressedTargets.delete(target);
-      }
-      if (this.#pressedTimeouts.has(target)) {
-        clearTimeout(this.#pressedTimeouts.get(target));
-        this.#pressedTimeouts.delete(target);
-      }
-    }
-  }
-}

package/src/shared/controllers/MonitorControllerBase.ts

@@ -1,99 +0,0 @@
-import { ReactiveController, ReactiveControllerHost } from "lit";
-
-/** Encapsulates options used to monitor the state of one or more elements. */
-export interface MonitorControllerOptions {
-  /**
-   * The element to observe. In addition to configuring the target here,
-   * the `observe` method can be called to observe additional targets. When
-   * not specified, the target defaults to the `host`. If set to `null`, no
-   * target is automatically observed. Only the configured target will be
-   * re-observed if the host connects again after unobserving via disconnection.
-   */
-  target?: HTMLElement | null;
-}
-
-/**
- * A base implementation for a `ReactiveController` used to monitor the state of one
- * or more elements. This class must be inherited.
- */
-export abstract class MonitorControllerBase implements ReactiveController {
-  /** @private */ readonly #host: ReactiveControllerHost & HTMLElement;
-  /** @private */ readonly #target?: HTMLElement | null;
-  /** @private */ readonly #targets = new Set<HTMLElement>();
-
-  /**
-   * Initializes the `MonitorControllerBase` base class values when called by a derived class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {MonitorControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: MonitorControllerOptions) {
-    this.#host = host;
-    this.#target = options.target;
-    this.#host.addController(this);
-  }
-
-  /** The targets being observed. */
-  get targets(): Iterable<HTMLElement> {
-    return this.#targets.values();
-  }
-
-  /** @inheritdoc */
-  hostConnected(): void {
-    // Target defaults to host unless explicitly null.
-    if (this.#target !== null) {
-      this.observe(this.#target ?? this.#host);
-    }
-  }
-
-  /** @inheritdoc */
-  hostDisconnected(): void {
-    this.#targets.forEach((x) => this.unobserve(x));
-    this.#targets.clear();
-  }
-
-  /** @inheritdoc */
-  hostUpdate?(): void;
-
-  /** @inheritdoc */
-  hostUpdated?(): void;
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  observe(target: HTMLElement): void {
-    if (this.#targets.has(target)) return;
-    this.#targets.add(target);
-    this._observe(target);
-  }
-
-  /**
-   * Determines whether the specified element is being observed.
-   * @param {HTMLElement} target The element to test.
-   * @returns {boolean} Whether `target` is being observed.
-   */
-  isObserving(target: HTMLElement): boolean {
-    return this.#targets.has(target);
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  unobserve(target: HTMLElement): void {
-    if (!this.#targets.delete(target)) return;
-    this._unobserve(target);
-  }
-
-  /**
-   * When implemented by a derived class, starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected abstract _observe(target: HTMLElement): void;
-
-  /**
-   * When implemented by a derived class, stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected abstract _unobserve(target: HTMLElement): void;
-}

package/src/shared/controllers/MutationController.ts

@@ -1,89 +0,0 @@
-import { isServer, ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** Encapsulates options used to configure a `MutationController`. */
-export interface MutationControllerOptions extends MonitorControllerOptions {
-  /** The callback used to process detected changes. */
-  callback: MutationCallback;
-
-  /**
-   * By default, the `callback` is invoked without changes when a
-   * target is observed in order to help maintain initial state. Use
-   * `skipInitial` to skip this step.
-   */
-  skipInitial?: boolean;
-
-  /** The configuration object for the underlying `MutationObserver`. */
-  config?: MutationObserverInit;
-}
-
-/**
- * A `ReactiveController` that integrates a `MutationObserver` with an element's reactive update lifecycle
- * to detect arbitrary changes to DOM, including nodes being added or removed and attributes changing.
- */
-export class MutationController extends MonitorControllerBase {
-  /** @private */ #host: ReactiveControllerHost;
-  /** @private */ #callback: MutationCallback;
-  /** @private */ #skipInitial = false;
-  /** @private */ #config?: MutationObserverInit;
-  /** @private */ #observer?: MutationObserver;
-  /** @private */ #unobservedUpdate = true;
-
-  /**
-   * Initializes a new instance of the `MutationController` class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {MutationControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: MutationControllerOptions) {
-    super(host, options);
-
-    this.#host = host;
-    this.#callback = options.callback;
-    this.#skipInitial = options.skipInitial ?? false;
-    this.#config = options.config;
-
-    if (isServer) return;
-    if (!window.MutationObserver) {
-      console.warn("MutationController error: the browser does not support MutationObserver.");
-      return;
-    }
-
-    this.#observer = new MutationObserver((records, observer) => {
-      this.#callback(records, observer);
-      this.#host.requestUpdate();
-    });
-  }
-
-  /** @inheritdoc */
-  override async hostUpdated(): Promise<void> {
-    if (this.#observer && !this.#skipInitial && this.#unobservedUpdate) {
-      const records = this.#observer.takeRecords();
-      if (records.length > 0) {
-        this.#callback(records, this.#observer);
-      }
-    }
-    this.#unobservedUpdate = false;
-  }
-
-  /** @inheritdoc */
-  override hostDisconnected(): void {
-    super.hostDisconnected();
-    this.#observer?.disconnect();
-  }
-
-  /** @inheritdoc */
-  protected override _observe(target: HTMLElement): void {
-    this.#observer?.observe(target, this.#config);
-    this.#unobservedUpdate = true;
-    this.#host.requestUpdate();
-  }
-
-  /** @inheritdoc */
-  protected override _unobserve(): void {
-    this.#observer?.disconnect();
-    for (const target of this.targets) {
-      this.#observer?.observe(target, this.#config);
-    }
-  }
-}

package/src/shared/controllers/PressedController.ts

@@ -1,137 +0,0 @@
-import { ReactiveControllerHost } from "lit";
-
-import { MonitorControllerBase, MonitorControllerOptions } from "./MonitorControllerBase";
-
-/** The callback function invoked when the pressed state of an element changes. */
-export type PressedControllerCallback = (
-  pressed: boolean,
-  point: { x: number; y: number },
-  target: HTMLElement
-) => void;
-
-/** Encapsulates options used to configure a `PressedController`. */
-export interface PressedControllerOptions extends MonitorControllerOptions {
-  /** The callback invoked when the pressed state of an element changes. */
-  callback: PressedControllerCallback;
-
-  /** Whether events are captured. */
-  capture?: boolean;
-
-  /**
-   * A function used to determine whether a given keyboard key toggles the pressed state.
-   * @param key The `KeyboardEvent.key` to test.
-   * @returns Whether `key` toggles the pressed state.
-   */
-  isPressedKey?: (key: string) => boolean;
-}
-
-/** A `ReactiveController` used to monitor the pressed state of one or more elements. */
-export class PressedController extends MonitorControllerBase {
-  /** @private */ readonly #capture?: boolean;
-  /** @private */ readonly #callback: PressedControllerCallback;
-  /** @private */ readonly #isPressedKey?: (key: string) => boolean;
-  /** @private */ readonly #pressedTargets = new Set<HTMLElement>();
-
-  /** @private */ readonly #pointerDownHandler = (e: PointerEvent) => this.#handlePointerDown(e);
-  /** @private */ readonly #pointerUpHandler = (e: PointerEvent) => this.#handlePointerUp(e);
-  /** @private */ readonly #keyDownHandler = (e: KeyboardEvent) => this.#handleKeyDown(e);
-  /** @private */ readonly #keyUpHandler = (e: KeyboardEvent) => this.#handleKeyUp(e);
-
-  /**
-   * Initializes a new instance of this class.
-   * @param {ReactiveControllerHost & HTMLElement} host The host element to which this controller will be added.
-   * @param {PressedControllerOptions} options Options used to configure this controller.
-   */
-  constructor(host: ReactiveControllerHost & HTMLElement, options: PressedControllerOptions) {
-    super(host, options);
-
-    this.#capture = options.capture;
-    this.#callback = options.callback;
-    this.#isPressedKey = options.isPressedKey;
-  }
-
-  /** @inheritdoc */
-  override hostConnected(): void {
-    document.addEventListener("pointerup", this.#pointerUpHandler, { capture: this.#capture });
-    super.hostConnected();
-  }
-
-  /** @inheritdoc */
-  override hostDisconnected(): void {
-    document.removeEventListener("pointerup", this.#pointerUpHandler, { capture: this.#capture });
-    super.hostDisconnected();
-    this.#pressedTargets.clear();
-  }
-
-  /**
-   * Starts observing the specified element.
-   * @param {HTMLElement} target The element to start observing.
-   */
-  protected override _observe(target: HTMLElement): void {
-    target.addEventListener("pointerdown", this.#pointerDownHandler, { capture: this.#capture });
-    if (this.#isPressedKey) {
-      target.addEventListener("keydown", this.#keyDownHandler, { capture: this.#capture });
-      target.addEventListener("keyup", this.#keyUpHandler, { capture: this.#capture });
-    }
-  }
-
-  /**
-   * Stops observing the specified element.
-   * @param {HTMLElement} target The element to stop observing.
-   */
-  protected override _unobserve(target: HTMLElement): void {
-    target.removeEventListener("pointerdown", this.#pointerDownHandler, { capture: this.#capture });
-
-    if (this.#isPressedKey) {
-      target.removeEventListener("keydown", this.#keyDownHandler, { capture: this.#capture });
-      target.removeEventListener("keyup", this.#keyUpHandler, { capture: this.#capture });
-    }
-  }
-
-  /** @private */
-  #handlePointerDown(e: PointerEvent): void {
-    if (e.pointerType === "mouse" && e.button > 1) return;
-
-    for (const target of e.composedPath()) {
-      if (target instanceof HTMLElement && this.isObserving(target)) {
-        this.#pressedTargets.add(target);
-        this.#callback(true, { x: e.x, y: e.y }, target);
-        break;
-      }
-    }
-  }
-
-  /** @private */
-  #handlePointerUp(e: PointerEvent): void {
-    if (e.pointerType === "mouse" && e.button > 1) return;
-
-    this.#pressedTargets.forEach((x) => this.#callback(false, { x: e.x, y: e.y }, x));
-    this.#pressedTargets.clear();
-  }
-
-  /** @private */
-  #handleKeyDown(e: KeyboardEvent): void {
-    const target = e.target as HTMLElement;
-
-    if (!this.#pressedTargets.has(target) && this.#isPressedKey?.(e.key)) {
-      if (e.key === " ") {
-        e.preventDefault();
-      }
-
-      this.#pressedTargets.add(target);
-      const bounds = target.getBoundingClientRect();
-      this.#callback(true, { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 }, target);
-    }
-  }
-
-  /** @private */
-  #handleKeyUp(e: KeyboardEvent): void {
-    const target = e.target as HTMLElement;
-
-    if (this.#pressedTargets.has(target) && this.#isPressedKey?.(e.key)) {
-      this.#pressedTargets.delete(target);
-      const bounds = target.getBoundingClientRect();
-      this.#callback(false, { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 }, target);
-    }
-  }
-}