Clipboard and markdown

import { createFullEditor, createMinimalEditor, HtmlPasteExtension, NabuPasteExtension, MarkdownPasteExtension, PlainTextPasteExtension } from '@aionbuilders/nabu';

// The interpreters are plain objects of the extensions: read one format, return a fragment (or null).
const [html] = HtmlPasteExtension.pasteInterpreters;
const [nabuJson] = NabuPasteExtension.pasteInterpreters;
const [markdown] = MarkdownPasteExtension.pasteInterpreters;
const [plain] = PlainTextPasteExtension.pasteInterpreters;
expect([nabuJson.priority, html.priority, markdown.priority, plain.priority]).toEqual([100, 50, 25, 0]);

const engine = createFullEditor();

// A paste of markdown text: one line is one block.
const fragment = markdown.interpret('# Title\nfirst line\nsecond line', engine);
expect(fragment.blocks.map((block) => block.type)).toEqual(['heading', 'paragraph', 'paragraph']);

// Importing markdown joins consecutive lines (CommonMark).
const joined = markdown.interpret('first line\nsecond line', engine, { joinLines: true });
expect(joined.blocks).toHaveLength(1);

// A clipboard fragment of a version this editor does not know is declined, not mis-read.
expect(nabuJson.interpret(JSON.stringify({ version: 99, blocks: [] }), engine)).toBeNull();

// A fragment is adapted to the receiving editor: a heading pasted into a paragraph-only editor stays as text.
const minimal = createMinimalEditor();
await minimal.importFragment({
  blocks: [{ type: 'heading', partial: false, props: { level: 2 }, delta: [{ insert: 'Title' }] }]
});
expect(minimal.children.map((block) => block.type)).toEqual(['paragraph']);
expect(minimal.serialize('markdown')).toBe('Title');

import { createTextEditor } from '@aionbuilders/nabu';
import { extension } from '@aionbuilders/nabu/extend';

// Reads tab-separated text as one paragraph per row, cells joined with " | ".
const Tsv = extension('tsv-paste', {
  pasteInterpreters: [
    {
      format: 'text/plain',
      priority: 40, // above markdown (25): asked first
      interpret(raw) {
        if (!raw.includes('\t')) return null; // decline: the next interpreter reads it
        const rows = raw.split('\n').map((row) => row.split('\t').join(' | '));
        return { blocks: rows.map((row) => ({ type: 'paragraph', partial: false, delta: [{ insert: row }] })) };
      }
    }
  ]
});

const engine = createTextEditor({ extensions: [Tsv] });
const [interpreter] = Tsv.pasteInterpreters;

await engine.importFragment(interpreter.interpret('a\tb\nc\td', engine));
expect(engine.serialize('markdown')).toBe('a | b\n\nc | d');
expect(interpreter.interpret('no tab here', engine)).toBeNull();

import { createFullEditor } from '@aionbuilders/nabu';

const source = [
  '# Title',
  '',
  'A paragraph with **bold**, *italic*, ~~gone~~, `code` and [a link](https://example.com).',
  '',
  '> A quote',
  '',
  '> [!TIP]',
  '> Useful',
  '',
  '```js',
  'let a = 1;',
  '```',
  '',
  '---',
  '',
  '- one',
  '- two',
  '  - nested',
  '',
  '1. first',
  '2. second',
  '',
  '- [ ] to do',
  '- [x] done',
  '',
  '<details open>',
  '<summary>More</summary>',
  '',
  'Hidden **text**',
  '',
  '</details>',
  '',
  '-- Hello there',
  '',
  '![alt text](https://example.com/a.png)'
].join('\n');

const engine = createFullEditor();
await engine.importMarkdown(source);

// Every block type above is read back as itself...
expect(engine.serialize('json').blocks.map((block) => block.type)).toEqual([
  'heading', 'paragraph', 'blockquote', 'callout', 'code', 'divider',
  'list', 'list', 'list', 'toggle', 'dialogue', 'image'
]);
// ...and written back exactly as it was read.
expect(engine.serialize('markdown')).toBe(source);

