Mirrors/yjs
1
0
Fork 0
mirror of https://github.com/yjs/yjs.git synced 2025-12-15 19:27:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

bump deps and use new delta format

Browse Source
This commit is contained in:
Kevin Jahns
2025-10-28 17:51:10 +01:00
parent 19dbe61141
commit 584ad5fc9a
13 changed files with 2393 additions and 1873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4038
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

13
package.json
View File

@@ -18,7 +18,6 @@
"dist": "npm run clean && rollup -c && tsc --skipLibCheck",
"watch": "rollup -wc",
"lint": "markdownlint README.md && standard && tsc",
"docs": "rm -rf docs; jsdoc --configure ./.jsdoc.json --verbose --readme ./README.md --package ./package.json || true",
"serve-docs": "npm run docs && 0serve ./docs/",
"preversion": "PRODUCTION=1 npm run dist && npm run docs && test -e dist/src/index.d.ts && test -e dist/yjs.cjs && test -e dist/yjs.cjs",
"debug": "npm run gentesthtml && 0serve -o test.html",
@@ -85,17 +84,15 @@
},
"homepage": "https://docs.yjs.dev",
"dependencies": {
"lib0": "^0.2.115-0"
"lib0": "^0.2.115-1"
},
"devDependencies": {
"@types/node": "^22.14.1",
"@y/protocols": "^1.0.6-1",
"concurrently": "^3.6.1",
"jsdoc": "^3.6.7",
"markdownlint-cli": "^0.41.0",
"rollup": "^4.37.0",
"standard": "^16.0.4",
"tui-jsdoc-template": "^1.2.2",
"concurrently": "^9.2.1",
"markdownlint-cli": "^0.45.0",
"rollup": "^4.52.5",
"standard": "^17.1.2",
"typescript": "^5.9.3"
},
"engines": {

6
src/types/AbstractType.js
View File

@@ -468,7 +468,7 @@ export class AbstractType {
getContent (am = noAttributionsManager, opts = {}) {
const { itemsToRender = null, retainInserts = false, retainDeletes = false, renderAttrs = null, renderChildren = true, deletedItems = null, modified = null, deep = false } = opts
/**
* @type {EventDelta}
* @type {EventDelta extends delta.Delta<infer N,infer Attrs,infer Children,infer Text,any> ? delta.DeltaBuilder<N,Attrs,Children,Text,any> : never}
*/
const d = /** @type {any} */ (delta.create(/** @type {any} */ (this).nodeName || null))
typeMapGetDelta(d, /** @type {any} */ (this), renderAttrs, am, deep, modified, deletedItems, itemsToRender)
@@ -726,7 +726,7 @@ export class AbstractType {
} else if (delta.$deleteOp.check(op)) {
deleteText(transaction, currPos, op.delete)
} else if (delta.$modifyOp.check(op)) {
/** @type {ContentType} */ (currPos.right?.content).type.applyDelta(op.modify)
/** @type {ContentType} */ (currPos.right?.content).type.applyDelta(op.value)
currPos.formatText(transaction, /** @type {any} */ (this), 1, op.format || {})
}
}
@@ -1277,7 +1277,7 @@ export const typeMapGetAll = (parent) => {
* Note that deleted content that was not deleted in prevYdoc is rendered as an insertion with the
* attribution `{ isDeleted: true, .. }`.
*
* @template {delta.Delta<any,any,any,any>} TypeDelta
* @template {delta.DeltaBuilder<any,any,any,any>} TypeDelta
* @param {TypeDelta} d
* @param {YType_} parent
* @param {Set<string>?} attrsToRender

2
src/types/YXmlElement.js
View File

@@ -24,7 +24,7 @@ import {
* * An YXmlElement has attributes (key value pairs)
* * An YXmlElement has childElements that must inherit from YXmlElement
*
* @template {{ [key: string]: ValueTypes }} [Attrs={ [key: string]: string }]
* @template {{ [key: string]: any }} [Attrs={ [key: string]: string }]
* @template {any} [Children=any]
* @extends YXmlFragment<Children,Attrs>
*/

1
src/utils/types.js
View File

@@ -1,4 +1,3 @@
/**
* @typedef {import('../types/YArray.js').YArray<any>
* | import('../types/YMap.js').YMap<any>

4
tests/compatibility.tests.js
View File

File diff suppressed because one or more lines are too long

4
tests/testHelper.js
View File

@@ -460,7 +460,7 @@ export const compare = users => {
users.push(.../** @type {any} */(mergedDocs))
const userArrayValues = users.map(u => u.getArray('array').toJSON())
const userMapValues = users.map(u => u.getMap('map').toJSON())
const userXmlValues = users.map(u => u.get('xml', Y.XmlElement).toString())
const userXmlValues = users.map(u => /** @type {Y.XmlElement} */ (u.get('xml', Y.XmlElement)).toString())
const userTextValues = users.map(u => u.getText('text').getContentDeep())
for (const u of users) {
t.assert(u.store.pendingDs === null)
@@ -486,7 +486,7 @@ export const compare = users => {
t.compare(userArrayValues[i], userArrayValues[i + 1])
t.compare(userMapValues[i], userMapValues[i + 1])
t.compare(userXmlValues[i], userXmlValues[i + 1])
t.compare(list.toArray(userTextValues[i].children).map(a => delta.$textOp.check(a) ? a.insert : ' ').join('').length, users[i].getText('text').length)
t.compare(list.toArray(userTextValues[i].children).map(a => (delta.$textOp.check(a) || delta.$insertOp.check(a)) ? a.insert.length : 0).reduce((a, b) => a + b, 0), users[i].getText('text').length)
t.compare(userTextValues[i], userTextValues[i + 1], '', (_constructor, a, b) => {
if (a instanceof Y.AbstractType) {
t.compare(a.toJSON(), b.toJSON())

2
tests/undo-redo.tests.js
View File

@@ -299,7 +299,9 @@ export const testUndoXml = tc => {
// format textchild and revert that change
undoManager.stopCapturing()
textchild.format(3, 4, { bold: {} })
t.compare(xml0.getContentDeep(), delta.create('UNDEFINED').insert([delta.text().insert('con').insert('tent', { bold: true }).done()]).done())
t.assert(xml0.toString() === '<undefined><p>con<bold>tent</bold></p></undefined>')
debugger
undoManager.undo()
t.assert(xml0.toString() === '<undefined><p>content</p></undefined>')
undoManager.redo()

12
tests/updates.tests.js
View File

@@ -127,7 +127,15 @@ export const testKeyEncoding = tc => {
const update = Y.encodeStateAsUpdateV2(users[0])
Y.applyUpdateV2(users[1], update)
t.compare(text1.getContent().toJSON().children, [{ insert: 'c', format: { italic: true } }, { insert: 'b' }, { insert: 'a', format: { italic: true } }])
const c = text1.getContent()
t.compare(
c,
delta.create()
.insert('c', { italic: true })
.insert('b')
.insert('a', { italic: true })
.done()
)
compare(users)
}
@@ -335,7 +343,7 @@ export const testObfuscateUpdates = _tc => {
t.assert(d[0].insert !== 'text' && d[0].insert.length === 4)
t.assert(object.length(d[0].format) === 1)
t.assert(!object.hasProperty(d[0].format, 'bold'))
t.assert(object.length(d[1]) === 1)
t.assert(object.length(d[1].insert) === 1)
t.assert(object.hasProperty(d[1], 'insert'))
// test ymap
t.assert(omap.size === 1)

4
tests/y-array.tests.js
View File

@@ -393,13 +393,13 @@ export const testChangeEvent = tc => {
const newArr = new Y.Array()
array0.insert(0, [newArr, 4, 'dtrn'])
t.assert(d !== null && d.children.len === 1)
t.compare(d.toJSON().children, [{ insert: [newArr, 4, 'dtrn'] }])
t.compare(d, delta.create().insert([newArr, 4, 'dtrn']))
array0.delete(0, 2)
t.assert(d !== null && d.children.len === 1)
t.compare(d.toJSON().children, [{ delete: 2 }])
array0.insert(1, [0.1])
t.assert(d !== null && d.children.len === 2)
t.compare(d.toJSON().children, [{ retain: 1 }, { insert: [0.1] }])
t.compare(d, delta.create().retain(1).insert([0.1]).done())
compare(users)
}

15
tests/y-map.tests.js
View File

@@ -10,6 +10,7 @@ import * as t from 'lib0/testing'
import * as prng from 'lib0/prng'
import * as delta from 'lib0/delta'
import * as s from 'lib0/schema'
import * as object from 'lib0/object'
/**
* @param {t.TestCase} _tc
@@ -498,33 +499,33 @@ export const testChangeEvent = tc => {
changes = e.delta
})
map0.set('a', 1)
let keyChange = changes.attrs.get('a')
let keyChange = changes.attrs.a
t.assert(delta.$insertOpWith(s.$number).check(keyChange) && keyChange.prevValue === undefined)
map0.set('a', 2)
keyChange = changes.attrs.get('a')
keyChange = changes.attrs.a
t.assert(delta.$insertOpWith(s.$number).check(keyChange) && keyChange.prevValue === 1)
users[0].transact(() => {
map0.set('a', 3)
map0.set('a', 4)
})
keyChange = changes.attrs.get('a')
keyChange = changes.attrs.a
t.assert(delta.$insertOpWith(s.$number).check(keyChange) && keyChange.prevValue === 2)
users[0].transact(() => {
map0.set('b', 1)
map0.set('b', 2)
})
keyChange = changes.attrs.get('b')
keyChange = changes.attrs.b
t.assert(delta.$insertOpWith(s.$number).check(keyChange) && keyChange.prevValue === undefined)
users[0].transact(() => {
map0.set('c', 1)
map0.delete('c')
})
t.assert(changes !== null && changes.attrs.size === 0)
t.assert(changes !== null && object.isEmpty(changes.attrs))
users[0].transact(() => {
map0.set('d', 1)
map0.set('d', 2)
})
keyChange = changes.attrs.get('d')
keyChange = changes.attrs.d
t.assert(delta.$insertOpWith(s.$number).check(keyChange) && keyChange.prevValue === undefined)
compare(users)
}
@@ -635,7 +636,7 @@ export const testAttributedContent = _tc => {
})
t.group('overwrite value', () => {
ymap.set('test', 'fourtytwo')
const expectedContent = { test: delta.$deltaMapChangeJson.expect({ type: 'insert', prevValue: 42, value: 'fourtytwo', attribution: { insert: [] } }) }
const expectedContent = { test: delta.$deltaMapChangeJson.expect({ type: 'insert', value: 'fourtytwo', attribution: { insert: [] } }) }
const attributedContent = ymap.getContent(attributionManager)
console.log(attributedContent)
t.compare(expectedContent, attributedContent.toJSON().attrs)

159
tests/y-text.tests.js
View File

@@ -1216,6 +1216,7 @@ export const testDeltaBug2 = _tc => {
ytext.applyDelta(changeEvent)
const d = ytext.getContent()
t.compare(list.toArray(d.children)[40].toJSON(), {
type: 'insert',
insert: '\n',
format: {
'block-id': 'block-9d6566a1-be55-4e20-999a-b990bc15e143'
@@ -1242,11 +1243,12 @@ export const testDeltaAfterConcurrentFormatting = tc => {
const deltas = []
text1.observe(event => {
if (event.delta.children.len > 0) {
deltas.push(event.delta.toJSON())
deltas.push(event.delta)
}
})
testConnector.flushAllMessages()
t.compare(deltas, [[{ retain: 2, format: { bold: true } }, { retain: 1 }, { retain: 1, format: { bold: null } }]])
t.assert(deltas.length === 1)
t.compare(deltas[0], delta.create().retain(2, { bold: true }).retain(1).retain(1, { bold: null }).done())
}
/**
@@ -1295,29 +1297,29 @@ export const testBasicFormat = tc => {
})
text0.insert(0, 'abc', { bold: true })
t.assert(text0.toString() === 'abc', 'Basic insert with attributes works')
t.compare(text0.getContent(), delta.create().insert('abc', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('abc', { bold: true }).done())
t.compare(eventDelta, delta.create().insert('abc', { bold: true }))
text0.delete(0, 1)
t.assert(text0.toString() === 'bc', 'Basic delete on formatted works (position 0)')
t.compare(text0.getContent(), delta.create().insert('bc', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('bc', { bold: true }).done())
t.compare(eventDelta, delta.create().delete(1))
text0.delete(1, 1)
t.assert(text0.toString() === 'b', 'Basic delete works (position 1)')
t.compare(text0.getContent(), delta.create().insert('b', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('b', { bold: true }).done())
t.compare(eventDelta, delta.create().retain(1).delete(1))
text0.insert(0, 'z', { bold: true })
t.assert(text0.toString() === 'zb')
t.compare(text0.getContent(), delta.create().insert('zb', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('zb', { bold: true }).done())
t.compare(eventDelta, delta.create().insert('z', { bold: true }))
// @ts-ignore
t.assert(text0._start.right.right.right.content.str === 'b', 'Does not insert duplicate attribute marker')
text0.insert(0, 'y')
t.assert(text0.toString() === 'yzb')
t.compare(text0.getContent(), delta.create().insert('y').insert('zb', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('y').insert('zb', { bold: true }).done())
t.compare(eventDelta, delta.create().insert('y'))
text0.format(0, 2, { bold: null })
t.assert(text0.toString() === 'yzb')
t.compare(text0.getContent(), delta.create().insert('yz').insert('b', { bold: true }))
t.compare(text0.getContent(), delta.create().insert('yz').insert('b', { bold: true }).done())
t.compare(eventDelta, delta.create().retain(1).retain(1, { bold: null }))
compare(users)
}
@@ -1332,14 +1334,14 @@ export const testFalsyFormats = tc => {
delta = event.delta.toJSON().children
})
text0.insert(0, 'abcde', { falsy: false })
t.compare(text0.getContent().toJSON().children, [{ insert: 'abcde', format: { falsy: false } }])
t.compare(delta, [{ insert: 'abcde', format: { falsy: false } }])
t.compare(text0.getContent().toJSON().children, [{ type: 'insert', insert: 'abcde', format: { falsy: false } }])
t.compare(delta, [{ type: 'insert', insert: 'abcde', format: { falsy: false } }])
text0.format(1, 3, { falsy: true })
t.compare(text0.getContent().toJSON().children, [{ insert: 'a', format: { falsy: false } }, { insert: 'bcd', format: { falsy: true } }, { insert: 'e', format: { falsy: false } }])
t.compare(delta, [{ retain: 1 }, { retain: 3, format: { falsy: true } }])
t.compare(text0.getContent().toJSON().children, [{ type: 'insert', insert: 'a', format: { falsy: false } }, { type: 'insert', insert: 'bcd', format: { falsy: true } }, { type: 'insert', insert: 'e', format: { falsy: false } }])
t.compare(delta, [{ type: 'retain', retain: 1 }, { type: 'retain', retain: 3, format: { falsy: true } }])
text0.format(2, 1, { falsy: false })
t.compare(text0.getContent().toJSON().children, [{ insert: 'a', format: { falsy: false } }, { insert: 'b', format: { falsy: true } }, { insert: 'c', format: { falsy: false } }, { insert: 'd', format: { falsy: true } }, { insert: 'e', format: { falsy: false } }])
t.compare(delta, [{ retain: 2 }, { retain: 1, format: { falsy: false } }])
t.compare(text0.getContent().toJSON().children, [{ type: 'insert', insert: 'a', format: { falsy: false } }, { type: 'insert', insert: 'b', format: { falsy: true } }, { type: 'insert', insert: 'c', format: { falsy: false } }, { type: 'insert', insert: 'd', format: { falsy: true } }, { type: 'insert', insert: 'e', format: { falsy: false } }])
t.compare(delta, [{ type: 'retain', retain: 2 }, { type: 'retain', retain: 1, format: { falsy: false } }])
compare(users)
}
@@ -1357,13 +1359,16 @@ export const testMultilineFormat = _tc => {
.retain(1) // newline character
.retain(10, { bold: true })
testText.applyDelta(tt)
t.compare(testText.getContent().toJSON().children, [
{ insert: 'Test', format: { bold: true } },
{ insert: '\n' },
{ insert: 'Multi-line', format: { bold: true } },
{ insert: '\n' },
{ insert: 'Formatting', format: { bold: true } }
])
t.compare(
testText.getContent(),
delta.create()
.insert('Test', { bold: true })
.insert('\n')
.insert('Multi-line', { bold: true })
.insert('\n')
.insert('Formatting', { bold: true })
.done()
)
}
/**
@@ -1378,12 +1383,15 @@ export const testNotMergeEmptyLinesFormat = _tc => {
.insert('\nText')
.insert('\n', { title: true })
)
t.compare(testText.getContent().toJSON().children, [
{ insert: 'Text' },
{ insert: '\n', format: { title: true } },
{ insert: '\nText' },
{ insert: '\n', format: { title: true } }
])
t.compare(
testText.getContent(),
delta.create()
.insert('Text')
.insert('\n', { title: true })
.insert('\nText')
.insert('\n', { title: true })
.done()
)
}
/**
@@ -1402,10 +1410,12 @@ export const testPreserveAttributesThroughDelete = _tc => {
.delete(1)
.retain(1, { title: true })
)
t.compare(testText.getContent().toJSON().children, [
{ insert: 'Text' },
{ insert: '\n', format: { title: true } }
])
t.compare(testText.getContent(),
delta.create()
.insert('Text')
.insert('\n', { title: true })
.done()
)
}
/**
@@ -1414,9 +1424,11 @@ export const testPreserveAttributesThroughDelete = _tc => {
export const testGetDeltaWithEmbeds = tc => {
const { text0 } = init(tc, { users: 1 })
text0.applyDelta(delta.create().insert([{ linebreak: 's' }]))
t.compare(text0.getContent().toJSON().children, [{
insert: [{ linebreak: 's' }]
}])
t.compare(text0.getContent(),
delta.create()
.insert([{ linebreak: 's' }])
.done()
)
}
/**
@@ -1427,18 +1439,18 @@ export const testTypesAsEmbed = tc => {
text0.applyDelta(delta.create()
.insert([new Y.Map([['key', 'val']])])
)
t.compare(/** @type {any} */ (text0).getContentDeep().toJSON().children[0]?.insert, { key: 'val' })
t.compare(/** @type {any} */ (text0).getContentDeep().toJSON().children, [{ type: 'insert', insert: [{ attrs: { key: { type: 'insert', value: 'val' } }}] }])
let firedEvent = false
text1.observe(event => {
const d = event.delta
const d = event.deltaDeep
t.assert(d.children.len === 1)
t.compare(list.toArray(d.children).map(x => /** @type {any} */ (x).insert.toJSON()), [{ key: 'val' }])
t.compare(d.toJSON().children?.map(x => /** @type {any} */ (x).insert), [[{ key: { type: 'insert', value: 'val' } }]])
firedEvent = true
})
testConnector.flushAllMessages()
const dd = text1.getContent().toJSON().children
t.assert(dd?.length === 1)
t.compare(/** @type {any} */ (dd?.[0]).insert.toJSON(), { key: 'val' })
t.compare(/** @type {any} */ (dd?.[0]).insert, { key: 'val' })
t.assert(firedEvent, 'fired the event observer containing a Type-Embed')
}
@@ -1463,12 +1475,19 @@ export const testSnapshot = tc => {
.delete(1)
)
const state1 = text0.getContent(createAttributionManagerFromSnapshots(snapshot1))
t.compare(state1.toJSON().children, [{ insert: 'abcd' }])
t.compare(state1, delta.create().insert('abcd').done())
const state2 = text0.getContent(createAttributionManagerFromSnapshots(snapshot2))
t.compare(state2.toJSON().children, [{ insert: 'axcd' }])
const state2Diff = text0.getContent(createAttributionManagerFromSnapshots(snapshot1, snapshot2)).toJSON().children
const expected = [{ insert: 'a' }, { insert: 'x', attribution: { insert: [] } }, { insert: 'b', attribution: { delete: [] } }, { insert: 'cd' }]
t.compare(state2Diff, expected)
t.compare(state2, delta.create().insert('axcd').done())
const state2Diff = text0.getContent(createAttributionManagerFromSnapshots(snapshot1, snapshot2))
t.compare(
state2Diff,
delta.create()
.insert('a')
.insert('x', null, { insert: [] })
.insert('b', null, { delete: [] })
.insert('cd')
.done()
)
}
/**
@@ -1506,8 +1525,15 @@ export const testToDeltaEmbedAttributes = tc => {
const { text0 } = init(tc, { users: 1 })
text0.insert(0, 'ab', { bold: true })
text0.insertEmbed(1, { image: 'imageSrc.png' }, { width: 100 })
const delta0 = text0.getContent().toJSON().children
t.compare(delta0, [{ insert: 'a', format: { bold: true } }, { insert: [{ image: 'imageSrc.png' }], format: { width: 100 } }, { insert: 'b', format: { bold: true } }])
const delta0 = text0.getContent()
t.compare(
delta0,
delta.create()
.insert('a', { bold: true })
.insert([{ image: 'imageSrc.png' }], { width: 100 })
.insert('b', { bold: true })
.done()
)
}
/**
@@ -1517,8 +1543,16 @@ export const testToDeltaEmbedNoAttributes = tc => {
const { text0 } = init(tc, { users: 1 })
text0.insert(0, 'ab', { bold: true })
text0.insertEmbed(1, { image: 'imageSrc.png' })
const delta0 = text0.getContent().toJSON().children
t.compare(delta0, [{ insert: 'a', format: { bold: true } }, { insert: [{ image: 'imageSrc.png' }] }, { insert: 'b', format: { bold: true } }], 'toDelta does not set attributes key when no attributes are present')
const delta0 = text0.getContent()
t.compare(
delta0,
delta.create()
.insert('a', { bold: true })
.insert([{ image: 'imageSrc.png' }])
.insert('b', { bold: true })
.done()
, 'toDelta does not set attributes key when no attributes are present'
)
}
/**
@@ -1528,6 +1562,7 @@ export const testFormattingRemoved = tc => {
const { text0 } = init(tc, { users: 1 })
text0.insert(0, 'ab', { bold: true })
text0.delete(0, 2)
// @ts-ignore
t.assert(Y.getTypeChildren(text0).length === 1)
}
@@ -1571,9 +1606,7 @@ export const testFormattingDeltaUnnecessaryAttributeChange = tc => {
testConnector.flushAllMessages()
const filteredDeltas = deltas.filter(d => d.children.len > 0)
t.assert(filteredDeltas.length === 2)
t.compare(filteredDeltas[0].toJSON().children, [
{ retain: 1, format: { LIST_STYLES: 'number' } }
])
t.compare(filteredDeltas[0], delta.create().retain(1, { LIST_STYLES: 'number' }).done())
t.compare(filteredDeltas[0], filteredDeltas[1])
}
@@ -1820,12 +1853,12 @@ export const testFormattingBug = async _tc => {
ydoc2.getText().format(1, 1, { url: 'http://docs.yjs.dev' })
Y.applyUpdate(ydoc2, Y.encodeStateAsUpdate(ydoc1))
const text2 = ydoc2.getText()
const expectedResult = [
{ insert: '\n', format: { url: 'http://example.com' } },
{ insert: '\n', format: { url: 'http://docs.yjs.dev' } },
{ insert: '\n', format: { url: 'http://example.com' } }
]
t.compare(text1.getContent().toJSON().children, expectedResult)
const expectedResult = delta.create()
.insert('\n', { url: 'http://example.com' })
.insert('\n', { url: 'http://docs.yjs.dev' })
.insert('\n', { url: 'http://example.com' })
.done()
t.compare(text1.getContent(), expectedResult)
t.compare(text1.getContent().toJSON(), text2.getContent().toJSON())
console.log(text1.getContent().toJSON())
}
@@ -1850,13 +1883,13 @@ export const testDeleteFormatting = _tc => {
text.format(16, 4, { bold: null })
Y.applyUpdate(doc2, Y.encodeStateAsUpdate(doc))
const expected = [
{ insert: 'Attack ships ' },
{ insert: 'on ', format: { bold: true } },
{ insert: 'fire off the shoulder of Orion.' }
]
t.compare(text.getContent().toJSON().children, expected)
t.compare(text2.getContent().toJSON().children, expected)
const expected = delta.create()
.insert('Attack ships ')
.insert('on ', { bold: true })
.insert('fire off the shoulder of Orion.')
.done()
t.compare(text.getContent(), expected)
t.compare(text2.getContent(), expected)
}
/**

6
tests/y-xml.tests.js
View File

@@ -106,7 +106,7 @@ export const testYtextAttributes = _tc => {
const ydoc = new Y.Doc()
const ytext = /** @type {Y.XmlText} */ (ydoc.get('', Y.XmlText))
ytext.observe(event => {
t.assert(event.delta.attrs.get('test')?.type === 'insert')
t.assert(event.delta.attrs.test?.type === 'insert')
})
ytext.setAttribute('test', 42)
t.compare(ytext.getAttribute('test'), 42)
@@ -124,7 +124,7 @@ export const testSiblings = _tc => {
yxml.insert(0, [first, second])
t.assert(first.nextSibling === second)
t.assert(second.prevSibling === first)
t.assert(first.parent === yxml)
t.assert(first.parent === /** @type {Y.AbstractType<any>} */ (yxml))
t.assert(yxml.parent === null)
t.assert(yxml.firstChild === first)
}
@@ -272,7 +272,7 @@ export const testElementAttributedContent = _tc => {
console.log('cs expec', JSON.stringify(expectedContent.toJSON(), null, 2))
console.log('attributes', attributedContent.toJSON().attrs)
t.assert(attributedContent.equals(expectedContent))
t.compare(attributedContent, /** @type {delta.MapDelta<any>} */ (delta.map()).set('key', '42', { insert: [] }))
t.compare(attributedContent, delta.map().set('key', '42', { insert: [] }))
t.compare(attributedContent.toJSON().attrs, { key: { type: 'insert', prevValue: undefined, value: '42', attribution: { insert: [] } } })
t.assert(attributedContent.name === 'UNDEFINED')
})