@node-edit-utils/core 2.3.3 → 2.3.4

package/src/lib/node-tools/createNodeTools.test.ts

@@ -0,0 +1,373 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as connectResizeObserverModule from "../helpers/observer/connectResizeObserver";
+import * as sendPostMessageModule from "../post-message/sendPostMessage";
+import * as bindToWindowModule from "../window/bindToWindow";
+import { createNodeTools } from "./createNodeTools";
+import * as setupEventListenerModule from "./events/setupEventListener";
+import * as clearHighlightFrameModule from "./highlight/clearHighlightFrame";
+import * as highlightNodeModule from "./highlight/highlightNode";
+import * as refreshHighlightFrameModule from "./highlight/refreshHighlightFrame";
+import * as updateHighlightFrameVisibilityModule from "./highlight/updateHighlightFrameVisibility";
+import * as nodeTextModule from "./text/nodeText";
+
+vi.mock("../window/bindToWindow");
+vi.mock("../post-message/sendPostMessage");
+vi.mock("./events/setupEventListener");
+vi.mock("./highlight/clearHighlightFrame");
+vi.mock("./highlight/highlightNode");
+vi.mock("./highlight/refreshHighlightFrame");
+vi.mock("./highlight/updateHighlightFrameVisibility");
+vi.mock("./text/nodeText");
+vi.mock("../helpers/observer/connectResizeObserver");
+
+// Mock ResizeObserver for jsdom
+global.ResizeObserver = class ResizeObserver {
+  constructor(public callback: ResizeObserverCallback) {}
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+} as unknown as typeof ResizeObserver;
+
+describe("createNodeTools", () => {
+  let nodeProvider: HTMLElement;
+  let node: HTMLElement;
+  let mockText: {
+    enableEditMode: ReturnType<typeof vi.fn>;
+    blurEditMode: ReturnType<typeof vi.fn>;
+    getEditableNode: ReturnType<typeof vi.fn>;
+    isEditing: ReturnType<typeof vi.fn>;
+  };
+  let mockRemoveListeners: ReturnType<typeof vi.fn>;
+  let mockResizeObserver: ResizeObserver;
+  let mockMutationObserver: MutationObserver;
+  let mockParentMutationObserver: MutationObserver;
+
+  beforeEach(() => {
+    nodeProvider = document.createElement("div");
+    nodeProvider.setAttribute("data-role", "node-provider");
+    document.body.appendChild(nodeProvider);
+
+    node = document.createElement("div");
+    node.setAttribute("data-node-id", "test-node-1");
+    nodeProvider.appendChild(node);
+
+    mockText = {
+      enableEditMode: vi.fn(),
+      blurEditMode: vi.fn(),
+      getEditableNode: vi.fn().mockReturnValue(null),
+      isEditing: vi.fn().mockReturnValue(false),
+    };
+
+    mockRemoveListeners = vi.fn();
+    mockResizeObserver = new ResizeObserver(() => {});
+    mockResizeObserver.disconnect = vi.fn();
+    mockMutationObserver = new MutationObserver(() => {});
+    mockMutationObserver.disconnect = vi.fn();
+    mockParentMutationObserver = new MutationObserver(() => {});
+    mockParentMutationObserver.disconnect = vi.fn();
+
+    vi.mocked(bindToWindowModule.bindToWindow).mockImplementation(() => {});
+    vi.mocked(sendPostMessageModule.sendPostMessage).mockImplementation(() => {});
+    vi.mocked(setupEventListenerModule.setupEventListener).mockReturnValue(mockRemoveListeners);
+    vi.mocked(clearHighlightFrameModule.clearHighlightFrame).mockImplementation(() => {});
+    vi.mocked(highlightNodeModule.highlightNode).mockImplementation(() => {});
+    vi.mocked(refreshHighlightFrameModule.refreshHighlightFrame).mockImplementation(() => {});
+    vi.mocked(updateHighlightFrameVisibilityModule.updateHighlightFrameVisibility).mockImplementation(() => {});
+    vi.mocked(nodeTextModule.nodeText).mockReturnValue(mockText as unknown as ReturnType<typeof nodeTextModule.nodeText>);
+    vi.mocked(connectResizeObserverModule.connectResizeObserver).mockReturnValue(mockResizeObserver);
+  });
+
+  afterEach(() => {
+    if (document.body.contains(nodeProvider)) {
+      document.body.removeChild(nodeProvider);
+    }
+    vi.clearAllMocks();
+  });
+
+  it("should return NodeTools interface", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    expect(nodeTools).toHaveProperty("selectNode");
+    expect(nodeTools).toHaveProperty("getSelectedNode");
+    expect(nodeTools).toHaveProperty("getEditableNode");
+    expect(nodeTools).toHaveProperty("refreshHighlightFrame");
+    expect(nodeTools).toHaveProperty("clearSelectedNode");
+    expect(nodeTools).toHaveProperty("cleanup");
+  });
+
+  it("should bind nodeTools to window", () => {
+    createNodeTools(nodeProvider);
+
+    expect(bindToWindowModule.bindToWindow).toHaveBeenCalledWith("nodeTools", expect.any(Object));
+  });
+
+  it("should setup event listeners", () => {
+    createNodeTools(nodeProvider);
+
+    expect(setupEventListenerModule.setupEventListener).toHaveBeenCalledWith(
+      nodeProvider,
+      expect.any(Function),
+      expect.any(Function),
+      mockText
+    );
+  });
+
+  it("should initialize with no selected node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    expect(nodeTools.getSelectedNode()).toBeNull();
+  });
+
+  it("should select a node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+
+    expect(nodeTools.getSelectedNode()).toBe(node);
+    expect(highlightNodeModule.highlightNode).toHaveBeenCalledWith(node);
+    expect(sendPostMessageModule.sendPostMessage).toHaveBeenCalledWith("selectedNodeChanged", "test-node-1");
+  });
+
+  it("should not select same node twice", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    vi.clearAllMocks();
+
+    nodeTools.selectNode(node);
+
+    // Should not call highlightNode again
+    expect(highlightNodeModule.highlightNode).not.toHaveBeenCalled();
+  });
+
+  it("should clear previous selection when selecting new node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+    const node2 = document.createElement("div");
+    node2.setAttribute("data-node-id", "test-node-2");
+    nodeProvider.appendChild(node2);
+
+    nodeTools.selectNode(node);
+    vi.clearAllMocks();
+
+    nodeTools.selectNode(node2);
+
+    expect(nodeTools.getSelectedNode()).toBe(node2);
+    expect(mockResizeObserver.disconnect).toHaveBeenCalled();
+  });
+
+  it("should clear selection when selecting null", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    nodeTools.selectNode(null);
+
+    expect(nodeTools.getSelectedNode()).toBeNull();
+    expect(clearHighlightFrameModule.clearHighlightFrame).toHaveBeenCalled();
+  });
+
+  it("should blur edit mode when selecting different node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+    const node2 = document.createElement("div");
+    node2.setAttribute("data-node-id", "test-node-2");
+    nodeProvider.appendChild(node2);
+
+    mockText.getEditableNode.mockReturnValue(node);
+    mockText.isEditing.mockReturnValue(true);
+
+    nodeTools.selectNode(node);
+    vi.clearAllMocks();
+
+    nodeTools.selectNode(node2);
+
+    expect(mockText.blurEditMode).toHaveBeenCalled();
+  });
+
+  it("should not blur edit mode when selecting same editable node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    mockText.getEditableNode.mockReturnValue(node);
+    mockText.isEditing.mockReturnValue(true);
+
+    nodeTools.selectNode(node);
+    vi.clearAllMocks();
+
+    nodeTools.selectNode(node);
+
+    expect(mockText.blurEditMode).not.toHaveBeenCalled();
+  });
+
+  it("should setup observers when selecting node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+
+    expect(connectResizeObserverModule.connectResizeObserver).toHaveBeenCalled();
+  });
+
+  it("should handle escape key when editing", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    mockText.isEditing.mockReturnValue(true);
+    nodeTools.selectNode(node);
+
+    // Get the escape handler from setupEventListener
+    const escapeHandler = vi.mocked(setupEventListenerModule.setupEventListener).mock.calls[0][2];
+    escapeHandler();
+
+    expect(mockText.blurEditMode).toHaveBeenCalled();
+  });
+
+  it("should handle escape key when node is selected", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+
+    const escapeHandler = vi.mocked(setupEventListenerModule.setupEventListener).mock.calls[0][2];
+    escapeHandler();
+
+    expect(clearHighlightFrameModule.clearHighlightFrame).toHaveBeenCalled();
+    expect(nodeTools.getSelectedNode()).toBeNull();
+  });
+
+  it("should handle escape key when no node is selected", () => {
+    createNodeTools(nodeProvider);
+
+    const escapeHandler = vi.mocked(setupEventListenerModule.setupEventListener).mock.calls[0][2];
+    escapeHandler();
+
+    expect(clearHighlightFrameModule.clearHighlightFrame).not.toHaveBeenCalled();
+  });
+
+  it("should refresh highlight frame", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    vi.clearAllMocks();
+
+    nodeTools.refreshHighlightFrame();
+
+    expect(refreshHighlightFrameModule.refreshHighlightFrame).toHaveBeenCalledWith(node, nodeProvider, "canvas");
+    expect(updateHighlightFrameVisibilityModule.updateHighlightFrameVisibility).toHaveBeenCalledWith(node);
+  });
+
+  it("should not refresh highlight frame when no node is selected", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.refreshHighlightFrame();
+
+    expect(refreshHighlightFrameModule.refreshHighlightFrame).not.toHaveBeenCalled();
+  });
+
+  it("should clear selected node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    nodeTools.clearSelectedNode();
+
+    expect(nodeTools.getSelectedNode()).toBeNull();
+    expect(clearHighlightFrameModule.clearHighlightFrame).toHaveBeenCalled();
+  });
+
+  it("should get editable node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    mockText.getEditableNode.mockReturnValue(node);
+
+    expect(nodeTools.getEditableNode()).toBe(node);
+  });
+
+  it("should cleanup all resources", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    nodeTools.cleanup();
+
+    expect(mockRemoveListeners).toHaveBeenCalled();
+    expect(mockText.blurEditMode).toHaveBeenCalled();
+    expect(clearHighlightFrameModule.clearHighlightFrame).toHaveBeenCalled();
+    expect(sendPostMessageModule.sendPostMessage).toHaveBeenCalledWith("selectedNodeChanged", null);
+  });
+
+  it("should work with null nodeProvider", () => {
+    const nodeTools = createNodeTools(null);
+
+    expect(() => {
+      nodeTools.selectNode(node);
+    }).not.toThrow();
+  });
+
+  it("should handle node removal detection", async () => {
+    const nodeTools = createNodeTools(nodeProvider);
+    const testNode = document.createElement("div");
+    testNode.setAttribute("data-node-id", "test-node-removal");
+    nodeProvider.appendChild(testNode);
+
+    nodeTools.selectNode(testNode);
+    expect(nodeTools.getSelectedNode()).toBe(testNode);
+
+    // Simulate node removal
+    nodeProvider.removeChild(testNode);
+
+    // Wait for mutation observer to process
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // The node should be cleared after removal
+    // Note: The mutation observer should detect the removal and clear the selection
+    expect(nodeTools.getSelectedNode()).toBeNull();
+  });
+
+  it("should use custom canvas name", () => {
+    const nodeTools = createNodeTools(nodeProvider, "custom-canvas");
+
+    nodeTools.selectNode(node);
+
+    expect(nodeTextModule.nodeText).toHaveBeenCalledWith("custom-canvas");
+  });
+
+  it("should send postMessage with node ID when selecting", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+
+    expect(sendPostMessageModule.sendPostMessage).toHaveBeenCalledWith("selectedNodeChanged", "test-node-1");
+  });
+
+  it("should send postMessage with null when clearing selection", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+    nodeTools.selectNode(null);
+
+    expect(sendPostMessageModule.sendPostMessage).toHaveBeenLastCalledWith("selectedNodeChanged", null);
+  });
+
+  it("should update highlight frame visibility when selecting node", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+
+    nodeTools.selectNode(node);
+
+    expect(updateHighlightFrameVisibilityModule.updateHighlightFrameVisibility).toHaveBeenCalledWith(node);
+  });
+
+  it("should handle multiple node selections", () => {
+    const nodeTools = createNodeTools(nodeProvider);
+    const node2 = document.createElement("div");
+    node2.setAttribute("data-node-id", "test-node-2");
+    nodeProvider.appendChild(node2);
+    const node3 = document.createElement("div");
+    node3.setAttribute("data-node-id", "test-node-3");
+    nodeProvider.appendChild(node3);
+
+    nodeTools.selectNode(node);
+    expect(nodeTools.getSelectedNode()).toBe(node);
+
+    nodeTools.selectNode(node2);
+    expect(nodeTools.getSelectedNode()).toBe(node2);
+
+    nodeTools.selectNode(node3);
+    expect(nodeTools.getSelectedNode()).toBe(node3);
+
+    nodeTools.selectNode(null);
+    expect(nodeTools.getSelectedNode()).toBeNull();
+  });
+});

