Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

24.0 KB
Raw Blame
import { LinkFidelity, MarkdownManager, sharedExtensions } from '@inkeep/open-knowledge-core';
import * as actualHtmlToMdast from '@inkeep/open-knowledge-core/markdown/html-to-mdast';
import { Editor, type Extensions } from '@tiptap/core';
import StarterKit from '@tiptap/starter-kit';
import * as actualSonner from 'sonner';
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
import { createServedBindingLog } from '@/test-utils/served-binding.test-helper';
import { GfmAutolink } from '../gfm-autolink-plugin.ts';
import { flushMicrotasksAndTimers, installDomGlobals } from '../walk-currency-test-harness.ts';

const servedCore = createServedBindingLog();

vi.doMock('@inkeep/open-knowledge-core/markdown/html-to-mdast', () => {
  return servedCore.serve('@inkeep/open-knowledge-core/markdown/html-to-mdast', {
    ...actualHtmlToMdast,
    htmlToMdast: vi.fn((_html: string) => ({ type: 'root', children: [] })),
    mdastToMarkdown: vi.fn((_tree: unknown) => '**bold**'),
  });
});

vi.doMock('sonner', () => ({ ...actualSonner, toast: { error: vi.fn(() => {}) } }));

let createHandlePaste: typeof import('./handle-paste.ts').createHandlePaste;
beforeAll(async () => {
  ({ createHandlePaste } = await import('./handle-paste.ts'));
});

function fakeDT(data: Record<string, string>): ClipboardEvent {
  const evt = {
    clipboardData: {
      types: Object.keys(data),
      getData: (k: string) => data[k] ?? '',
    },
  } as unknown as ClipboardEvent;
  return evt;
}

function fakeMdManager() {
  return {
    parse: vi.fn((_md: string) => ({
      type: 'doc',
      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'parsed' }] }],
    })),
  };
}

// biome-ignore lint/suspicious/noExplicitAny: narrow fake view for unit test
function fakeView(opts: { inCodeBlock?: boolean } = {}): any {
  const dispatch = vi.fn(() => {});
  const codeBlockType = {
    create: vi.fn((_attrs: unknown, _content: unknown) => ({
      slice: (_f: number, _t: number) => 'CODE-SLICE',
    })),
  };
  const $from = {
    depth: 1,
    node: (_d: number) => ({ type: { name: opts.inCodeBlock ? 'codeBlock' : 'paragraph' } }),
  };
  return {
    state: {
      selection: { $from, empty: true },
      schema: {
        nodes: { codeBlock: codeBlockType },
        text: (s: string) => ({ textContent: s }),
        // biome-ignore lint/suspicious/noExplicitAny: fake schema for unit test
        nodeFromJSON: (json: any) => ({
          slice: (_f: number, _t: number) => ({ json, size: 10, content: { size: 10 } }),
          content: {
            size: 10,
            childCount: 1,
            // biome-ignore lint/suspicious/noExplicitAny: fake fragment child
            forEach: (fn: (child: any) => void) => fn({ type: { name: 'paragraph' } }),
          },
        }),
      },
      tr: {
        replaceSelectionWith: vi.fn(function (this: unknown, _node: unknown) {
          return this;
        }),
        replaceSelection: vi.fn(function (this: unknown, _slice: unknown) {
          return this;
        }),
        setMeta: vi.fn(function (this: unknown, _key: unknown, _value: unknown) {
          return this;
        }),
        scrollIntoView: vi.fn(function (this: unknown) {
          return this;
        }),
      },
    },
    dispatch,
  };
}

let origWarn: typeof console.warn;
beforeEach(() => {
  origWarn = console.warn;
  console.warn = () => {};
});
afterEach(() => {
  console.warn = origWarn;
});

