[Init] Initial commit - NetMesh terminal manager

components/terminal/copyOnSelect.test.ts

@@ -0,0 +1,304 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  COPY_ON_SELECT_USER_GESTURE_RELEASE_MS,
+  createCopyOnSelectUserGestureTracker,
+  pulseCopyOnSelectUserCommand,
+  shouldWriteCopyOnSelect,
+  subscribeCopyOnSelectUserCommand,
+  subscribeCopyOnSelectUserGesture,
+} from "./copyOnSelect.ts";
+
+test("copy-on-select writes only after a user selection gesture", () => {
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: true,
+  }), true);
+});
+
+test("copy-on-select skips SearchAddon and other programmatic selections", () => {
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: false,
+  }), false);
+});
+
+test("copy-on-select still skips restore and attach snapshots", () => {
+  assert.equal(shouldWriteCopyOnSelect({
+    allowCopy: false,
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: true,
+  }), false);
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: true,
+    isUserSelection: true,
+  }), false);
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: false,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: true,
+  }), false);
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: false,
+    isRestoringSelection: false,
+    isUserSelection: true,
+  }), false);
+});
+
+test("user gesture stays armed until shortly after pointer-up", () => {
+  assert.ok(COPY_ON_SELECT_USER_GESTURE_RELEASE_MS < 200);
+
+  const scheduled: Array<{ cb: () => void; ms: number }> = [];
+  const tracker = createCopyOnSelectUserGestureTracker({
+    setTimeoutFn: ((cb: () => void, ms?: number) => {
+      scheduled.push({ cb, ms: ms ?? 0 });
+      return scheduled.length as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  assert.equal(tracker.isActive(), false);
+  tracker.mark();
+  assert.equal(tracker.isActive(), true);
+
+  tracker.release();
+  assert.equal(tracker.isActive(), true);
+  assert.equal(scheduled.at(-1)?.ms, COPY_ON_SELECT_USER_GESTURE_RELEASE_MS);
+
+  // A later SearchAddon revival (200ms) must not still look like a drag.
+  scheduled.at(-1)?.cb();
+  assert.equal(tracker.isActive(), false);
+
+  tracker.dispose();
+});
+
+test("marking again cancels a pending release so a new drag can copy", () => {
+  const cleared: number[] = [];
+  let nextId = 1;
+  const tracker = createCopyOnSelectUserGestureTracker({
+    setTimeoutFn: ((cb: () => void) => {
+      const id = nextId;
+      nextId += 1;
+      void cb;
+      return id as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: ((id: ReturnType<typeof setTimeout>) => {
+      cleared.push(id as unknown as number);
+    }) as typeof clearTimeout,
+  });
+
+  tracker.mark();
+  tracker.release();
+  tracker.mark();
+
+  assert.deepEqual(cleared, [1]);
+  assert.equal(tracker.isActive(), true);
+  tracker.dispose();
+});
+
+const listenerKey = (
+  type: string,
+  options?: boolean | AddEventListenerOptions,
+): string => {
+  const capture = options === true || (
+    typeof options === "object" && options?.capture === true
+  );
+  return `${type}:${capture ? "capture" : "bubble"}`;
+};
+
+const createEventTargetStub = () => {
+  const listeners = new Map<string, Set<EventListener>>();
+  return {
+    addEventListener(
+      type: string,
+      listener: EventListener,
+      options?: boolean | AddEventListenerOptions,
+    ) {
+      const key = listenerKey(type, options);
+      const set = listeners.get(key) ?? new Set();
+      set.add(listener);
+      listeners.set(key, set);
+    },
+    removeEventListener(
+      type: string,
+      listener: EventListener,
+      options?: boolean | AddEventListenerOptions,
+    ) {
+      listeners.get(listenerKey(type, options))?.delete(listener);
+    },
+    dispatch(type: string, event: Event, phase: "capture" | "bubble") {
+      for (const listener of listeners.get(`${type}:${phase}`) ?? []) {
+        listener(event);
+      }
+    },
+  };
+};
+
+const eventOn = (type: string, target: EventTarget): Event => {
+  const event = new Event(type);
+  Object.defineProperty(event, "target", { value: target });
+  return event;
+};
+
+test("pointer listeners mark on capture down and release on document up", () => {
+  const el = createEventTargetStub();
+  const root = createEventTargetStub();
+  const view = createEventTargetStub();
+  let marked = 0;
+  let pulsed = 0;
+  let released = 0;
+  const unsubscribe = subscribeCopyOnSelectUserGesture(
+    { element: el },
+    {
+      mark: () => {
+        marked += 1;
+      },
+      release: () => {
+        released += 1;
+      },
+      pulse: () => {
+        pulsed += 1;
+      },
+    },
+    root,
+    view,
+  );
+
+  root.dispatch("mousedown", eventOn("mousedown", el), "capture");
+  root.dispatch("mouseup", eventOn("mouseup", el), "bubble");
+  root.dispatch("contextmenu", eventOn("contextmenu", el), "capture");
+  root.dispatch("touchcancel", eventOn("touchcancel", el), "bubble");
+  view.dispatch("blur", eventOn("blur", el), "bubble");
+  assert.equal(marked, 1);
+  assert.equal(released, 3);
+  assert.equal(pulsed, 1);
+
+  unsubscribe();
+  root.dispatch("mousedown", eventOn("mousedown", el), "capture");
+  root.dispatch("mouseup", eventOn("mouseup", el), "bubble");
+  root.dispatch("touchcancel", eventOn("touchcancel", el), "bubble");
+  view.dispatch("blur", eventOn("blur", el), "bubble");
+  assert.equal(marked, 1);
+  assert.equal(released, 3);
+  assert.equal(pulsed, 1);
+});
+
+test("late contextmenu after mouseup is a one-shot and then releases", () => {
+  const scheduled: Array<() => void> = [];
+  const tracker = createCopyOnSelectUserGestureTracker({
+    setTimeoutFn: ((cb: () => void) => {
+      scheduled.push(cb);
+      return scheduled.length as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  tracker.mark();
+  tracker.release();
+  // Windows: contextmenu after mouseup used to cancel this timer and stick.
+  tracker.pulse();
+  assert.equal(tracker.isActive(), true);
+  scheduled.at(-1)?.();
+  assert.equal(tracker.isActive(), false);
+
+  tracker.dispose();
+});
+
+test("document-capture contextmenu still counts when the terminal never sees the bubble", () => {
+  const el = createEventTargetStub();
+  const outside = createEventTargetStub();
+  const root = createEventTargetStub();
+  let pulsed = 0;
+  subscribeCopyOnSelectUserGesture(
+    { element: el },
+    {
+      mark: () => {},
+      release: () => {},
+      pulse: () => {
+        pulsed += 1;
+      },
+    },
+    root,
+  );
+
+  // tmux/vim capture handler on the container stops the event before
+  // term.element bubble listeners would run.
+  root.dispatch("contextmenu", eventOn("contextmenu", el), "capture");
+  root.dispatch("contextmenu", eventOn("contextmenu", outside), "capture");
+  assert.equal(pulsed, 1);
+});
+
+test("user-invoked Select All pulses only the selected terminal", () => {
+  let pulsedA = 0;
+  let pulsedB = 0;
+  const terminalA = { id: "a" };
+  const terminalB = { id: "b" };
+  const unsubscribeA = subscribeCopyOnSelectUserCommand(terminalA, () => {
+    pulsedA += 1;
+  });
+  const unsubscribeB = subscribeCopyOnSelectUserCommand(terminalB, () => {
+    pulsedB += 1;
+  });
+
+  pulseCopyOnSelectUserCommand(terminalA);
+  assert.equal(pulsedA, 1);
+  assert.equal(pulsedB, 0);
+
+  unsubscribeA();
+  unsubscribeB();
+  pulseCopyOnSelectUserCommand(terminalA);
+  assert.equal(pulsedA, 1);
+  assert.equal(pulsedB, 0);
+});
+
+test("issue 3007: search match then later revival does not copy", () => {
+  const scheduled: Array<() => void> = [];
+  const tracker = createCopyOnSelectUserGestureTracker({
+    setTimeoutFn: ((cb: () => void) => {
+      scheduled.push(cb);
+      return scheduled.length as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  // Typing in the search bar selects the match with no terminal pointer.
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: tracker.isActive(),
+  }), false);
+
+  // User drag-selects a docker image id in the buffer.
+  tracker.mark();
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: tracker.isActive(),
+  }), true);
+  tracker.release();
+  scheduled.at(-1)?.();
+
+  // Opening the snippet dialog resizes the terminal; SearchAddon re-selects
+  // the search term. Clipboard must stay on the image id.
+  assert.equal(shouldWriteCopyOnSelect({
+    hasText: true,
+    copyOnSelect: true,
+    isRestoringSelection: false,
+    isUserSelection: tracker.isActive(),
+  }), false);
+
+  tracker.dispose();
+});