, + * the class giving it a line's height): it gets a line break, so it is not taken for markup around nothing. + */ +function keepBlankLines(body) { + for (const p of body.querySelectorAll('p')) { + if (p.textContent.trim() || p.querySelector('img, br, table, ul, ol')) continue; + if (Number.parseFloat(p.style?.height) > 0) p.append(p.ownerDocument.createElement('br')); + } +} + +/** + * Lists a page nests by class rather than by markup, as Google Docs writes them: every level is a list of its own + * (class lst-kix_
Sales in the caf=C3=A9 grew by 12 % and kept grow=', 'ing.
| A | B |
Na'), 0xef, ...strToU8('ve r'), 0xe9, ...strToU8('sum'), 0xe9, ...strToU8('
')]); + const body = 'Plan
+
After a blank line
+End
`; + +test('a Google Docs web page opens with its blank lines and nested, numbered lists', async ({ page }) => { + await page.goto('/mock.html#/new'); + await expect(page.getByRole('button', { name: 'Bold', exact: true })).toBeEnabled(); + await page.locator('input[type=file][aria-label="Open DOCX file"]').setInputFiles({ name: 'Plan.html', mimeType: 'text/html', buffer: Buffer.from(PAGE) }); + const input = page.getByRole('textbox', { name: 'Document text' }); + await expect(input).toHaveValue('Plan\n\nAfter a blank line\nOne\nDetail\nTwo\n\nEnd'); + const lists = await page.evaluate(() => window.__docs.current.view.engine.model.paragraphs.map(p => p.list?.level ?? null)); + expect(lists).toEqual([null, null, null, 0, 1, 0, null, null]); + await expect(page.locator('.editor-error')).toHaveCount(0); +}); diff --git a/src/documents/tests/browser/group-stacking.spec.js b/src/documents/tests/browser/group-stacking.spec.js new file mode 100644 index 000000000..20b7cd385 --- /dev/null +++ b/src/documents/tests/browser/group-stacking.spec.js @@ -0,0 +1,95 @@ +import { test, expect } from '@playwright/test'; +import { onTab } from './helpers/editor-tools.js'; + +// Group keeps the objects stacked as they were: one in front stays in front inside the group, whichever +// is anchored first in the text; Ungroup puts the objects back in the group's place among the others. +const input = page => page.getByRole('textbox', { name: 'Document text' }); +const drawings = page => page.evaluate(() => { + const m = window.__docs.current.view.engine.model; + let at = 0; const out = []; + for (const p of m.paragraphs) { for (const r of p.runs) { if (r.image?.anchor) out.push({ at, order: r.image.anchor.order, kind: (/prst="(\w+)"/.exec(r.image.shell || '') || [])[1], shapes: [...(r.image.shell || '').matchAll(/Quarterly report
Revenue grew 4%.
`; + +async function open(page, name, mimeType, source) { + await page.goto('/mock.html#/new'); + await expect(page.getByRole('button', { name: 'Bold', exact: true })).toBeEnabled(); + await page.locator('input[type=file][aria-label="Open DOCX file"]').setInputFiles({ name, mimeType, buffer: Buffer.from(source) }); + await expect(page.getByRole('textbox', { name: 'Document name' })).toHaveValue(name.replace(/\.\w+$/, '')); +} + +test('a web page holding an embedded copy opens as the page reads', async ({ page }) => { + await open(page, 'page.html', 'text/html', `${EMBEDDED}`); + await expect(input(page)).toHaveValue('Quarterly report\nRevenue grew 4%.'); +}); + +test('a Markdown file holding an embedded copy opens as the file reads', async ({ page }) => { + await open(page, 'notes.md', 'text/markdown', `# Notes\n\n${EMBEDDED}\n\nLast line.\n`); + await expect(input(page)).toHaveValue('Notes\nQuarterly report\nRevenue grew 4%.\nLast line.'); +}); + +test('Text from File reads a web page holding an embedded copy as the page reads', async ({ page }) => { + // Wide enough that the Insert tab's Text group shows its buttons with any system font. + await page.setViewportSize({ width: 1440, height: 900 }); + await page.goto('/playground.html'); + await page.getByRole('button', { name: 'New', exact: true }).click(); + await input(page).fill('Start'); + await page.locator('#ribbon-tab-insert').click(); + await page.locator('#ribbon-panel-insert').getByRole('button', { name: 'Object', exact: true }).click(); + const chooser = page.waitForEvent('filechooser'); + await page.getByRole('menuitem', { name: 'Text from File…' }).click(); + await input(page).press('ControlOrMeta+End'); + await (await chooser).setFiles({ name: 'page.html', mimeType: 'text/html', buffer: Buffer.from(`${EMBEDDED}`) }); + await expect.poll(() => input(page).inputValue()).toMatch(/Quarterly report\nRevenue grew 4%\.$/); +}); diff --git a/src/documents/tests/browser/justification.spec.js b/src/documents/tests/browser/justification.spec.js index 97f5e8ce6..1ba48e076 100644 --- a/src/documents/tests/browser/justification.spec.js +++ b/src/documents/tests/browser/justification.spec.js @@ -85,12 +85,40 @@ test('uses native shaping for expanded spaces, matches paint widths and keeps zo test('previews unsupported justification as read-only with the original available', async ({ page }) => { const input = await fixture(page), text = await input.inputValue(); - for (const [from, to, error] of [['Just a phrase
').paragraphs[0].mark).toBe(false); }); @@ -92,3 +92,25 @@ it('writes tel: and mailto: links into the copied HTML, and never unsafe schemes const anchors = [...new DOMParser().parseFromString(html, 'text/html').querySelectorAll('a')].map(a => [a.textContent, a.getAttribute('href')]); expect(anchors).toEqual([['Call', 'tel:+1-555-0100'], [' mail', 'mailto:a@example.com']]); }); + +it('keeps a link whose address has spaces or line breaks around it, as a browser follows it', () => { + const links = html => htmlFragment(html)?.paragraphs.flatMap(p => p.runs.filter(r => r.link).map(r => [r.text, r.link])); + expect(links('See the site.
')).toEqual([['the site', 'https://example.com/a']]); + expect(links('')).toEqual([['Write', 'mailto:someone@example.com']]); + // An address that is not a web, mail or phone link still gives no link. + expect(links('')).toEqual([]); +}); + +it('keeps a table row on one line when its cells hold paragraphs, as Word, LibreOffice and Google Docs write them', () => { + expect(texts('Name | Qty |
Apples | 3 |
Item | Two lines |
After
')).toEqual(['Item\tTwo lines', 'After']); + expect(texts('Head | Plain |
|---|
Bold word Slanted word
')) + .toEqual([['Bold word', true, false], [' ', false, false], ['Slanted word', false, true]]); + // A weight or style of its own still counts. + expect(runs('Bold plain
')).toEqual([['Bold ', true, false], ['plain', false, false]]); +}); diff --git a/src/documents/tests/clipboard-objects.test.js b/src/documents/tests/clipboard-objects.test.js index 07fb4ee87..bc69f0483 100644 --- a/src/documents/tests/clipboard-objects.test.js +++ b/src/documents/tests/clipboard-objects.test.js @@ -20,6 +20,17 @@ it('copies fields as their results, equations as their text and drops bare objec expect(note.clipboardText((run, at) => run.noteMark && at === 5 ? '1' : '?')).toBe('Claim1'); }); +it('copies a table in a selection as one line per row with a tab between cells', () => { + const d = new TextDocument([paragraph('Before')]); + d.select(6); d.insertTable(2, 3); + for (const [i, text] of ['a1', 'b1', 'c1', 'a2', 'b2', 'c2'].entries()) { if (i) d.moveCell(1); d.replace(text); } + // A second paragraph in a cell stays on its own line, as in other word processors. + d.select(d.text.indexOf('b2') + 2); d.insertParagraph(); d.replace('more'); + d.select(d.text.length); d.replace('After'); + d.select(0, d.text.length); + expect(d.clipboardText()).toBe('Before\na1\tb1\tc1\na2\tb2\nmore\tc2\nAfter'); +}); + let editor; afterEach(() => { editor?.destroy(); document.body.replaceChildren(); vi.restoreAllMocks(); }); diff --git a/src/documents/tests/collab-binding.test.js b/src/documents/tests/collab-binding.test.js index cc559317d..cfe3c2703 100644 --- a/src/documents/tests/collab-binding.test.js +++ b/src/documents/tests/collab-binding.test.js @@ -199,6 +199,42 @@ describe('co-editing binding', () => { expect(bob.engine.viewOnly).toBe(false); }); + it('sends a picture added in single-editor mode to the others with its bytes', async () => { + const { people: [ann, bob] } = await room('form'); + ann.engine.execute(m => { m.paragraphs[0].runs.push({ ...m.paragraphs[0].runs[0], text: '', contentControl: { id: 7, placeholder: true } }); m.didChange(); }); + await settle(); + expect(ann.binding.mode).toBe('single'); + ann.engine.execute(m => { m.assets.logo = { bytes: new Uint8Array([137, 80, 78, 71]), mime: 'image/png' }; m.select(0); m.insertImage('logo', { width: 100, height: 100 }); }); + await settle(); + const run = bob.engine.model.paragraphs[0].runs.find(r => r.image); + expect(run).toBeTruthy(); + // Without the picture's bytes the others cannot show it, and the owner's tab cannot save the file. + expect(bob.engine.session.body.assets[run.image.assetId]?.bytes).toEqual(new Uint8Array([137, 80, 78, 71])); + // Its id is this person's own, so it cannot stand for another picture someone else adds. + expect(run.image.assetId).toMatch(/@/); + }); + + it('undoes and redoes the single editor\'s own changes, and shares the result', async () => { + const { people: [ann, bob] } = await room('form'); + // An empty form field, which the shared text cannot hold, as an opened form brings one. + ann.engine.execute(m => { m.paragraphs[0].runs = [...m.paragraphs[0].runs, { ...m.paragraphs[0].runs[0], text: '', contentControl: { id: 7, persistent: true } }]; m.didChange(); }); + await settle(); + expect(ann.binding.mode).toBe('single'); + ann.engine.execute(m => { m.select(0); m.replace('Typed '); }); + await settle(); + expect(bob.engine.model.text).toBe('Typed form'); + expect(ann.engine.session.history.length).toBeGreaterThan(0); + ann.engine.undo(); + await settle(); + expect(ann.engine.model.text).toBe('form'); + expect(bob.engine.model.text).toBe('form'); + expect([ann.engine.session.future.length, ann.binding.mode, ann.binding.holdsLock()]).toEqual([1, 'single', true]); + ann.engine.redo(); + await settle(); + expect(ann.engine.model.text).toBe('Typed form'); + expect(bob.engine.model.text).toBe('Typed form'); + }); + it('gives people stable, readable colors and parses links', () => { expect(colorFor('alice')).toBe(colorFor('alice')); expect(PERSON_COLORS).toContain(colorFor('bob')); diff --git a/src/documents/tests/collab-outbox-account.test.js b/src/documents/tests/collab-outbox-account.test.js new file mode 100644 index 000000000..f347e0306 --- /dev/null +++ b/src/documents/tests/collab-outbox-account.test.js @@ -0,0 +1,43 @@ +import { it, expect, beforeEach, afterEach } from 'vitest'; + +/** Just enough of IndexedDB for the outbox: one store, put/getAll/delete, completing after the calls. */ +function memoryIndexedDB() { + const rows = new Map(); + const store = { + put: item => { rows.set(item.key, structuredClone(item)); return {}; }, + delete: key => { rows.delete(key); return {}; }, + getAll: () => ({ result: [...rows.values()].map(r => structuredClone(r)) }), + }; + const db = { transaction: () => { const tx = { objectStore: () => store }; setTimeout(() => tx.oncomplete?.(), 0); return tx; } }; + return { rows, open: () => { const request = { result: db }; setTimeout(() => { request.onupgradeneeded?.(); request.onsuccess?.(); }, 0); request.result.createObjectStore = () => store; return request; } }; +} + +let idb; +beforeEach(() => { idb = memoryIndexedDB(); globalThis.indexedDB = idb; }); +afterEach(() => { delete globalThis.indexedDB; }); + +const { Outbox, CollabClient } = await import('../src/collab/client.js'); + +it('gives back only the changes this account left undelivered in a room, keeping the others\' for them', async () => { + const ann = new Outbox('room1', 's1', 'ann-uuid'); + await ann.add(new Uint8Array([1, 2, 3])); + await new Outbox('room2', 's2', 'ann-uuid').add(new Uint8Array([9])); + // Someone else signs in on this computer and opens the same shared document. + const bob = new Outbox('room1', 's3', 'bob-uuid'); + expect(await bob.restore()).toEqual([]); + // Ann's change waits for her, in its room only. + const again = await new Outbox('room1', 's4', 'ann-uuid').restore(); + expect(again.map(item => [...item.update])).toEqual([[1, 2, 3]]); + expect(idb.rows.size).toBe(2); +}); + +it('leaves changes kept before they named their account alone, rather than sending them as whoever opens the room', async () => { + idb.rows.set('legacy', { key: 'legacy', room: 'room1', at: 1, seq: 0, update: new Uint8Array([7]) }); + expect(await new Outbox('room1', 's1', 'bob-uuid').restore()).toEqual([]); + expect(idb.rows.has('legacy')).toBe(true); +}); + +it('names the person\'s account on what a client keeps', () => { + const client = new CollabClient({ transport: {}, user: { id: 'ann-uuid', name: 'Ann' }, room: 'room1' }); + expect(client.outbox.account).toBe('ann-uuid'); +}); diff --git a/src/documents/tests/collab-reconnect.test.js b/src/documents/tests/collab-reconnect.test.js new file mode 100644 index 000000000..2c051d38d --- /dev/null +++ b/src/documents/tests/collab-reconnect.test.js @@ -0,0 +1,27 @@ +import { it, expect, vi, beforeEach } from 'vitest'; + +let failure = null; +const forgotten = []; +vi.mock('../src/collab/api.js', async (importOriginal) => ({ ...await importOriginal(), call: async () => { throw failure; } })); +vi.mock('../src/collab/room-memory.js', async (importOriginal) => ({ ...await importOriginal(), rememberRoom: async (path, link) => { forgotten.push([path, link]); } })); +const { reconnect } = await import('../src/collab/live.js'); + +const saved = { server: 'https://documents-abc.puter.work', room: 'room1' }; +const user = { id: 'u0', name: 'Ada' }; +beforeEach(() => { forgotten.length = 0; }); + +it('forgets a room whose sharing was stopped, and opens the document as the owner\'s own', async () => { + for (const status of [404, 410]) { + failure = Object.assign(new Error('This shared document is no longer available.'), { status }); + expect(await reconnect('Documents/Plan.docx', user, saved)).toBeNull(); + } + expect(forgotten).toEqual([['Documents/Plan.docx', null], ['Documents/Plan.docx', null]]); +}); + +it('says so when the room cannot be reached just now, and keeps it', async () => { + for (const status of [0, 500, 503]) { + failure = Object.assign(new Error('Failed to fetch'), { status }); + await expect(reconnect('Documents/Plan.docx', user, saved)).rejects.toThrow('Failed to fetch'); + } + expect(forgotten).toEqual([]); +}); diff --git a/src/documents/tests/collab-reopen-hold.test.js b/src/documents/tests/collab-reopen-hold.test.js index 7fc36f4ae..7c4a552b0 100644 --- a/src/documents/tests/collab-reopen-hold.test.js +++ b/src/documents/tests/collab-reopen-hold.test.js @@ -9,13 +9,15 @@ import { CollabClient } from '../src/collab/client.js'; import { MemoryHub } from '../src/collab/transports.js'; const hub = new MemoryHub(Y.encodeStateAsUpdate(createSharedDoc(editorState({ session: { body: new TextDocument([paragraph('Shared')]), storyEdits: {} } })))); -let release = null, remembered = null; +let release = null, remembered = null, failures = 0; vi.mock('../src/collab/room-memory.js', async (importOriginal) => ({ ...await importOriginal(), rememberedRoom: async () => remembered })); vi.mock('../src/collab/live.js', async (importOriginal) => ({ ...await importOriginal(), // Joining the owner's room takes a few round trips; the test decides when they end. reconnect: async () => { await new Promise(resolve => { release = resolve; }); + // The service could not be reached (a network failure, a server error): the room is still there. + if (failures > 0) { failures--; throw Object.assign(new Error('Failed to fetch'), { status: 0 }); } const client = new CollabClient({ transport: hub.connect('owner'), user: { id: 'u0', name: 'Ada' }, room: 'room1', sendDelay: 0 }); await client.connect(); return { client, link: { server: 'https://documents-abc.puter.work', room: 'room1' } }; @@ -84,3 +86,26 @@ it('keeps Viewing chosen while the room was joined', async () => { expect(engine.viewOnly).toBe(true); collab.destroy(); }); + +it('stays read-only with a way to try again when the room of a reopened shared document cannot be reached', async () => { + remembered = { server: 'https://documents-abc.puter.work', room: 'room1' }; + release = null; failures = 1; + const engine = new FakeEngine('Shared'); + const collab = open(engine); + collab.attach(); + await vi.waitFor(() => expect(release).toBeTypeOf('function')); + const first = release; + release = null; + first(); + // Edits made now would neither reach the others nor survive: the room's state replaces the editor's once joined. + await vi.waitFor(() => expect(collab.banner.textContent).toContain('Could not connect to the shared document')); + expect(engine.viewOnly).toBe(true); + expect(collab.live).toBeNull(); + const retry = [...collab.banner.querySelectorAll('button')].find(b => b.textContent === 'Try Again'); + retry.click(); + await vi.waitFor(() => expect(release).toBeTypeOf('function')); + release(); + await vi.waitFor(() => expect(collab.live).not.toBeNull()); + expect(engine.viewOnly).toBe(false); + collab.destroy(); +}); diff --git a/src/documents/tests/collab-saver-handoff.test.js b/src/documents/tests/collab-saver-handoff.test.js index 2934c3354..8ad9984f6 100644 --- a/src/documents/tests/collab-saver-handoff.test.js +++ b/src/documents/tests/collab-saver-handoff.test.js @@ -77,4 +77,20 @@ describe('the owner tab that saves a shared document', () => { expect(await P.__files.get(PATH).blob.text()).toBe('Shared plan!'); second.live.destroy(); }); + + it('keeps saving when someone without the owner\'s role claims to save the file', async () => { + const hub = new MemoryHub(Y.encodeStateAsUpdate(createSharedDoc(editorState({ session: { body: new TextDocument([paragraph('Shared')]), storyEdits: {} } })))); + const owner = await ownerTab(hub, 'b'); + await settle(); + expect(owner.doc.writes).toBe(true); + // An editor's (modified) client says it saves, from a session that sorts before the owner's; the service stamps + // each presence with its sender's role. + const guest = hub.connect('editor'); + await guest.join({ update() {}, presence() {}, role() {} }); + guest.presence({ session: '0', role: 'editor', saves: true, at: Date.now() }); + await settle(); + expect(owner.live.saves).toBe(true); + expect(owner.doc.writes).toBe(true); + owner.live.destroy(); + }); }); diff --git a/src/documents/tests/collab-shared-doc.test.js b/src/documents/tests/collab-shared-doc.test.js index 03a28191f..36f8a817a 100644 --- a/src/documents/tests/collab-shared-doc.test.js +++ b/src/documents/tests/collab-shared-doc.test.js @@ -205,3 +205,110 @@ describe('shared document mapping', () => { expect(readBody(ydoc.getText('body')).map(p => p.runs.map(r => r.text).join(''))).toEqual(['loose']); }); }); + +describe('typing in a table while someone else changes its structure', () => { + // A 3×2 table after "Intro": cells in reading order are [r1c1, r1c2, r2c1, r2c2, r3c1, r3c2]. + const start = () => { + const seed = new TextDocument([paragraph('Intro')]); + seed.select(5); seed.insertTable(3, 2); + const origin = createSharedDoc(stateOf(seed)); + const update = Y.encodeStateAsUpdate(origin); + // Fixed client ids: Yjs orders insertions made at one place at the same moment by them. + return ['ann', 'bob'].map((name, i) => { const d = new Y.Doc(); d.clientID = 1000 + i; Y.applyUpdate(d, update); return new Peer(name, d); }); + }; + const cells = m => (m.tables[0]?.rows || []).flatMap(r => r.cells.map(c => c.id)); + const at = (m, cellId) => { m.select(m.paragraphOffset(m.paragraphs.findIndex(p => p.cellId === cellId))); }; + const holder = (m, text) => m.paragraphs.find(p => p.runs.some(r => r.text.includes(text)))?.cellId; + const cases = { + 'inserts a row': (m, ids) => { at(m, ids[0]); m.insertTableRow(); }, + 'deletes a row': (m, ids) => { at(m, ids[0]); m.deleteTablePart('row'); }, + 'inserts a column': (m, ids) => { at(m, ids[0]); m.insertTableColumn(); }, + 'deletes a column': (m, ids) => { at(m, ids[0]); m.deleteTablePart('column'); }, + 'merges cells': (m, ids) => { const a = m.paragraphOffset(m.paragraphs.findIndex(p => p.cellId === ids[0])), b = m.paragraphOffset(m.paragraphs.findIndex(p => p.cellId === ids[1])); m.select(a, b); m.mergeCells(); }, + }; + // The cell typed in: not one a new row or column goes right before (see below). + const targets = { 'inserts a row': 3, 'deletes a row': 3, 'inserts a column': 2, 'deletes a column': 3, 'merges cells': 3 }; + for (const [name, change] of Object.entries(cases)) { + it(`keeps text typed in another cell in that cell when someone ${name}`, () => { + const [ann, bob] = start(); + const ids = cells(ann.model), target = ids[targets[name]]; + ann.edit(m => change(m, ids)); + bob.edit(m => { at(m, target); m.replace('B2'); }); + deliverAll([ann, bob]); + for (const peer of [ann, bob]) { + expect(holder(peer.model, 'B2'), `${peer.name}`).toBe(target); + // The table reads back whole: every cell has its paragraphs, in reading order. + expect(() => modelFrom(readState(peer.ydoc))).not.toThrow(); + } + expect(bob.ydoc.getText('body').toString()).toBe(ann.ydoc.getText('body').toString()); + expect(JSON.stringify(visible(bob.model))).toBe(JSON.stringify(visible(ann.model))); + }); + } + it('keeps text typed in a cell someone else merges into the cell beside it, in the merged cell', () => { + const [ann, bob] = start(); + const ids = cells(ann.model); + ann.edit(m => cases['merges cells'](m, ids)); + bob.edit(m => { at(m, ids[1]); m.replace('B1'); }); + deliverAll([ann, bob]); + for (const peer of [ann, bob]) { + expect(() => modelFrom(readState(peer.ydoc))).not.toThrow(); + expect(holder(peer.model, 'B1')).toBe(ids[0]); + } + expect(bob.ydoc.getText('body').toString()).toBe(ann.ydoc.getText('body').toString()); + }); + it('keeps text typed in a row someone else deletes, and the table whole', () => { + const [ann, bob] = start(); + const ids = cells(ann.model); + ann.edit(m => { at(m, ids[2]); m.deleteTablePart('row'); }); + bob.edit(m => { at(m, ids[3]); m.replace('Lost?'); }); + deliverAll([ann, bob]); + for (const peer of [ann, bob]) { + expect(() => modelFrom(readState(peer.ydoc))).not.toThrow(); + expect(peer.model.tables[0].rows).toHaveLength(2); + // No paragraph refers to a cell that is gone. + const live = new Set(cells(peer.model)); + expect(peer.model.paragraphs.filter(p => p.cellId && !live.has(p.cellId))).toEqual([]); + // What was typed there is kept, in the cell after it. + expect(holder(peer.model, 'Lost?')).toBe(ids[4]); + } + expect(bob.ydoc.getText('body').toString()).toBe(ann.ydoc.getText('body').toString()); + }); + + it('stays whole and keeps everyone\'s typing under random row and column changes by one person', () => { + // Typing goes on after text already in a cell. (Typing into an empty cell right where someone else inserts a row + // or column at the same moment can still land in a new cell: the two insertions share one place in the text.) + const filled = () => { + const seed = new TextDocument([paragraph('Intro')]); + seed.select(5); seed.insertTable(3, 2); + seed.tables[0].rows.flatMap(r => r.cells).forEach((c, i) => { seed.selectCell(c.id); seed.replace(`c${i}`); }); + const update = Y.encodeStateAsUpdate(createSharedDoc(stateOf(seed))); + return ['ann', 'bob'].map((name, i) => { const d = new Y.Doc(); d.clientID = 1000 + i; Y.applyUpdate(d, update); return new Peer(name, d); }); + }; + const end = (m, cellId) => { const i = m.paragraphs.findLastIndex(p => p.cellId === cellId); m.select(m.paragraphOffset(i) + m.paragraphs[i].runs.reduce((n, r) => n + r.text.length, 0)); }; + for (let seed = 1; seed <= 40; seed++) { + const rnd = random(seed); + const [ann, bob] = filled(); + const typed = []; + for (let step = 0; step < 12; step++) { + const ids = cells(ann.model); + if (!ids.length) break; + const pick = () => ids[Math.floor(rnd() * ids.length)]; + const kind = ['inserts a row', 'deletes a row', 'inserts a column', 'deletes a column'][Math.floor(rnd() * 4)]; + try { ann.edit(m => cases[kind](m, [pick(), pick()])); } catch { /* a change the table refuses (the last row, say) */ } + const own = cells(bob.model).filter(id => bob.model.paragraphs.some(p => p.cellId === id && p.runs.some(r => r.text))); + if (!own.length) continue; + const cell = own[Math.floor(rnd() * own.length)], word = `w${seed}x${step}z`; + bob.edit(m => { end(m, cell); m.replace(rnd() < 0.2 ? `${word}\n${word}b` : word); }); + typed.push([word, cell]); + if (rnd() < 0.6) deliverAll([ann, bob]); + } + deliverAll([ann, bob]); deliverAll([ann, bob]); + expect(bob.ydoc.getText('body').toString(), `seed ${seed}`).toBe(ann.ydoc.getText('body').toString()); + const model = modelFrom(readState(ann.ydoc)); + const live = new Set(cells(model)); + expect(model.paragraphs.filter(p => p.cellId && !live.has(p.cellId)), `seed ${seed}`).toEqual([]); + // What was typed in a cell that is still there is in that cell. + for (const [word, cell] of typed) if (live.has(cell)) expect(holder(model, word), `seed ${seed} ${word}`).toBe(cell); + } + }); +}); diff --git a/src/documents/tests/comment-column.test.js b/src/documents/tests/comment-column.test.js new file mode 100644 index 000000000..96eb3134f --- /dev/null +++ b/src/documents/tests/comment-column.test.js @@ -0,0 +1,170 @@ +// @vitest-environment jsdom +import { beforeEach, afterEach, it, expect, vi } from 'vitest'; +import { CanvasEditor } from '../src/engine/canvas-editor.js'; +import { paragraph } from '../src/engine/model.js'; +import { createReview } from '../src/views/review.js'; +import { revisionView } from '../src/engine/revisions.js'; + +let editor, host, review; +beforeEach(() => { + vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({ + fontKerning: 'auto', getTransform: () => ({ a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }), measureText: text => ({ width: [...text].length * 8 }), + setTransform() {}, fillRect() {}, fillText() {}, save() {}, restore() {}, beginPath() {}, rect() {}, clip() {}, moveTo() {}, lineTo() {}, stroke() {}, setLineDash() {}, + }); + host = document.createElement('div'); document.body.append(host); +}); +afterEach(() => { review?.destroy(); editor?.destroy(); review = editor = null; document.body.replaceChildren(); vi.restoreAllMocks(); }); + +function open(texts) { + editor = new CanvasEditor(host, { paragraphs: texts.map(text => paragraph(text)), comments: [] }); + review = createReview({ editor: () => editor, pkg: () => ({}), host: () => host, error: e => { throw e; }, author: () => 'Ada' }); + review.refresh(true); + return editor; +} +const card = id => review.layer.querySelector(`[data-thread="${id}"]`); +const type = (textarea, text) => { textarea.value = text; textarea.dispatchEvent(new Event('input')); }; + +it('keeps a reply and an edit being written when the column is rebuilt around them', () => { + open(['First paragraph here.', 'Second paragraph here.']); + const first = editor.model.addComment({ author: 'Ada', text: 'One', range: [0, 5] }); + const second = editor.model.addComment({ author: 'Grace', text: 'Two', range: [22, 28] }); + review.refresh(true); + type(card(first).querySelector('.wcc-reply textarea'), 'Half a reply'); + // The caret goes into the other thread (a click in the document): the column is rebuilt. + editor.model.select(24, 24); review.refresh(); + expect(card(second).classList.contains('is-active')).toBe(true); + expect(card(first).querySelector('.wcc-reply textarea').value).toBe('Half a reply'); + expect(card(first).querySelector('.wcc-reply .wcc-post').disabled).toBe(false); + // Sending it posts the words and leaves the box empty. + card(first).querySelector('.wcc-reply .wcc-post').click(); + expect(editor.model.comments.at(-1)).toMatchObject({ text: 'Half a reply', parentId: first }); + expect(card(first).querySelector('.wcc-reply textarea').value).toBe(''); + // An edit in progress survives the same way, and Cancel forgets it. + review.commands.selectThreadById(second); + card(second).querySelector('.wcc-more').click(); + document.querySelector('[role="menuitem"]').click(); + type(card(second).querySelector('.wcc-entry.is-editing textarea'), 'Two, edited'); + editor.model.select(2, 2); review.refresh(); review.refresh(true); + expect(card(second).querySelector('.wcc-entry.is-editing textarea').value).toBe('Two, edited'); + card(second).querySelector('.wcc-entry.is-editing .wcc-cancel').click(); + expect(editor.model.comments.find(c => c.id === second).text).toBe('Two'); +}); + +it('stacks the cards above the active one down from the top instead of piling them up there', () => { + open(['One two three four five six seven.', 'Second paragraph.']); + const ids = [[0, 3], [4, 7], [8, 13], [14, 18], [19, 23]].map(([a, b], i) => editor.model.addComment({ author: 'Ada', text: `c${i}`, range: [a, b] })); + editor.relayout(); + review.commands.selectThreadById(ids[4]); + review.refresh(true); + const tops = ids.map(id => parseFloat(card(id).style.top)); + expect(card(ids[4]).classList.contains('is-active')).toBe(true); + // Each card starts below the one before it (a card is 80 pixels high where nothing is laid out). + for (let i = 1; i < tops.length; i++) expect(tops[i], `card ${i}`).toBeGreaterThanOrEqual(tops[i - 1] + 88); + expect(tops[0]).toBeGreaterThanOrEqual(8); +}); + +it('keeps a new comment, a reply or an edit the document refuses, to post again', async () => { + open(['First paragraph here.', 'Second paragraph here.']); + const first = editor.model.addComment({ author: 'Ada', text: 'One', range: [0, 5] }); + review.refresh(true); + // Protection that allows no comment changes. + editor.session.guard = () => { throw new Error('This document is protected: comments cannot be changed.'); }; + editor.model.select(22, 28); + review.commands.newComment(); + type(review.layer.querySelector('.ed-comment-draft textarea'), 'A long thought'); + review.layer.querySelector('.ed-comment-draft .wcc-post').click(); + expect(editor.model.comments).toHaveLength(1); + expect(review.layer.querySelector('.ed-comment-draft textarea').value).toBe('A long thought'); + await Promise.resolve(); + expect(document.activeElement).toBe(review.layer.querySelector('.ed-comment-draft textarea')); + review.layer.querySelector('.ed-comment-draft .wcc-cancel').click(); + review.commands.selectThreadById(first); + type(card(first).querySelector('.wcc-reply textarea'), 'A reply'); + card(first).querySelector('.wcc-reply .wcc-post').click(); + expect(editor.model.comments).toHaveLength(1); + expect(card(first).querySelector('.wcc-reply textarea').value).toBe('A reply'); + card(first).querySelector('.wcc-more').click(); + document.querySelector('[role="menuitem"]').click(); + type(card(first).querySelector('.wcc-entry.is-editing textarea'), 'One, edited'); + card(first).querySelector('.wcc-entry.is-editing .wcc-post').click(); + expect(editor.model.comments[0].text).toBe('One'); + expect(card(first).querySelector('.wcc-entry.is-editing textarea').value).toBe('One, edited'); + // Allowed again, they post. + editor.session.guard = null; + card(first).querySelector('.wcc-entry.is-editing .wcc-post').click(); + card(first).querySelector('.wcc-reply .wcc-post').click(); + expect(editor.model.comments.map(c => c.text)).toEqual(['One, edited', 'A reply']); + expect(card(first).querySelector('.wcc-reply textarea').value).toBe(''); +}); + +it('offers no new comment where the document\'s protection allows none', () => { + editor = new CanvasEditor(host, { paragraphs: [paragraph('Protected text.')], comments: [] }); + let protection = { edit: 'readOnly', enforcement: true }; + const errors = []; + review = createReview({ editor: () => editor, pkg: () => ({}), host: () => host, error: e => errors.push(e.message), author: () => 'Ada', hooks: { protection: () => protection } }); + editor.model.addComment({ author: 'Grace', text: 'Earlier', range: [10, 14] }); + review.refresh(true); + editor.model.select(0, 9); + expect(review.commands.canComment()).toBe(false); + // The thread already there cannot be answered, resolved or changed either. + expect(review.layer.querySelector('.wcc-reply')).toBeNull(); + expect(review.layer.querySelector('.wcc-more').disabled).toBe(true); + review.commands.newComment(); + expect(review.layer.querySelector('.ed-comment-draft')).toBeNull(); + expect(errors).toEqual(['This document is protected: comments cannot be added.']); + protection = { edit: 'forms', enforcement: true }; + expect(review.commands.canComment()).toBe(false); + // Protected for comments only, or not at all, a comment can be started. + for (protection of [{ edit: 'comments', enforcement: true }, null]) expect(review.commands.canComment()).toBe(true); + review.commands.newComment(); + expect(review.layer.querySelector('.ed-comment-draft')).not.toBeNull(); +}); + +it('tells assistive technology which person the arrow keys choose to mention', () => { + editor = new CanvasEditor(host, { paragraphs: [paragraph('Some text to discuss.')], comments: [] }); + review = createReview({ editor: () => editor, pkg: () => ({}), host: () => host, error: e => { throw e; }, author: () => 'Ada', hooks: { people: () => ['Ada Lovelace', 'Alan Turing', 'Grace Hopper'] } }); + review.refresh(true); + editor.model.select(0, 4); + review.commands.newComment(); + const box = review.layer.querySelector('.ed-comment-draft textarea'), list = review.layer.querySelector('.wcc-mentions'); + box.focus(); + expect(box.getAttribute('aria-controls')).toBe(list.id); + box.value = 'Ask @A'; box.setSelectionRange(6, 6); box.dispatchEvent(new Event('input')); + expect(list.hidden).toBe(false); + const options = [...list.querySelectorAll('[role="option"]')]; + expect(options.map(o => o.textContent)).toEqual(['ALAda Lovelace', 'ATAlan Turing']); + expect(box.getAttribute('aria-activedescendant')).toBe(options[0].id); + box.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true })); + expect(box.getAttribute('aria-activedescendant')).toBe(options[1].id); + expect(options[1].getAttribute('aria-selected')).toBe('true'); + expect(options.every(o => o.tabIndex === -1)).toBe(true); + box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })); + expect(list.hidden).toBe(true); + expect(box.hasAttribute('aria-activedescendant')).toBe(false); +}); + +it('hides the comments in No Markup and Original, and going to a comment shows the markup again', () => { + open(['First paragraph here.', 'Second paragraph here.']); + const first = editor.model.addComment({ author: 'Ada', text: 'One', range: [0, 5] }); + review.refresh(true); + expect(review.layer.hidden).toBe(false); + try { + for (const mode of ['none', 'original']) { + review.commands.setMarkupView(mode); review.refresh(); + expect(review.layer.hidden, mode).toBe(true); + expect(review.layer.querySelector('[data-thread]')).toBeNull(); + expect(review.commands.shown).toBe(false); + review.commands.setMarkupView('simple'); review.refresh(); + expect(card(first)).not.toBeNull(); + } + review.commands.setMarkupView('none'); review.refresh(); + review.commands.go(1); review.refresh(); + expect(revisionView.mode).toBe('all'); + expect(card(first).classList.contains('is-active')).toBe(true); + review.commands.setMarkupView('original'); review.refresh(); + editor.model.select(30, 34); + review.commands.newComment(); + expect(revisionView.mode).toBe('all'); + expect(review.layer.querySelector('.ed-comment-draft')).not.toBeNull(); + } finally { revisionView.mode = 'all'; } +}); diff --git a/src/documents/tests/comment-docx.test.js b/src/documents/tests/comment-docx.test.js index 383f47762..3a966fd35 100644 --- a/src/documents/tests/comment-docx.test.js +++ b/src/documents/tests/comment-docx.test.js @@ -115,6 +115,19 @@ describe('DOCX comments', () => { expect((await open(bytes)).model.commentList).toEqual([]); }); + it('deletes a resolved thread\'s replies with it when only its first comment is marked done', async () => { + // A resolved thread as Word writes it: done on the thread's first comment, not on its replies. + const parts = unzipSync(commentedDocx()); + parts['word/commentsExtended.xml'] = strToU8(`Energy: E=mc2 then → next done
'); + }); +}); + +describe('a list numbered again part-way through', () => { + const doc = () => { + const d = blankDoc(); + d.replace('a'); d.toggleList('number'); + d.insertParagraph(); d.replace('b'); + d.insertParagraph(); d.replace('c'); d.restartNumbering(1); + d.insertParagraph(); d.replace('d'); + return d; + }; + it('keeps its numbers in a web page and in Markdown', () => { + expect(documentPlainText(doc())).toBe('1.\ta\n2.\tb\n1.\tc\n2.\td\n'); + // A browser numbers each item one past the one before unless told otherwise. + expect(body(documentHtml(doc()))).toBe('Plan
+
After a blank line
+End
`; + // (Its blank lines need a browser's style sheets: tests/browser/google-docs-import.spec.js.) + it('keeps its nested lists, numbered on', async () => { + const { htmlBody } = await import('../src/lib/importers.js'); + const lines = opened(htmlBody(page)).filter(Boolean); + expect(lines).toEqual(['Plan', 'After a blank line', '1.\tOne', expect.stringMatching(/^ \S\tDetail$/), expect.stringMatching(/^ \S\tMore$/), '2.\tTwo', 'End']); + }); +}); + +describe('horizontal rules and table rows', () => { + const model = (html) => { + const doc = new TextDocument([paragraph()]), fragment = htmlFragment(html, { copied: false }); + for (const p of fragment.paragraphs) p.mark = true; + pasteFragment(doc, fragment); + return doc; + }; + it('keeps a horizontal rule as a line under an empty paragraph, as Word draws one', () => { + for (const html of ['Above
Below
', markdownHtml('Above\n\n---\n\nBelow\n')]) { + const doc = model(html); + expect(doc.paragraphs.map(p => p.runs.map(r => r.text).join(''))).toEqual(['Above', '', 'Below']); + expect(doc.paragraphs[1].format?.paragraphBorders?.bottom?.style).toBe('single'); + expect(doc.paragraphs[0].format?.paragraphBorders?.bottom?.style ?? 'none').toBe('none'); + expect(doc.paragraphs[2].format?.paragraphBorders?.bottom?.style ?? 'none').toBe('none'); + } + }); + it('keeps every cell in its column when cells before it are empty', () => { + expect(model('| Q1 | Q2 | |
|---|---|---|
| Sales | 9 |
Text bold
'); expect(htmlBody('fragment
')).toBe('fragment
'); }); + it('links a Google Docs web page\'s links to where they go, not through Google\'s redirect', () => { + const page = ''; + expect(htmlBody(page)).toBe(''); + // Other addresses on google.com, and redirects to what a link may not open, stay as they are. + expect(htmlBody('')) + .toBe(''); + }); it('keeps the text of a page whose body is one form', () => { expect(htmlBody('')).toBe('Body
'); }); @@ -116,6 +123,45 @@ describe('legacy Korean, Japanese and Chinese text', () => { }); }); +describe('UTF-16 text without a byte-order mark', () => { + const le = text => new Uint8Array(Buffer.from(text, 'utf16le')); + const be = text => { const bytes = le(text); for (let i = 0; i < bytes.length; i += 2) [bytes[i], bytes[i + 1]] = [bytes[i + 1], bytes[i]]; return bytes; }; + it('reads it by where its zero bytes fall, as editors that write no mark save it', () => { + for (const text of ['Привет, мир! Это текст.\r\nВторая строка.', 'Hello world\nSecond line', 'Καλημέρα κόσμε — 2024', '日本語のテキスト 123 abc']) { + expect(decodeTextFile(le(text))).toBe(text); + expect(decodeTextFile(be(text))).toBe(text); + } + }); + it('leaves UTF-8 with a stray zero byte as UTF-8', () => { + for (const tail of [' und mehr Text hier', ' und mehr Text hier!']) { + expect(decodeTextFile(new Uint8Array([...Buffer.from('Grüße', 'utf8'), 0, ...Buffer.from(tail, 'utf8')]))).toBe(`Grüße\0${tail}`); + } + }); +}); + +describe('legacy Cyrillic, Greek, Hebrew and Arabic text', () => { + const encode = (text, encoding) => { + // The code page's byte for each character, found by decoding every byte (TextDecoder only decodes). + const table = new Map([...new TextDecoder(encoding).decode(Uint8Array.from({ length: 256 }, (_, i) => i))].map((ch, i) => [ch, i])); + return new Uint8Array([...text].map(ch => table.get(ch))); + }; + it('reads a file saved in its language\'s Windows code page as its text, not as accented Latin letters', () => { + for (const [text, encoding] of [ + ['Привет, мир! Это обычный текстовый файл, сохранённый в Блокноте.', 'windows-1251'], + ['Доброго ранку! Це звичайний текст українською мовою.', 'windows-1251'], + ['Καλημέρα κόσμε. Αυτό είναι ένα απλό κείμενο στα ελληνικά.', 'windows-1253'], + ['שלום עולם. זהו קובץ טקסט פשוט בעברית.', 'windows-1255'], + ['مرحبا بالعالم. هذا ملف نصي بسيط باللغة العربية.', 'windows-1256'], + ]) expect(decodeTextFile(encode(text, encoding))).toBe(text); + }); + it('still reads Western text, with a few accented letters in its words, as Windows-1252', () => { + for (const text of ['Le cœur a ses raisons que la raison ne connaît point. Ça va très bien, déjà vu, à côté.', + 'Größe, Straße, übermäßig schön; Fußgänger über die Brücke.', 'Ångström, Æsir, Øresund — Ærø är så vackert.']) { + expect(decodeTextFile(encode(text, 'windows-1252'))).toBe(text); + } + }); +}); + describe('applyImport', () => { const fakeApi = ({ blank = true } = {}) => { const calls = []; diff --git a/src/documents/tests/index-authorities.test.js b/src/documents/tests/index-authorities.test.js index c096b9b74..179d6e8dd 100644 --- a/src/documents/tests/index-authorities.test.js +++ b/src/documents/tests/index-authorities.test.js @@ -137,4 +137,18 @@ describe('tables of authorities', () => { writeTableOfAuthorities(again, { existing: tableFields(again.paragraphs)[0], options: { category: 1, passim: false, headings: true, keepFormatting: true, entrySeparator: '\t', pageSeparator: ', ', extra: [] }, pageOf: pages(pkg, again) }); expect(again.text).toContain('Roe v. Wade, 410 U.S. 113 (1973)\t2, 3, 4, 5, 6, 7'); }); + + it('lists a short-form mark that comes before its authority\'s long-form mark', async () => { + // The long form is marked on page 3 first; an earlier citation on page 1 is marked afterwards and gets the short form only. + const { pkg, d } = await setup('Roe v. Wade is discussed.\fNothing here.\fRoe v. Wade, 410 U.S. 113 (1973), held so.\n'); + const long = 'Roe v. Wade, 410 U.S. 113 (1973)'; + let at = d.text.lastIndexOf(long); d.select(at, at + long.length); + markAuthority(d, { long, short: 'Roe v. Wade', category: 1 }); + at = d.text.indexOf('Roe v. Wade'); d.select(at, at + 11); + markAuthority(d, { long, short: 'Roe v. Wade', category: 1 }); + expect(authorities(d.paragraphs).map(a => [a.long, a.marks.length])).toEqual([[long, 2]]); + d.select(d.text.length); + writeTableOfAuthorities(d, { options: { category: 1, passim: false, headings: false, keepFormatting: true, entrySeparator: '\t', pageSeparator: ', ', extra: [] }, pageOf: pages(pkg, d) }); + expect(d.text.split('\n').at(-2)).toBe(`${long}\t1, 3`); + }); }); diff --git a/src/documents/tests/ink-geometry.test.js b/src/documents/tests/ink-geometry.test.js index 363c959f6..44601874d 100644 --- a/src/documents/tests/ink-geometry.test.js +++ b/src/documents/tests/ink-geometry.test.js @@ -81,6 +81,14 @@ describe('erasing and lasso', () => { expect(eraseFromStroke(stroke, { x: 50, y: 30 }, 5)).toEqual([stroke]); expect(eraseFromStroke({ ...stroke, points: line({ x: 0, y: 0 }, { x: 4, y: 0 }, 4) }, { x: 2, y: 0 }, 10)).toEqual([]); }); + it('leaves a stroke as it is when the point eraser only grazes its edge', () => { + // Touching the ink (within the eraser and the line's half width) but no point within the cut. + const r = widthAt(stroke.width, 0.5, 'pen') / 2, at = { x: 50, y: 5 + r * 0.8 }; + expect(strokeHit(stroke, at, 5)).toBe(true); + const pieces = eraseFromStroke(stroke, at, 5); + expect(pieces).toHaveLength(1); + expect(pieces[0]).toBe(stroke); + }); it('selects strokes mostly inside a loop', () => { const loop = [{ x: -10, y: -10 }, { x: 60, y: -10 }, { x: 60, y: 10 }, { x: -10, y: 10 }]; expect(lassoContains(loop, { points: line({ x: 0, y: 0 }, { x: 50, y: 0 }) })).toBe(true); diff --git a/src/documents/tests/line-numbers.test.js b/src/documents/tests/line-numbers.test.js index ce042c9e5..17cf84579 100644 --- a/src/documents/tests/line-numbers.test.js +++ b/src/documents/tests/line-numbers.test.js @@ -95,6 +95,24 @@ describe('line number labels', () => { expect(Number(label.text)).toBe(colLayout.lines.filter(l => l.page === 0 && l.column === 0 && !l.virtual).length + 1); }); + it('keeps automatic labels clear of the line between columns', () => { + const doc = new TextDocument([paragraph('word '.repeat(2000))], { lineNumbers: { countBy: 1, restart: 'newPage' }, columns: { count: 2, space: 720, equalWidth: true, separator: true } }); + const layout = layoutOf(doc), result = lineNumberLabels(layout, doc.paragraphs, doc.numbering, doc.styles, measure); + const separators = layout.columnSeparators.filter(s => s.page === 0); + expect(separators).toHaveLength(1); + const line = separators[0], second = result.filter(l => l.page === 0 && l.x > 200); + expect(second.length).toBeGreaterThan(10); + // Before, a column-two label ended exactly on the line (half the 0.5 in gap from the column). + for (const label of second) { + expect(label.x).toBeGreaterThan(line.x + line.width); + expect(label.x + label.width).toBeLessThan(layout.lines.find(l => l.page === 0 && l.column === 1).columnLeft); + } + // An authored distance is kept as declared. + const authored = new TextDocument([paragraph('word '.repeat(2000))], { lineNumbers: { countBy: 1, restart: 'newPage', distance: 360 }, columns: { count: 2, space: 720, equalWidth: true, separator: true } }); + const authoredLayout = layoutOf(authored), authoredLabel = lineNumberLabels(authoredLayout, authored.paragraphs, authored.numbering, authored.styles, measure).find(l => l.page === 0 && l.x > 200); + expect(authoredLabel.x + authoredLabel.width).toBeCloseTo(authoredLayout.lines.find(l => l.page === 0 && l.column === 1).columnLeft - 24); + }); + it('uses the Line Number character style over the default paragraph style', async () => { const pkg = await DocxPackage.open(readFileSync('public/fixtures/line-numbers.docx')); const style = lineNumberStyle(pkg.styles); diff --git a/src/documents/tests/mail-merge-docx.test.js b/src/documents/tests/mail-merge-docx.test.js index 620eda360..a89d448cb 100644 --- a/src/documents/tests/mail-merge-docx.test.js +++ b/src/documents/tests/mail-merge-docx.test.js @@ -244,6 +244,22 @@ describe('editing merge fields in the model', () => { // The remembered formatting is not written to the file. expect(strFromU8(unzipSync(await save(pkg, d))['word/document.xml'])).not.toContain('resultFormatting'); }); + it('keeps the caret on the same text when a preview changes the field results before it', async () => { + const { d } = await blankModel('Dear '); + d.select(5); insertMergeField(d, ' MERGEFIELD "First Name" '); d.replace(', thank you.'); + const caretBefore = text => { const at = d.text.indexOf(text); d.select(at); }; + const caretText = () => d.text.slice(d.range[0], d.range[0] + 5); + caretBefore('thank'); + applyMergeResults(d, mergeFieldRanges(d), ['Rosa']); + expect(d.text).toBe('Dear Rosa, thank you.'); + expect(caretText()).toBe('thank'); + applyMergeResults(d, mergeFieldRanges(d), ['Bartholomew-Alexander']); + expect(caretText()).toBe('thank'); + // A selection across the field keeps both ends on their text. + d.select(0, d.text.indexOf('you')); + applyMergeResults(d, mergeFieldRanges(d), placeholderResults(mergeFieldRanges(d))); + expect(d.text.slice(...d.range)).toBe('Dear «First Name», thank '); + }); it('builds label sheets that open editable and propagates the first label', async () => { const layout = LABEL_LAYOUTS.find(l => l.id === 'letter-10'); expect(layoutProblems(layout)).toEqual([]); diff --git a/src/documents/tests/markdown-html.test.js b/src/documents/tests/markdown-html.test.js index 339edc554..32f8b6d66 100644 --- a/src/documents/tests/markdown-html.test.js +++ b/src/documents/tests/markdown-html.test.js @@ -39,3 +39,8 @@ it('opens footnotes as their numbered notes, without the arrows a web page links expect(lines).toContain('with more.'); expect(lines[0]).toBe('A claim1 and1 another2.'); }); + +it('leaves out hidden HTML in a Markdown file, as opening a web page does', () => { + const lines = open('# Notes\n\n