describe('WYSIWYG paste dispatcher — branch routing', () => {
  test('empty clipboard returns false (PM default runs)', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView();
    const evt = {
      clipboardData: { types: [] as string[], getData: () => '' },
    } as unknown as ClipboardEvent;
    expect(paste(view, evt)).toBe(false);
  });

  test('FR-10: cursor-in-codeBlock short-circuits to plain-text insert', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView({ inCodeBlock: true });
    const evt = fakeDT({ 'text/plain': 'raw code', 'text/html': '<b>bold</b>' });
    expect(paste(view, evt)).toBe(true);
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });

  test('Branch A: vscode-editor-data produces a codeBlock with language', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'vscode-editor-data': '{"mode":"typescript"}',
      'text/plain': 'const x = 1;',
    });
    expect(paste(view, evt)).toBe(true);
    expect(view.state.schema.nodes.codeBlock.create).toHaveBeenCalledWith(
      { language: 'typescript' },
      expect.anything(),
    );
  });

  test('Branch A: unsanitized language falls back to empty lang string', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'vscode-editor-data': '{"mode":"ts\\n```evil"}',
      'text/plain': 'code',
    });
    paste(view, evt);
    expect(view.state.schema.nodes.codeBlock.create).toHaveBeenCalledWith(
      { language: '' },
      expect.anything(),
    );
  });

  test('Branch A: malformed vscode-editor-data JSON falls through to a later branch', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'vscode-editor-data': '{not json',
      'text/plain': 'fallback content',
    });
    expect(paste(view, evt)).toBe(true);
    expect(view.state.schema.nodes.codeBlock.create).not.toHaveBeenCalled();
  });

  test('Branch B: a throwing mdManager.parse falls through instead of escaping', () => {
    const throwingMd = {
      parse: vi.fn(() => {
        throw new Error('parse exploded');
      }),
    };
    // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
    const paste = createHandlePaste({ mdManager: throwingMd as any });
    const view = fakeView();
    const evt = fakeDT({ 'text/x-gfm': '# heading', 'text/plain': '# heading' });
    expect(paste(view, evt)).toBe(true);
    expect(throwingMd.parse).toHaveBeenCalled();
  });

  test('lone-URL cursor paste: a throwing mdManager.parse falls through to plain insert', () => {
    const throwingMd = {
      parse: vi.fn(() => {
        throw new Error('parse exploded');
      }),
    };
    // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
    const paste = createHandlePaste({ mdManager: throwingMd as any });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'https://example.com' });
    expect(paste(view, evt)).toBe(true);
    expect(throwingMd.parse).toHaveBeenCalled();
    expect(view.dispatch).toHaveBeenCalled();
  });

  test('Branch C: data-pm-slice fingerprint returns false (PM handles)', () => {
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: fakeMdManager() as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/html': '<div data-pm-slice="0 0 paragraph"><p>hi</p></div>',
      'text/plain': 'hi',
    });
    expect(paste(view, evt)).toBe(false);
  });

  test('Branch B: text/x-gfm routes through MarkdownManager.parse', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/x-gfm': '# gfm heading', 'text/plain': '# gfm heading' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('# gfm heading');
  });

  test('Branch B (FR-13 ambiguous): plain+html with markdown-shaped plain → markdown path wins', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const markdownPlain = '# H\n\n- a\n- b\n\n```\ncode\n```\n';
    const evt = fakeDT({
      'text/plain': markdownPlain,
      'text/html': '<h1>H</h1>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith(markdownPlain);
  });

  test('Branch D: generic HTML (no markdown signals in text/plain) goes through htmlToMdast', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': 'plain prose no signals',
      'text/html': '<p>rich <b>html</b></p>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('**bold**');
  });

  test('Branch E: text/plain only with markdown signals parses as markdown', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': '# H\n\n- a\n- b\n\n```\ncode\n```\n',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalled();
  });

  test('Branch E: text/plain only prose inserts verbatim (no markdown parse)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'hello world, plain prose' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });

  test('FR-17: Cmd+Shift+V (via injected shiftKey) → verbatim text/plain insert', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': '# H', 'text/html': '<h1>H</h1>' });
    Object.defineProperty(evt, 'shiftKey', { value: true, configurable: true });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
  });
});

describe('WYSIWYG paste dispatcher — core replacement liveness', () => {
  test('a generic HTML paste parses the markdown the html-to-mdast replacement serves', () => {
    const since = servedCore.mark();
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const evt = fakeDT({
      'text/plain': 'plain prose no signals',
      'text/html': '<p>rich <b>html</b></p>',
    });

    expect(paste(fakeView(), evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('**bold**');
    for (const member of ['htmlToMdast', 'mdastToMarkdown']) {
      expect(
        servedCore.readersOf('@inkeep/open-knowledge-core/markdown/html-to-mdast', member, since),
      ).toEqual(['editor/clipboard/handle-paste.ts']);
    }
  });
});

describe('WYSIWYG paste dispatcher — markdown-first tiebreak ordering (D5/D13)', () => {
  test('OK→OK <img/> JSX paste: markdown-first wins over Branch C data-pm-slice', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': '<img src="x.png" />',
      'text/html': '<div data-pm-slice="0 0 paragraph"><img src="x.png" /></div>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('<img src="x.png" />');
  });

  test('OK→OK <Callout> JSX paste: markdown-first wins over Branch C', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': '<Callout type="note">body</Callout>',
      'text/html':
        '<div data-pm-slice="0 0 paragraph"><pre><code>&lt;Callout&gt;</code></pre></div>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('<Callout type="note">body</Callout>');
  });

  test('Cross-PM-editor: markdown-canonical text/plain routes through markdown path even with PM slice', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': '# H\n\n- a\n- b\n',
      'text/html': '<div data-pm-slice="0 0 paragraph"><h1>H</h1></div>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('# H\n\n- a\n- b\n');
  });

  test('Branch C still fires when text/plain is non-markdown prose (no false-positive on heuristic)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': 'plain prose without markdown signals',
      'text/html':
        '<div data-pm-slice="0 0 paragraph"><p>plain prose without markdown signals</p></div>',
    });
    expect(paste(view, evt)).toBe(false);
    expect(md.parse).not.toHaveBeenCalled();
  });
});