package/src/lib/node-tools/events/click/handleNodeClick.test.ts

@@ -0,0 +1,109 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as clearHighlightFrameModule from "../../highlight/clearHighlightFrame";
+import * as selectNodeModule from "../../select/selectNode";
+import type { NodeText } from "../../text/types";
+import { handleNodeClick } from "./handleNodeClick";
+
+vi.mock("../../highlight/clearHighlightFrame");
+vi.mock("../../select/selectNode");
+
+describe("handleNodeClick", () => {
+  let nodeProvider: HTMLElement;
+  let node: HTMLElement;
+  let mockText: NodeText;
+  let onNodeSelected: ReturnType<typeof vi.fn>;
+  let mockEvent: MouseEvent;
+
+  beforeEach(() => {
+    nodeProvider = document.createElement("div");
+    nodeProvider.setAttribute("data-role", "node-provider");
+    document.body.appendChild(nodeProvider);
+
+    node = document.createElement("div");
+    node.setAttribute("data-node-id", "test-node");
+    nodeProvider.appendChild(node);
+
+    mockText = {
+      getEditableNode: vi.fn(),
+      enableEditMode: vi.fn(),
+      blurEditMode: vi.fn(),
+      isEditing: vi.fn(),
+    };
+
+    onNodeSelected = vi.fn();
+
+    mockEvent = new MouseEvent("click", {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(mockEvent, "target", { value: node, writable: false });
+
+    vi.mocked(clearHighlightFrameModule.clearHighlightFrame).mockImplementation(() => {});
+    vi.mocked(selectNodeModule.selectNode).mockReturnValue(node);
+  });
+
+  afterEach(() => {
+    if (document.body.contains(nodeProvider)) {
+      document.body.removeChild(nodeProvider);
+    }
+    vi.clearAllMocks();
+  });
+
+  it("should prevent default and stop propagation", () => {
+    const preventDefaultSpy = vi.spyOn(mockEvent, "preventDefault");
+    const stopPropagationSpy = vi.spyOn(mockEvent, "stopPropagation");
+
+    handleNodeClick(mockEvent, nodeProvider, mockText, onNodeSelected);
+
+    expect(preventDefaultSpy).toHaveBeenCalled();
+    expect(stopPropagationSpy).toHaveBeenCalled();
+  });
+
+  it("should clear highlight and call onNodeSelected with null when click is outside nodeProvider", () => {
+    const outsideElement = document.createElement("div");
+    document.body.appendChild(outsideElement);
+    const outsideEvent = new MouseEvent("click", {
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(outsideEvent, "target", { value: outsideElement, writable: false, configurable: true });
+
+    handleNodeClick(outsideEvent, nodeProvider, mockText, onNodeSelected);
+
+    expect(clearHighlightFrameModule.clearHighlightFrame).toHaveBeenCalled();
+    expect(onNodeSelected).toHaveBeenCalledWith(null);
+    expect(selectNodeModule.selectNode).not.toHaveBeenCalled();
+
+    document.body.removeChild(outsideElement);
+  });
+
+  it("should select node when click is inside nodeProvider", () => {
+    handleNodeClick(mockEvent, nodeProvider, mockText, onNodeSelected);
+
+    expect(selectNodeModule.selectNode).toHaveBeenCalledWith(mockEvent, nodeProvider, mockText);
+    expect(onNodeSelected).toHaveBeenCalledWith(node);
+  });
+
+  it("should work with null nodeProvider", () => {
+    handleNodeClick(mockEvent, null, mockText, onNodeSelected);
+
+    expect(selectNodeModule.selectNode).toHaveBeenCalledWith(mockEvent, null, mockText);
+  });
+
+  it("should handle when selectNode returns null", () => {
+    vi.mocked(selectNodeModule.selectNode).mockReturnValue(null);
+
+    handleNodeClick(mockEvent, nodeProvider, mockText, onNodeSelected);
+
+    expect(onNodeSelected).toHaveBeenCalledWith(null);
+  });
+
+  it("should handle when selectNode returns different node", () => {
+    const node2 = document.createElement("div");
+    vi.mocked(selectNodeModule.selectNode).mockReturnValue(node2);
+
+    handleNodeClick(mockEvent, nodeProvider, mockText, onNodeSelected);
+
+    expect(onNodeSelected).toHaveBeenCalledWith(node2);
+  });
+});

package/src/lib/node-tools/events/setupEventListener.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as processPostMessageModule from "@/lib/post-message/processPostMessage";
+import * as handleNodeClickModule from "./click/handleNodeClick";
+import { setupEventListener } from "./setupEventListener";
+import type { NodeText } from "../../text/types";
+
+vi.mock("@/lib/post-message/processPostMessage");
+vi.mock("./click/handleNodeClick");
+
+describe("setupEventListener", () => {
+  let nodeProvider: HTMLElement;
+  let onNodeSelected: ReturnType<typeof vi.fn>;
+  let onEscapePressed: ReturnType<typeof vi.fn>;
+  let mockText: NodeText;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    nodeProvider = document.createElement("div");
+    nodeProvider.setAttribute("data-role", "node-provider");
+    document.body.appendChild(nodeProvider);
+
+    onNodeSelected = vi.fn();
+    onEscapePressed = vi.fn();
+    mockText = {
+      getEditableNode: vi.fn(),
+      enableEditMode: vi.fn(),
+      blurEditMode: vi.fn(),
+      isEditing: vi.fn(),
+    };
+
+    vi.mocked(processPostMessageModule.processPostMessage).mockImplementation(() => {});
+    vi.mocked(handleNodeClickModule.handleNodeClick).mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    if (cleanup) {
+      cleanup();
+    }
+    if (document.body.contains(nodeProvider)) {
+      document.body.removeChild(nodeProvider);
+    }
+    vi.clearAllMocks();
+  });
+
+  it("should return cleanup function", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    expect(typeof cleanup).toBe("function");
+  });
+
+  it("should setup message event listener", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    const event = new MessageEvent("message", {
+      data: { source: "application", action: "selectedNodeChanged", data: "test" },
+    });
+    window.dispatchEvent(event);
+
+    expect(processPostMessageModule.processPostMessage).toHaveBeenCalledWith(event, onNodeSelected);
+  });
+
+  it("should setup click event listener", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    const event = new MouseEvent("click", { bubbles: true });
+    document.dispatchEvent(event);
+
+    expect(handleNodeClickModule.handleNodeClick).toHaveBeenCalledWith(event, nodeProvider, mockText, onNodeSelected);
+  });
+
+  it("should setup keydown event listener for Escape key", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    const event = new KeyboardEvent("keydown", { key: "Escape", bubbles: true, cancelable: true });
+    const preventDefaultSpy = vi.spyOn(event, "preventDefault");
+    const stopPropagationSpy = vi.spyOn(event, "stopPropagation");
+
+    document.dispatchEvent(event);
+
+    expect(preventDefaultSpy).toHaveBeenCalled();
+    expect(stopPropagationSpy).toHaveBeenCalled();
+    expect(onEscapePressed).toHaveBeenCalled();
+  });
+
+  it("should not call onEscapePressed for other keys", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    const event = new KeyboardEvent("keydown", { key: "Enter", bubbles: true });
+    document.dispatchEvent(event);
+
+    expect(onEscapePressed).not.toHaveBeenCalled();
+  });
+
+  it("should remove all event listeners on cleanup", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    cleanup();
+    vi.clearAllMocks();
+
+    const messageEvent = new MessageEvent("message", {
+      data: { source: "application", action: "selectedNodeChanged", data: "test" },
+    });
+    window.dispatchEvent(messageEvent);
+
+    const clickEvent = new MouseEvent("click", { bubbles: true });
+    document.dispatchEvent(clickEvent);
+
+    const keydownEvent = new KeyboardEvent("keydown", { key: "Escape", bubbles: true });
+    document.dispatchEvent(keydownEvent);
+
+    expect(processPostMessageModule.processPostMessage).not.toHaveBeenCalled();
+    expect(handleNodeClickModule.handleNodeClick).not.toHaveBeenCalled();
+    expect(onEscapePressed).not.toHaveBeenCalled();
+  });
+
+  it("should work with null nodeProvider", () => {
+    cleanup = setupEventListener(null, onNodeSelected, onEscapePressed, mockText);
+
+    const event = new MouseEvent("click", { bubbles: true });
+    document.dispatchEvent(event);
+
+    expect(handleNodeClickModule.handleNodeClick).toHaveBeenCalledWith(event, null, mockText, onNodeSelected);
+  });
+
+  it("should handle multiple escape presses", () => {
+    cleanup = setupEventListener(nodeProvider, onNodeSelected, onEscapePressed, mockText);
+
+    const event1 = new KeyboardEvent("keydown", { key: "Escape", bubbles: true });
+    const event2 = new KeyboardEvent("keydown", { key: "Escape", bubbles: true });
+    document.dispatchEvent(event1);
+    document.dispatchEvent(event2);
+
+    expect(onEscapePressed).toHaveBeenCalledTimes(2);
+  });
+});
+