import { createFullEditor } from '@aionbuilders/nabu';

const engine = createFullEditor();
await engine.importMarkdown('<details>\n<summary>Header, **inline**</summary>\n\nBody\n\n</details>');

const toggle = engine.serialize('json').blocks[0];
expect(toggle).toMatchObject({ type: 'toggle', props: { collapsed: true } }); // no `open`: collapsed
expect(engine.serialize('markdown')).toBe('<details>\n<summary>Header, **inline**</summary>\n\nBody\n\n</details>');

// Any other markup is plain text: no tag, no attribute, no HTML is ever passed through.
const other = createFullEditor();
await other.importMarkdown('<details class="x">\n<summary>Head</summary>\n\nBody\n\n</details>');
expect(other.serialize('json').blocks.every((block) => block.type === 'paragraph')).toBe(true);

import { createFullEditor } from '@aionbuilders/nabu';

const source = [
  'Before the first region.',
  '',
  '<!-- region:section-1 {} -->',
  '# One',
  '',
  'Text of one.',
  '',
  '<!-- region:section-2 {} -->',
  '## A sub-section',
  '',
  'Text of the sub-section.',
  '',
  '<!-- region:section-1 {} -->',
  '# Two'
].join('\n');

const engine = createFullEditor();
await engine.importMarkdown(source);

expect(engine.regions.list.map((region) => region.title)).toEqual(['One', 'A sub-section', 'Two']);
expect(engine.regions.tree[1].title).toBe('Two');
expect(engine.serialize('markdown')).toBe(source);

import { createFullEditor } from '@aionbuilders/nabu';

const engine = createFullEditor();
await engine.importMarkdown('First\n\nSecond');
engine.insert('paragraph', { text: '' }); // an empty block...
await engine.commit();

expect(engine.children).toHaveLength(3);
expect(engine.serialize('markdown')).toBe('First\n\nSecond'); // ...has no markdown

// JSON keeps it.
expect(engine.serialize('json').blocks).toHaveLength(3);

import { createFullEditor, HtmlPasteExtension, deltaToHtml, sanitizeUrl } from '@aionbuilders/nabu';

const engine = createFullEditor();
const [html] = HtmlPasteExtension.pasteInterpreters;

const fragment = html.interpret(
  '<h2>Title</h2><p>A <strong>bold</strong> <a href="javascript:alert(1)">bad</a> and <a href="https://example.dev">good</a> link.<script>alert(1)</script></p>',
  engine
);
await engine.importFragment(fragment);

// The unsafe link keeps its text and loses its href; the script is gone entirely.
expect(engine.serialize('markdown')).toBe('## Title\n\nA **bold** bad and [good](https://example.dev) link.');

// The same rules in a JSON import.
await engine.importJSON({
  version: '1',
  blocks: [{ type: 'paragraph', content: [{ text: 'bad', link: 'javascript:alert(1)' }, { text: ' and ' }, { text: 'good', link: 'https://example.dev' }] }]
});
expect(engine.serialize('markdown')).toBe('bad and [good](https://example.dev)');

// The helpers are public: sanitizeUrl returns the URL, or null.
expect(sanitizeUrl('https://example.dev')).toBe('https://example.dev');
expect(sanitizeUrl('/relative/path')).toBe('/relative/path');
expect(sanitizeUrl('javascript:alert(1)')).toBeNull();
expect(sanitizeUrl('data:text/html,x')).toBeNull();
expect(sanitizeUrl('data:image/png;base64,AAAA', { kind: 'media' })).not.toBeNull();

// deltaToHtml escapes the text and drops an unsafe href.
expect(deltaToHtml([{ insert: '<b>', attributes: { bold: true } }])).toBe('<strong>&lt;b&gt;</strong>');
expect(deltaToHtml([{ insert: 'x', attributes: { link: 'javascript:1' } }])).toBe('x');