61 lines
2.8 KiB
TypeScript
61 lines
2.8 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
|
|
import type { AdfDocument, AdfNode } from '../../adf/document.ts'
|
|
import { mintTaskIds } from './task-ids.ts'
|
|
|
|
const uuidV4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
|
|
|
|
function taskIds(document: AdfDocument): unknown[] {
|
|
const ids: unknown[] = []
|
|
const pending: AdfNode[] = [...(document.content ?? [])].reverse()
|
|
for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
|
|
if (['blockTaskItem', 'taskItem', 'taskList'].includes(node.type)) ids.push(node.attrs?.['localId'])
|
|
for (const child of [...(node.content ?? [])].reverse()) pending.push(child)
|
|
}
|
|
return ids
|
|
}
|
|
|
|
function tasks(...content: AdfNode[]): AdfDocument {
|
|
return { content, type: 'doc', version: 1 }
|
|
}
|
|
|
|
test('mints each task node lacking a localId a UUID v4 in document order, unique and the same every run', () => {
|
|
const unminted = (): AdfDocument => tasks({ content: [{ attrs: { state: 'TODO' }, type: 'taskItem' }, { content: [{ attrs: { state: 'DONE' }, type: 'blockTaskItem' }], type: 'taskList' }], type: 'taskList' })
|
|
const minted = unminted()
|
|
mintTaskIds(minted, '- [ ] a\n', new Set())
|
|
const ids = taskIds(minted)
|
|
assert.equal(ids.length, 4)
|
|
for (const id of ids) assert.match(String(id), uuidV4)
|
|
assert.equal(new Set(ids).size, 4)
|
|
const again = unminted()
|
|
mintTaskIds(again, '- [ ] a\n', new Set())
|
|
assert.deepEqual(taskIds(again), ids)
|
|
const other = unminted()
|
|
mintTaskIds(other, '- [ ] b\n', new Set())
|
|
assert.equal(taskIds(other).some((id) => ids.includes(id)), false)
|
|
})
|
|
|
|
test('keeps a localId the document spells and skips it when minting, a carried one too', () => {
|
|
const first = tasks({ type: 'taskList' })
|
|
mintTaskIds(first, 'x', new Set())
|
|
const [taken] = taskIds(first)
|
|
const carried: AdfNode = { content: [{ attrs: { localId: String(taken) }, type: 'taskList' }], type: 'futureBlock' }
|
|
const spelled = tasks({ type: 'taskList' }, carried)
|
|
mintTaskIds(spelled, 'x', new Set([carried]))
|
|
const [minted, kept] = taskIds(spelled)
|
|
assert.equal(kept, taken)
|
|
assert.notEqual(minted, taken)
|
|
assert.match(String(minted), uuidV4)
|
|
})
|
|
|
|
test('leaves a node the carry restores as carried, minting neither it nor what it holds', () => {
|
|
const list = (): AdfNode => ({ content: [{ attrs: { state: 'TODO' }, type: 'taskItem' }], type: 'taskList' })
|
|
const carriedList = list()
|
|
const carriedPanel: AdfNode = { attrs: { panelType: 'info' }, content: [list()], type: 'panel' }
|
|
const future: AdfNode = { content: [list()], type: 'futureBlock' }
|
|
const document = tasks(carriedList, carriedPanel, future)
|
|
mintTaskIds(document, 'x', new Set([carriedList, carriedPanel]))
|
|
assert.deepEqual(document, tasks(list(), { attrs: { panelType: 'info' }, content: [list()], type: 'panel' }, { content: [list()], type: 'futureBlock' }))
|
|
})
|