[Init] Initial commit - NetMesh terminal manager

infrastructure/monaco/monacoClipboardPaste.test.ts

@@ -0,0 +1,207 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  buildMonacoPasteEdits,
+  isMonacoFindWidgetFocused,
+  isStillFocusedFindPasteTarget,
+  pasteForMonacoEditorCommand,
+  pasteTextIntoFocusedInput,
+  readClipboardTextWithFallbacks,
+  type FocusedTextInput,
+} from './monacoClipboardPaste.ts';
+
+function createMockTextInput(initialValue = ''): FocusedTextInput & {
+  selectionStart: number;
+  selectionEnd: number;
+} {
+  let selectionStart = initialValue.length;
+  let selectionEnd = initialValue.length;
+  return {
+    value: initialValue,
+    get selectionStart() {
+      return selectionStart;
+    },
+    set selectionStart(value: number) {
+      selectionStart = value;
+    },
+    get selectionEnd() {
+      return selectionEnd;
+    },
+    set selectionEnd(value: number) {
+      selectionEnd = value;
+    },
+    focus() {},
+    setSelectionRange(start: number, end: number) {
+      selectionStart = start;
+      selectionEnd = end;
+    },
+  };
+}
+
+test('buildMonacoPasteEdits pastes full text at a single cursor', () => {
+  const edits = buildMonacoPasteEdits('hello\nworld', [
+    { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+  ]);
+  assert.deepEqual(edits, [
+    {
+      range: { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+      text: 'hello\nworld',
+      forceMoveMarkers: true,
+    },
+  ]);
+});
+
+test('buildMonacoPasteEdits spreads one line per cursor when counts match', () => {
+  const edits = buildMonacoPasteEdits('one\ntwo', [
+    { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+    { startLineNumber: 2, startColumn: 1, endLineNumber: 2, endColumn: 1 },
+  ]);
+  assert.equal(edits.length, 2);
+  assert.equal(edits[0]?.text, 'one');
+  assert.equal(edits[1]?.text, 'two');
+});
+
+test('buildMonacoPasteEdits does not spread when line and cursor counts differ', () => {
+  const edits = buildMonacoPasteEdits('only-one-line', [
+    { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+    { startLineNumber: 2, startColumn: 1, endLineNumber: 2, endColumn: 1 },
+  ]);
+  assert.equal(edits[0]?.text, 'only-one-line');
+  assert.equal(edits[1]?.text, 'only-one-line');
+});
+
+test('buildMonacoPasteEdits returns empty when there are no selections', () => {
+  assert.deepEqual(buildMonacoPasteEdits('text', []), []);
+});
+
+test('readClipboardTextWithFallbacks prefers navigator clipboard', async () => {
+  const text = await readClipboardTextWithFallbacks({
+    readNavigator: async () => 'from-navigator',
+    readBridge: async () => {
+      throw new Error('bridge should not run');
+    },
+  });
+  assert.equal(text, 'from-navigator');
+});
+
+test('readClipboardTextWithFallbacks uses bridge when navigator fails', async () => {
+  const text = await readClipboardTextWithFallbacks({
+    readNavigator: async () => {
+      throw new Error('denied');
+    },
+    readBridge: async () => 'from-bridge',
+  });
+  assert.equal(text, 'from-bridge');
+});
+
+test('readClipboardTextWithFallbacks returns null when both paths fail', async () => {
+  const text = await readClipboardTextWithFallbacks({
+    readNavigator: async () => {
+      throw new Error('denied');
+    },
+    readBridge: async () => {
+      throw new Error('unavailable');
+    },
+  });
+  assert.equal(text, null);
+});
+
+test('isMonacoFindWidgetFocused detects elements inside .find-widget', () => {
+  const findInput = {
+    closest: (selector: string) => (selector === '.find-widget' ? {} : null),
+  };
+  const otherInput = {
+    closest: () => null,
+  };
+  assert.equal(isMonacoFindWidgetFocused(findInput), true);
+  assert.equal(isMonacoFindWidgetFocused(otherInput), false);
+  assert.equal(isMonacoFindWidgetFocused(null), false);
+});
+
+test('pasteTextIntoFocusedInput replaces the current selection', () => {
+  const input = createMockTextInput('hello');
+  input.setSelectionRange(0, 5);
+  assert.equal(pasteTextIntoFocusedInput(input, 'world'), true);
+  assert.equal(input.value, 'world');
+  assert.equal(input.selectionStart, 5);
+  assert.equal(input.selectionEnd, 5);
+});
+
+test('pasteTextIntoFocusedInput rejects non-input targets', () => {
+  assert.equal(pasteTextIntoFocusedInput({ closest: () => ({}) }, 'x'), false);
+});
+
+test('pasteForMonacoEditorCommand pastes into find widget and skips editor body', async () => {
+  const input = Object.assign(createMockTextInput(''), {
+    closest: (selector: string) => (selector === '.find-widget' ? {} : null),
+  });
+  let bodyPasteCount = 0;
+  await pasteForMonacoEditorCommand({
+    activeElement: input,
+    readClipboardText: async () => 'search-me',
+    pasteIntoEditor: () => {
+      bodyPasteCount += 1;
+    },
+  });
+
+  assert.equal(input.value, 'search-me');
+  assert.equal(bodyPasteCount, 0);
+});
+
+test('pasteForMonacoEditorCommand falls through to editor body outside find widget', async () => {
+  let bodyPasteCount = 0;
+  await pasteForMonacoEditorCommand({
+    activeElement: null,
+    readClipboardText: async () => {
+      throw new Error('should not read clipboard for body path');
+    },
+    pasteIntoEditor: () => {
+      bodyPasteCount += 1;
+    },
+  });
+  assert.equal(bodyPasteCount, 1);
+});
+
+test('isStillFocusedFindPasteTarget rejects targets no longer inside the find widget', () => {
+  const leftFind = {
+    closest: () => null,
+  };
+  assert.equal(isStillFocusedFindPasteTarget(leftFind), false);
+  assert.equal(isStillFocusedFindPasteTarget(null), false);
+});
+
+test('pasteForMonacoEditorCommand aborts if focus leaves the find field mid clipboard read', async () => {
+  const input = Object.assign(createMockTextInput('keep'), {
+    closest: (selector: string) => (selector === '.find-widget' ? {} : null),
+  });
+  // Simulate a browser document where focus moved away during the await.
+  const previousDocument = (globalThis as { document?: Document }).document;
+  Object.defineProperty(globalThis, 'document', {
+    configurable: true,
+    value: { activeElement: { id: 'editor-body' } },
+  });
+
+  let bodyPasteCount = 0;
+  try {
+    await pasteForMonacoEditorCommand({
+      activeElement: input,
+      readClipboardText: async () => 'should-not-apply',
+      pasteIntoEditor: () => {
+        bodyPasteCount += 1;
+      },
+    });
+  } finally {
+    if (previousDocument === undefined) {
+      delete (globalThis as { document?: Document }).document;
+    } else {
+      Object.defineProperty(globalThis, 'document', {
+        configurable: true,
+        value: previousDocument,
+      });
+    }
+  }
+
+  assert.equal(input.value, 'keep');
+  assert.equal(bodyPasteCount, 0);
+});