describe('WYSIWYG paste dispatcher — lone-URL routing', () => {
  test('lone GFM URL at a cursor routes through the markdown parse (payload trimmed)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'https://inkeep.com\n' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('https://inkeep.com');
  });

  test('lone GFM URL wins over a text/html sibling (browser link-copy shape)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({
      'text/plain': 'https://inkeep.com',
      'text/html': '<a href="https://inkeep.com">https://inkeep.com</a>',
    });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).toHaveBeenCalledWith('https://inkeep.com');
  });

  test('lone non-GFM token (bare domain) at a cursor inserts verbatim', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'example.com' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });

  test('URL inside plain prose inserts verbatim (not a lone URL)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'see https://inkeep.com for the docs' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });

  test('Cmd+Shift+V of a lone URL pastes verbatim (plain-paste gate runs first)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView();
    const evt = fakeDT({ 'text/plain': 'https://inkeep.com' });
    Object.defineProperty(evt, 'shiftKey', { value: true, configurable: true });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });

  test('lone URL pasted into a codeBlock inserts verbatim (code gate runs first)', () => {
    const md = fakeMdManager();
    const paste = createHandlePaste({
      // biome-ignore lint/suspicious/noExplicitAny: narrow fake md manager
      mdManager: md as any,
    });
    const view = fakeView({ inCodeBlock: true });
    const evt = fakeDT({ 'text/plain': 'https://inkeep.com' });
    expect(paste(view, evt)).toBe(true);
    expect(md.parse).not.toHaveBeenCalled();
    expect(view.state.tr.replaceSelectionWith).toHaveBeenCalled();
  });
});

describe('WYSIWYG paste dispatcher — lone-URL linkification (real editor)', () => {
  let restoreDomGlobals: (() => void) | null = null;
  let mdManager: MarkdownManager;

  beforeAll(() => {
    restoreDomGlobals = installDomGlobals();
    mdManager = new MarkdownManager({ extensions: sharedExtensions });
  });
  afterAll(() => {
    restoreDomGlobals?.();
    restoreDomGlobals = null;
  });

  function makeRealEditor(content: string, extraExtensions: Extensions = []): Editor {
    const host = document.createElement('div');
    document.body.appendChild(host);
    return new Editor({
      element: host,
      content,
      extensions: [
        StarterKit.configure({ link: false }),
        LinkFidelity.configure({ autolink: false }),
        ...extraExtensions,
      ],
    });
  }

  function pasteInto(editor: Editor, data: Record<string, string>): boolean {
    const paste = createHandlePaste({ mdManager });
    return paste(editor.view, fakeDT(data));
  }

  function selectText(editor: Editor, text: string): void {
    const idx = editor.state.doc.textContent.indexOf(text);
    if (idx < 0) throw new Error(`selectText: "${text}" not in doc`);
    editor.commands.setTextSelection({ from: idx + 1, to: idx + 1 + text.length });
  }

  function linkMarks(editor: Editor): Array<{ text: string; attrs: Record<string, unknown> }> {
    const found: Array<{ text: string; attrs: Record<string, unknown> }> = [];
    editor.state.doc.descendants((node) => {
      if (!node.isText) return;
      const mark = node.marks.find((m) => m.type.name === 'link');
      if (mark) found.push({ text: node.text ?? '', attrs: mark.attrs });
    });
    return found;
  }

  test('cursor paste of a URL creates a gfm-autolink mark over the bare literal', () => {
    const editor = makeRealEditor('<p></p>');
    try {
      expect(pasteInto(editor, { 'text/plain': 'https://inkeep.com' })).toBe(true);
      expect(editor.state.doc.textContent).toBe('https://inkeep.com');
      const marks = linkMarks(editor);
      expect(marks).toHaveLength(1);
      expect(marks[0]?.text).toBe('https://inkeep.com');
      expect(marks[0]?.attrs.href).toBe('https://inkeep.com');
      expect(marks[0]?.attrs.linkStyle).toBe('gfm-autolink');
    } finally {
      editor.destroy();
    }
  });

  test('cursor paste of a bare domain stays plain text', () => {
    const editor = makeRealEditor('<p></p>');
    try {
      expect(pasteInto(editor, { 'text/plain': 'example.com' })).toBe(true);
      expect(editor.state.doc.textContent).toBe('example.com');
      expect(linkMarks(editor)).toHaveLength(0);
    } finally {
      editor.destroy();
    }
  });

  test('paste over a selection keeps the selected text and links it', () => {
    const editor = makeRealEditor('<p>read the docs today</p>');
    try {
      selectText(editor, 'docs');
      expect(pasteInto(editor, { 'text/plain': 'https://inkeep.com' })).toBe(true);
      expect(editor.state.doc.textContent).toBe('read the docs today');
      const marks = linkMarks(editor);
      expect(marks).toHaveLength(1);
      expect(marks[0]?.text).toBe('docs');
      expect(marks[0]?.attrs.href).toBe('https://inkeep.com');
      expect(marks[0]?.attrs.linkStyle).toBe('inline');
    } finally {
      editor.destroy();
    }
  });

  test.each([
    ['example.com', 'https://example.com'],
    ['www.example.com', 'https://www.example.com'],
    ['[email protected]', 'mailto:[email protected]'],
  ])('paste of %s over a selection links to %s', (payload, expectedHref) => {
    const editor = makeRealEditor('<p>read the docs today</p>');
    try {
      selectText(editor, 'docs');
      expect(pasteInto(editor, { 'text/plain': payload })).toBe(true);
      expect(editor.state.doc.textContent).toBe('read the docs today');
      expect(linkMarks(editor)[0]?.attrs.href).toBe(expectedHref);
    } finally {
      editor.destroy();
    }
  });

  test('paste of a non-allowlisted scheme over a selection never links — the payload lands as inert plain text', () => {
    const editor = makeRealEditor('<p>read the docs today</p>');
    try {
      selectText(editor, 'docs');
      pasteInto(editor, { 'text/plain': 'javascript:alert(1)' });
      expect(linkMarks(editor)).toHaveLength(0);
      expect(editor.state.doc.textContent).toBe('read the javascript:alert(1) today');
    } finally {
      editor.destroy();
    }
  });

  test('paste of a URL over a code-marked selection falls through to a plain replace', () => {
    const editor = makeRealEditor('<p>run <code>bun install</code> now</p>');
    try {
      selectText(editor, 'install');
      pasteInto(editor, { 'text/plain': 'https://inkeep.com' });
      expect(linkMarks(editor)).toHaveLength(0);
      expect(editor.state.doc.textContent).toBe('run bun https://inkeep.com now');
    } finally {
      editor.destroy();
    }
  });

  test('paste of a URL over a cross-block selection falls through (no link mark)', () => {
    const editor = makeRealEditor('<p>one</p><p>two</p>');
    try {
      editor.commands.setTextSelection({ from: 2, to: 8 });
      pasteInto(editor, { 'text/plain': 'https://inkeep.com' });
      expect(linkMarks(editor)).toHaveLength(0);
      expect(editor.state.doc.textContent).toContain('https://inkeep.com');
    } finally {
      editor.destroy();
    }
  });

  test('paste of a URL over already-linked text re-points the link, keeping the text', () => {
    const editor = makeRealEditor('<p><a href="https://old.example">docs</a> page</p>');
    try {
      selectText(editor, 'docs');
      expect(pasteInto(editor, { 'text/plain': 'https://new.example' })).toBe(true);
      expect(editor.state.doc.textContent).toBe('docs page');
      const marks = linkMarks(editor);
      expect(marks).toHaveLength(1);
      expect(marks[0]?.text).toBe('docs');
      expect(marks[0]?.attrs.href).toBe('https://new.example');
    } finally {
      editor.destroy();
    }
  });

  test('pasted prose ending in a URL + space is never linkified by the typed-autolink plugin', async () => {
    const editor = makeRealEditor('<p></p>', [
      GfmAutolink.configure({ isActiveEditor: () => true }),
    ]);
    try {
      expect(pasteInto(editor, { 'text/plain': 'see https://inkeep.com ' })).toBe(true);
      await flushMicrotasksAndTimers();
      expect(linkMarks(editor)).toHaveLength(0);
      expect(editor.state.doc.textContent).toBe('see https://inkeep.com ');
    } finally {
      editor.destroy();
    }
  });

  test('lone-URL cursor paste with the typed-autolink plugin active yields exactly one mark', async () => {
    const editor = makeRealEditor('<p></p>', [
      GfmAutolink.configure({ isActiveEditor: () => true }),
    ]);
    try {
      pasteInto(editor, { 'text/plain': 'https://inkeep.com' });
      await flushMicrotasksAndTimers();
      const marks = linkMarks(editor);
      expect(marks).toHaveLength(1);
      expect(marks[0]?.attrs.linkStyle).toBe('gfm-autolink');
    } finally {
      editor.destroy();
    }
  });
});