v13.0.0-29 -- distribution files

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-28",
+  "version": "13.0.0-29",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "yjs",
-  "version": "13.0.0-28",
+  "version": "13.0.0-29",
   "description": "A framework for real-time p2p shared editing on any data",
   "main": "./y.node.js",
   "browser": "./y.js",

rollup.test.js

@@ -3,7 +3,7 @@ import commonjs from 'rollup-plugin-commonjs'
 import multiEntry from 'rollup-plugin-multi-entry'
 
 export default {
-  entry: 'test/y-map.tests.js',
+  entry: 'test/y-xml.tests.js',
   moduleName: 'y-tests',
   format: 'umd',
   plugins: [

src/Type/y-xml/utils.js

@@ -138,6 +138,7 @@ export function applyChangesFromDom (dom) {
 export function reflectChangesOnDom (events) {
   // Make sure that no filtered attributes are applied to the structure
   // if they were, delete them
+  /*
   events.forEach(event => {
     const target = event.target
     const keys = this._domFilter(target.nodeName, Array.from(event.keysChanged))
@@ -156,6 +157,7 @@ export function reflectChangesOnDom (events) {
       })
     }
   })
+  */
   this._mutualExclude(() => {
     events.forEach(event => {
       const yxml = event.target

y.node.js

@@ -1,7 +1,7 @@
 
 /**
  * yjs - A framework for real-time p2p shared editing on any data
- * @version v13.0.0-28
+ * @version v13.0.0-29
  * @license MIT
  */
 
@@ -2779,24 +2779,26 @@ function applyChangesFromDom (dom) {
 function reflectChangesOnDom (events) {
   // Make sure that no filtered attributes are applied to the structure
   // if they were, delete them
+  /*
   events.forEach(event => {
-    const target = event.target;
-    const keys = this._domFilter(target.nodeName, Array.from(event.keysChanged));
+    const target = event.target
+    const keys = this._domFilter(target.nodeName, Array.from(event.keysChanged))
     if (keys === null) {
-      target._delete();
+      target._delete()
     } else {
-      const removeKeys = new Set(); // is a copy of event.keysChanged
-      event.keysChanged.forEach(key => { removeKeys.add(key); });
+      const removeKeys = new Set() // is a copy of event.keysChanged
+      event.keysChanged.forEach(key => { removeKeys.add(key) })
       keys.forEach(key => {
         // remove all accepted keys from removeKeys
-        removeKeys.delete(key);
-      });
+        removeKeys.delete(key)
+      })
       // remove the filtered attribute
       removeKeys.forEach(key => {
-        target.removeAttribute(key);
-      });
+        target.removeAttribute(key)
+      })
     }
-  });
+  })
+  */
   this._mutualExclude(() => {
     events.forEach(event => {
       const yxml = event.target;

y.test.js

@@ -2776,24 +2776,26 @@ function applyChangesFromDom (dom) {
 function reflectChangesOnDom (events) {
   // Make sure that no filtered attributes are applied to the structure
   // if they were, delete them
+  /*
   events.forEach(event => {
-    const target = event.target;
-    const keys = this._domFilter(target.nodeName, Array.from(event.keysChanged));
+    const target = event.target
+    const keys = this._domFilter(target.nodeName, Array.from(event.keysChanged))
     if (keys === null) {
-      target._delete();
+      target._delete()
     } else {
-      const removeKeys = new Set(); // is a copy of event.keysChanged
-      event.keysChanged.forEach(key => { removeKeys.add(key); });
+      const removeKeys = new Set() // is a copy of event.keysChanged
+      event.keysChanged.forEach(key => { removeKeys.add(key) })
       keys.forEach(key => {
         // remove all accepted keys from removeKeys
-        removeKeys.delete(key);
-      });
+        removeKeys.delete(key)
+      })
       // remove the filtered attribute
       removeKeys.forEach(key => {
-        target.removeAttribute(key);
-      });
+        target.removeAttribute(key)
+      })
     }
-  });
+  })
+  */
   this._mutualExclude(() => {
     events.forEach(event => {
       const yxml = event.target;
@@ -18903,28 +18905,6 @@ var stacktrace = createCommonjsModule$1(function (module, exports) {
 }));
 });
 
-function proxyConsole () {
-  function createProxy (fName) {
-    var originallog = console[fName];
-    console[fName] = function consoleProxy () {
-      var trace = new Error().stack.split('\n');
-      var i = trace.length - 1;
-      while (i > 0 && trace[i].match((/^ {4}at (?:<anonymous>|__iterateOverGenerators|__testStarter|TestCase.*\.asyncGroup|asyncGroup).*/))) {
-        i--;
-      }
-      var hasTestName = trace[i]
-        .match(/^ {4}at TestCase.*\.(\S+) .*/);
-      if (hasTestName !== null && hasTestName[1] !== 'print') {
-        var testcase = testHandler.tests[hasTestName[1]];
-        testcase[fName].apply(testcase, arguments);
-      } else {
-        originallog.apply(console, arguments);
-      }
-    };
-  }
-  ['log', 'error', 'assert'].map(createProxy);
-}
-
 index.stacktrace = stacktrace;
 
 function test (testDescription, ...args) {
@@ -18934,368 +18914,408 @@ function test (testDescription, ...args) {
   testHandler.register(testCase);
 }
 
-proxyConsole();
-
-test('basic map tests', async function map0 (t) {
-  let { users, map0, map1, map2 } = await initArrays(t, { users: 3 });
-  users[2].disconnect();
-
-  map0.set('number', 1);
-  map0.set('string', 'hello Y');
-  map0.set('object', { key: { key2: 'value' } });
-  map0.set('y-map', new Y$1.Map());
-  let map = map0.get('y-map');
-  map.set('y-array', new Y$1.Array());
-  let array = map.get('y-array');
-  array.insert(0, [0]);
-  array.insert(0, [-1]);
-
-  t.assert(map0.get('number') === 1, 'client 0 computed the change (number)');
-  t.assert(map0.get('string') === 'hello Y', 'client 0 computed the change (string)');
-  t.compare(map0.get('object'), { key: { key2: 'value' } }, 'client 0 computed the change (object)');
-  t.assert(map0.get('y-map').get('y-array').get(0) === -1, 'client 0 computed the change (type)');
-
-  await users[2].reconnect();
+test('set property', async function xml0 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 2 });
+  xml0.setAttribute('height', 10);
+  t.assert(xml0.getAttribute('height') === 10, 'Simple set+get works');
   await flushAll(t, users);
-
-  t.assert(map1.get('number') === 1, 'client 1 received the update (number)');
-  t.assert(map1.get('string') === 'hello Y', 'client 1 received the update (string)');
-  t.compare(map1.get('object'), { key: { key2: 'value' } }, 'client 1 received the update (object)');
-  t.assert(map1.get('y-map').get('y-array').get(0) === -1, 'client 1 received the update (type)');
-
-  // compare disconnected user
-  t.assert(map2.get('number') === 1, 'client 2 received the update (number) - was disconnected');
-  t.assert(map2.get('string') === 'hello Y', 'client 2 received the update (string) - was disconnected');
-  t.compare(map2.get('object'), { key: { key2: 'value' } }, 'client 2 received the update (object) - was disconnected');
-  t.assert(map2.get('y-map').get('y-array').get(0) === -1, 'client 2 received the update (type) - was disconnected');
+  t.assert(xml1.getAttribute('height') === 10, 'Simple set+get works (remote)');
   await compareUsers(t, users);
 });
 
-test('Basic get&set of Map property (converge via sync)', async function map1 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  map0.set('stuff', 'stuffy');
-  map0.set('undefined', undefined);
-  map0.set('null', null);
-  t.compare(map0.get('stuff'), 'stuffy');
-
-  await flushAll(t, users);
-
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.compare(u.get('stuff'), 'stuffy');
-    t.assert(u.get('undefined') === undefined, 'undefined');
-    t.compare(u.get('null'), null, 'null');
-  }
-  await compareUsers(t, users);
-});
-
-test('Map can set custom types (Map)', async function map2 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  var map = map0.set('Map', new Y$1.Map());
-  map.set('one', 1);
-  map = map0.get('Map');
-  t.compare(map.get('one'), 1);
-  await compareUsers(t, users);
-});
-
-test('Map can set custom types (Map) - get also returns the type', async function map3 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  map0.set('Map', new Y$1.Map());
-  var map = map0.get('Map');
-  map.set('one', 1);
-  map = map0.get('Map');
-  t.compare(map.get('one'), 1);
-  await compareUsers(t, users);
-});
-
-test('Map can set custom types (Array)', async function map4 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  var array = map0.set('Array', new Y$1.Array());
-  array.insert(0, [1, 2, 3]);
-  array = map0.get('Array');
-  t.compare(array.toArray(), [1, 2, 3]);
-  await compareUsers(t, users);
-});
-
-test('Basic get&set of Map property (converge via update)', async function map5 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  map0.set('stuff', 'stuffy');
-  t.compare(map0.get('stuff'), 'stuffy');
-
-  await flushAll(t, users);
-
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.compare(u.get('stuff'), 'stuffy');
-  }
-  await compareUsers(t, users);
-});
-
-test('Basic get&set of Map property (handle conflict)', async function map6 (t) {
-  let { users, map0, map1 } = await initArrays(t, { users: 3 });
-  map0.set('stuff', 'c0');
-  map1.set('stuff', 'c1');
-
-  await flushAll(t, users);
-
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.compare(u.get('stuff'), 'c0');
-  }
-  await compareUsers(t, users);
-});
-
-test('Basic get&set&delete of Map property (handle conflict)', async function map7 (t) {
-  let { users, map0, map1 } = await initArrays(t, { users: 3 });
-  map0.set('stuff', 'c0');
-  map0.delete('stuff');
-  map1.set('stuff', 'c1');
-  await flushAll(t, users);
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.assert(u.get('stuff') === undefined);
-  }
-  await compareUsers(t, users);
-});
-
-test('Basic get&set of Map property (handle three conflicts)', async function map8 (t) {
-  let { users, map0, map1, map2 } = await initArrays(t, { users: 3 });
-  map0.set('stuff', 'c0');
-  map1.set('stuff', 'c1');
-  map1.set('stuff', 'c2');
-  map2.set('stuff', 'c3');
-  await flushAll(t, users);
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.compare(u.get('stuff'), 'c0');
-  }
-  await compareUsers(t, users);
-});
-
-test('Basic get&set&delete of Map property (handle three conflicts)', async function map9 (t) {
-  let { users, map0, map1, map2, map3 } = await initArrays(t, { users: 4 });
-  map0.set('stuff', 'c0');
-  map1.set('stuff', 'c1');
-  map1.set('stuff', 'c2');
-  map2.set('stuff', 'c3');
-  await flushAll(t, users);
-  map0.set('stuff', 'deleteme');
-  map0.delete('stuff');
-  map1.set('stuff', 'c1');
-  map2.set('stuff', 'c2');
-  map3.set('stuff', 'c3');
-  await flushAll(t, users);
-  for (let user of users) {
-    var u = user.get('map', Y$1.Map);
-    t.assert(u.get('stuff') === undefined);
-  }
-  await compareUsers(t, users);
-});
-
-/* TODO reimplement observePath
-test('observePath properties', async function map10 (t) {
-  let { users, map0, map1, map2 } = await initArrays(t, { users: 3 })
-  let map
-  map0.observePath(['map'], function (map) {
-    if (map != null) {
-      map.set('yay', 4)
-    }
-  })
-  map1.set('map', new Y.Map())
-  await flushAll(t, users)
-  map = map2.get('map')
-  t.compare(map.get('yay'), 4)
-  await compareUsers(t, users)
-})
-*/
-
-test('observe deep properties', async function map11 (t) {
-  let { users, map1, map2, map3 } = await initArrays(t, { users: 4 });
-  var _map1 = map1.set('map', new Y$1.Map());
-  var calls = 0;
-  var dmapid;
-  map1.observeDeep(function (events) {
-    events.forEach(event => {
-      calls++;
-      t.assert(event.keysChanged.has('deepmap'));
-      t.assert(event.path.length === 1);
-      t.assert(event.path[0] === 'map');
-      dmapid = event.target.get('deepmap')._id;
-    });
-  });
-  await flushAll(t, users);
-  await flushAll(t, users);
-  var _map3 = map3.get('map');
-  _map3.set('deepmap', new Y$1.Map());
-  await flushAll(t, users);
-  var _map2 = map2.get('map');
-  _map2.set('deepmap', new Y$1.Map());
-  await flushAll(t, users);
-  await flushAll(t, users);
-  var dmap1 = _map1.get('deepmap');
-  var dmap2 = _map2.get('deepmap');
-  var dmap3 = _map3.get('deepmap');
-  t.assert(calls > 0);
-  t.assert(dmap1._id.equals(dmap2._id));
-  t.assert(dmap1._id.equals(dmap3._id));
-  t.assert(dmap1._id.equals(dmapid));
-  await compareUsers(t, users);
-});
-
-test('observes using observeDeep', async function map12 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 });
-  var pathes = [];
-  var calls = 0;
-  map0.observeDeep(function (events) {
-    events.forEach(event => {
-      pathes.push(event.path);
-    });
-    calls++;
-  });
-  map0.set('map', new Y$1.Map());
-  map0.get('map').set('array', new Y$1.Array());
-  map0.get('map').get('array').insert(0, ['content']);
-  t.assert(calls === 3);
-  t.compare(pathes, [[], ['map'], ['map', 'array']]);
-  await compareUsers(t, users);
-});
-
-/* TODO: Test events in Y.Map
-function compareEvent (t, is, should) {
-  for (var key in should) {
-    t.assert(should[key] === is[key])
-  }
-}
-
-test('throws add & update & delete events (with type and primitive content)', async function map13 (t) {
-  let { users, map0 } = await initArrays(t, { users: 2 })
+/* TODO: Test YXml events!
+test('events', async function xml1 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 2 })
   var event
-  await flushAll(t, users)
-  map0.observe(function (e) {
-    event = e // just put it on event, should be thrown synchronously anyway
-  })
-  map0.set('stuff', 4)
-  compareEvent(t, event, {
-    type: 'add',
-    object: map0,
-    name: 'stuff'
-  })
-  // update, oldValue is in contents
-  map0.set('stuff', new Y.Array())
-  compareEvent(t, event, {
-    type: 'update',
-    object: map0,
-    name: 'stuff',
-    oldValue: 4
-  })
-  var replacedArray = map0.get('stuff')
-  // update, oldValue is in opContents
-  map0.set('stuff', 5)
-  var array = event.oldValue
-  t.compare(array._model, replacedArray._model)
-  // delete
-  map0.delete('stuff')
-  compareEvent(t, event, {
-    type: 'delete',
-    name: 'stuff',
-    object: map0,
-    oldValue: 5
-  })
-  await compareUsers(t, users)
-})
-*/
-
-/* reimplement event.value somehow (probably with ss vector)
-test('event has correct value when setting a primitive on a YMap (same user)', async function map14 (t) {
-  let { users, map0 } = await initArrays(t, { users: 3 })
-  var event
-  await flushAll(t, users)
-  map0.observe(function (e) {
+  var remoteEvent
+  let expectedEvent
+  xml0.observe(function (e) {
+    delete e._content
+    delete e.nodes
+    delete e.values
     event = e
   })
-  map0.set('stuff', 2)
-  t.compare(event.value, event.target.get(event.name))
-  await compareUsers(t, users)
-})
-
-test('event has correct value when setting a primitive on a YMap (received from another user)', async function map15 (t) {
-  let { users, map0, map1 } = await initArrays(t, { users: 3 })
-  var event
-  await flushAll(t, users)
-  map0.observe(function (e) {
-    event = e
+  xml1.observe(function (e) {
+    delete e._content
+    delete e.nodes
+    delete e.values
+    remoteEvent = e
   })
-  map1.set('stuff', 2)
+  xml0.setAttribute('key', 'value')
+  expectedEvent = {
+    type: 'attributeChanged',
+    value: 'value',
+    name: 'key'
+  }
+  t.compare(event, expectedEvent, 'attribute changed event')
   await flushAll(t, users)
-  t.compare(event.value, event.target.get(event.name))
+  t.compare(remoteEvent, expectedEvent, 'attribute changed event (remote)')
+  // check attributeRemoved
+  xml0.removeAttribute('key')
+  expectedEvent = {
+    type: 'attributeRemoved',
+    name: 'key'
+  }
+  t.compare(event, expectedEvent, 'attribute deleted event')
+  await flushAll(t, users)
+  t.compare(remoteEvent, expectedEvent, 'attribute deleted event (remote)')
+  // test childInserted event
+  expectedEvent = {
+    type: 'childInserted',
+    index: 0
+  }
+  xml0.insert(0, [new Y.XmlText('some text')])
+  t.compare(event, expectedEvent, 'child inserted event')
+  await flushAll(t, users)
+  t.compare(remoteEvent, expectedEvent, 'child inserted event (remote)')
+  // test childRemoved
+  xml0.delete(0)
+  expectedEvent = {
+    type: 'childRemoved',
+    index: 0
+  }
+  t.compare(event, expectedEvent, 'child deleted event')
+  await flushAll(t, users)
+  t.compare(remoteEvent, expectedEvent, 'child deleted event (remote)')
   await compareUsers(t, users)
 })
 */
 
-var mapTransactions = [
-  function set (t, user, chance) {
-    let key = chance.pickone(['one', 'two']);
-    var value = chance.string();
-    user.get('map', Y$1.Map).set(key, value);
-  },
-  function setType (t, user, chance) {
-    let key = chance.pickone(['one', 'two']);
-    var type = chance.pickone([new Y$1.Array(), new Y$1.Map()]);
-    user.get('map', Y$1.Map).set(key, type);
-    if (type instanceof Y$1.Array) {
-      type.insert(0, [1, 2, 3, 4]);
+test('attribute modifications (y -> dom)', async function xml2 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.setAttribute('height', '100px');
+  await wait();
+  t.assert(dom0.getAttribute('height') === '100px', 'setAttribute');
+  xml0.removeAttribute('height');
+  await wait();
+  t.assert(dom0.getAttribute('height') == null, 'removeAttribute');
+  xml0.setAttribute('class', 'stuffy stuff');
+  await wait();
+  t.assert(dom0.getAttribute('class') === 'stuffy stuff', 'set class attribute');
+  await compareUsers(t, users);
+});
+
+test('attribute modifications (dom -> y)', async function xml3 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  dom0.setAttribute('height', '100px');
+  await wait();
+  t.assert(xml0.getAttribute('height') === '100px', 'setAttribute');
+  dom0.removeAttribute('height');
+  await wait();
+  t.assert(xml0.getAttribute('height') == null, 'removeAttribute');
+  dom0.setAttribute('class', 'stuffy stuff');
+  await wait();
+  t.assert(xml0.getAttribute('class') === 'stuffy stuff', 'set class attribute');
+  await compareUsers(t, users);
+});
+
+test('element insert (dom -> y)', async function xml4 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  dom0.insertBefore(document.createTextNode('some text'), null);
+  dom0.insertBefore(document.createElement('p'), null);
+  await wait();
+  t.assert(xml0.get(0).toString() === 'some text', 'Retrieve Text Node');
+  t.assert(xml0.get(1).nodeName === 'P', 'Retrieve Element node');
+  await compareUsers(t, users);
+});
+
+test('element insert (y -> dom)', async function xml5 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlText('some text')]);
+  xml0.insert(1, [new Y$1.XmlElement('p')]);
+  t.assert(dom0.childNodes[0].textContent === 'some text', 'Retrieve Text node');
+  t.assert(dom0.childNodes[1].nodeName === 'P', 'Retrieve Element node');
+  await compareUsers(t, users);
+});
+
+test('y on insert, then delete (dom -> y)', async function xml6 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  dom0.insertBefore(document.createElement('p'), null);
+  await wait();
+  t.assert(xml0.length === 1, 'one node present');
+  dom0.childNodes[0].remove();
+  await wait();
+  t.assert(xml0.length === 0, 'no node present after delete');
+  await compareUsers(t, users);
+});
+
+test('y on insert, then delete (y -> dom)', async function xml7 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlElement('p')]);
+  t.assert(dom0.childNodes[0].nodeName === 'P', 'Get inserted element from dom');
+  xml0.delete(0, 1);
+  t.assert(dom0.childNodes.length === 0, '#childNodes is empty after delete');
+  await compareUsers(t, users);
+});
+
+test('delete consecutive (1) (Text)', async function xml8 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlText('1'), new Y$1.XmlText('2'), new Y$1.XmlText('3')]);
+  await wait();
+  xml0.delete(1, 2);
+  await wait();
+  t.assert(xml0.length === 1, 'check length (y)');
+  t.assert(dom0.childNodes.length === 1, 'check length (dom)');
+  t.assert(dom0.childNodes[0].textContent === '1', 'check content');
+  await compareUsers(t, users);
+});
+
+test('delete consecutive (2) (Text)', async function xml9 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlText('1'), new Y$1.XmlText('2'), new Y$1.XmlText('3')]);
+  await wait();
+  xml0.delete(0, 1);
+  xml0.delete(1, 1);
+  await wait();
+  t.assert(xml0.length === 1, 'check length (y)');
+  t.assert(dom0.childNodes.length === 1, 'check length (dom)');
+  t.assert(dom0.childNodes[0].textContent === '2', 'check content');
+  await compareUsers(t, users);
+});
+
+test('delete consecutive (1) (Element)', async function xml10 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlElement('A'), new Y$1.XmlElement('B'), new Y$1.XmlElement('C')]);
+  await wait();
+  xml0.delete(1, 2);
+  await wait();
+  t.assert(xml0.length === 1, 'check length (y)');
+  t.assert(dom0.childNodes.length === 1, 'check length (dom)');
+  t.assert(dom0.childNodes[0].nodeName === 'A', 'check content');
+  await compareUsers(t, users);
+});
+
+test('delete consecutive (2) (Element)', async function xml11 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  xml0.insert(0, [new Y$1.XmlElement('A'), new Y$1.XmlElement('B'), new Y$1.XmlElement('C')]);
+  await wait();
+  xml0.delete(0, 1);
+  xml0.delete(1, 1);
+  await wait();
+  t.assert(xml0.length === 1, 'check length (y)');
+  t.assert(dom0.childNodes.length === 1, 'check length (dom)');
+  t.assert(dom0.childNodes[0].nodeName === 'B', 'check content');
+  await compareUsers(t, users);
+});
+
+test('Receive a bunch of elements (with disconnect)', async function xml12 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  let dom1 = xml1.getDom();
+  users[1].disconnect();
+  xml0.insert(0, [new Y$1.XmlElement('A'), new Y$1.XmlElement('B'), new Y$1.XmlElement('C')]);
+  xml0.insert(0, [new Y$1.XmlElement('X'), new Y$1.XmlElement('Y'), new Y$1.XmlElement('Z')]);
+  await users[1].reconnect();
+  await flushAll(t, users);
+  t.assert(xml0.length === 6, 'check length (y)');
+  t.assert(xml1.length === 6, 'check length (y) (reconnected user)');
+  t.assert(dom0.childNodes.length === 6, 'check length (dom)');
+  t.assert(dom1.childNodes.length === 6, 'check length (dom) (reconnected user)');
+  await compareUsers(t, users);
+});
+
+test('move element to a different position', async function xml13 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  let dom1 = xml1.getDom();
+  dom0.append(document.createElement('div'));
+  dom0.append(document.createElement('h1'));
+  await flushAll(t, users);
+  dom1.insertBefore(dom1.childNodes[0], null);
+  t.assert(dom1.childNodes[0].nodeName === 'H1', 'div was deleted (user 0)');
+  t.assert(dom1.childNodes[1].nodeName === 'DIV', 'div was moved to the correct position (user 0)');
+  t.assert(dom1.childNodes[0].nodeName === 'H1', 'div was deleted (user 1)');
+  t.assert(dom1.childNodes[1].nodeName === 'DIV', 'div was moved to the correct position (user 1)');
+  await compareUsers(t, users);
+});
+
+test('filter node', async function xml14 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  let dom1 = xml1.getDom();
+  let domFilter = (node, attrs) => {
+    if (node.nodeName === 'H1') {
+      return null
     } else {
-      type.set('deepkey', 'deepvalue');
+      return attrs
+    }
+  };
+  xml0.setDomFilter(domFilter);
+  xml1.setDomFilter(domFilter);
+  dom0.append(document.createElement('div'));
+  dom0.append(document.createElement('h1'));
+  await flushAll(t, users);
+  t.assert(dom1.childNodes.length === 1, 'Only one node was not transmitted');
+  t.assert(dom1.childNodes[0].nodeName === 'DIV', 'div node was transmitted');
+  await compareUsers(t, users);
+});
+
+test('filter attribute', async function xml15 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  let dom1 = xml1.getDom();
+  let domFilter = (node, attrs) => {
+    return attrs.filter(name => name !== 'hidden')
+  };
+  xml0.setDomFilter(domFilter);
+  xml1.setDomFilter(domFilter);
+  dom0.setAttribute('hidden', 'true');
+  dom0.setAttribute('style', 'height: 30px');
+  dom0.setAttribute('data-me', '77');
+  await flushAll(t, users);
+  t.assert(dom0.getAttribute('hidden') === 'true', 'User 0 still has the attribute');
+  t.assert(dom1.getAttribute('hidden') == null, 'User 1 did not receive update');
+  t.assert(dom1.getAttribute('style') === 'height: 30px', 'User 1 received style update');
+  t.assert(dom1.getAttribute('data-me') === '77', 'User 1 received data update');
+  await compareUsers(t, users);
+});
+
+test('deep element insert', async function xml16 (t) {
+  var { users, xml0, xml1 } = await initArrays(t, { users: 3 });
+  let dom0 = xml0.getDom();
+  let dom1 = xml1.getDom();
+  let deepElement = document.createElement('p');
+  let boldElement = document.createElement('b');
+  let attrElement = document.createElement('img');
+  attrElement.setAttribute('src', 'http:localhost:8080/nowhere');
+  boldElement.append(document.createTextNode('hi'));
+  deepElement.append(boldElement);
+  deepElement.append(attrElement);
+  dom0.append(deepElement);
+  console.log(dom0.outerHTML);
+  let str0 = dom0.outerHTML;
+  await flushAll(t, users);
+  let str1 = dom1.outerHTML;
+  t.compare(str0, str1, 'Dom string representation matches');
+  await compareUsers(t, users);
+});
+
+test('treeWalker', async function xml17 (t) {
+  var { users, xml0 } = await initArrays(t, { users: 3 });
+  let paragraph1 = new Y$1.XmlElement('p');
+  let paragraph2 = new Y$1.XmlElement('p');
+  let text1 = new Y$1.Text('init');
+  let text2 = new Y$1.Text('text');
+  paragraph1.insert(0, [text1, text2]);
+  xml0.insert(0, [paragraph1, paragraph2, new Y$1.XmlElement('img')]);
+  let allParagraphs = xml0.querySelectorAll('p');
+  t.assert(allParagraphs.length === 2, 'found exactly two paragraphs');
+  t.assert(allParagraphs[0] === paragraph1, 'querySelectorAll found paragraph1');
+  t.assert(allParagraphs[1] === paragraph2, 'querySelectorAll found paragraph2');
+  t.assert(xml0.querySelector('p') === paragraph1, 'querySelector found paragraph1');
+  await compareUsers(t, users);
+});
+
+// TODO: move elements
+var xmlTransactions = [
+  function attributeChange (t, user, chance) {
+    user.get('xml', Y$1.XmlElement).getDom().setAttribute(chance.word(), chance.word());
+  },
+  function attributeChangeHidden (t, user, chance) {
+    user.get('xml', Y$1.XmlElement).getDom().setAttribute('hidden', chance.word());
+  },
+  function insertText (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
+    dom.insertBefore(document.createTextNode(chance.word()), succ);
+  },
+  function insertHiddenDom (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
+    dom.insertBefore(document.createElement('hidden'), succ);
+  },
+  function insertDom (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    var succ = dom.children.length > 0 ? chance.pickone(dom.children) : null;
+    dom.insertBefore(document.createElement(chance.word()), succ);
+  },
+  function deleteChild (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    if (dom.childNodes.length > 0) {
+      var d = chance.pickone(dom.childNodes);
+      d.remove();
     }
   },
-  function _delete (t, user, chance) {
-    let key = chance.pickone(['one', 'two']);
-    user.get('map', Y$1.Map).delete(key);
+  function insertTextSecondLayer (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    if (dom.children.length > 0) {
+      let dom2 = chance.pickone(dom.children);
+      let succ = dom2.childNodes.length > 0 ? chance.pickone(dom2.childNodes) : null;
+      dom2.insertBefore(document.createTextNode(chance.word()), succ);
+    }
+  },
+  function insertDomSecondLayer (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    if (dom.children.length > 0) {
+      let dom2 = chance.pickone(dom.children);
+      let succ = dom2.childNodes.length > 0 ? chance.pickone(dom2.childNodes) : null;
+      dom2.insertBefore(document.createElement(chance.word()), succ);
+    }
+  },
+  function deleteChildSecondLayer (t, user, chance) {
+    let dom = user.get('xml', Y$1.XmlElement).getDom();
+    if (dom.children.length > 0) {
+      let dom2 = chance.pickone(dom.children);
+      if (dom2.childNodes.length > 0) {
+        let d = chance.pickone(dom2.childNodes);
+        d.remove();
+      }
+    }
   }
 ];
 
-test('y-map: Random tests (42)', async function randomMap42 (t) {
-  await applyRandomTests(t, mapTransactions, 42);
+test('y-xml: Random tests (10)', async function xmlRandom10 (t) {
+  await applyRandomTests(t, xmlTransactions, 10);
 });
 
-test('y-map: Random tests (43)', async function randomMap43 (t) {
-  await applyRandomTests(t, mapTransactions, 43);
+test('y-xml: Random tests (42)', async function xmlRandom42 (t) {
+  await applyRandomTests(t, xmlTransactions, 42);
 });
 
-test('y-map: Random tests (44)', async function randomMap44 (t) {
-  await applyRandomTests(t, mapTransactions, 44);
+test('y-xml: Random tests (43)', async function xmlRandom43 (t) {
+  await applyRandomTests(t, xmlTransactions, 43);
 });
 
-test('y-map: Random tests (45)', async function randomMap45 (t) {
-  await applyRandomTests(t, mapTransactions, 45);
+test('y-xml: Random tests (44)', async function xmlRandom44 (t) {
+  await applyRandomTests(t, xmlTransactions, 44);
 });
 
-test('y-map: Random tests (46)', async function randomMap46 (t) {
-  await applyRandomTests(t, mapTransactions, 46);
+test('y-xml: Random tests (45)', async function xmlRandom45 (t) {
+  await applyRandomTests(t, xmlTransactions, 45);
 });
 
-test('y-map: Random tests (47)', async function randomMap47 (t) {
-  await applyRandomTests(t, mapTransactions, 47);
+test('y-xml: Random tests (46)', async function xmlRandom46 (t) {
+  await applyRandomTests(t, xmlTransactions, 46);
 });
 
-test('y-map: Random tests (200)', async function randomMap200 (t) {
-  await applyRandomTests(t, mapTransactions, 200);
+test('y-xml: Random tests (47)', async function xmlRandom47 (t) {
+  await applyRandomTests(t, xmlTransactions, 47);
 });
 
-test('y-map: Random tests (300)', async function randomMap300 (t) {
-  await applyRandomTests(t, mapTransactions, 300);
+test('y-xml: Random tests (100)', async function xmlRandom100 (t) {
+  await applyRandomTests(t, xmlTransactions, 100);
 });
 
-test('y-map: Random tests (500)', async function randomMap500 (t) {
-  await applyRandomTests(t, mapTransactions, 500);
+test('y-xml: Random tests (200)', async function xmlRandom200 (t) {
+  await applyRandomTests(t, xmlTransactions, 200);
 });
 
-test('y-map: Random tests (1000)', async function randomMap1000 (t) {
-  await applyRandomTests(t, mapTransactions, 1000);
+test('y-xml: Random tests (500)', async function xmlRandom500 (t) {
+  await applyRandomTests(t, xmlTransactions, 500);
 });
 
-test('y-map: Random tests (1800)', async function randomMap1800 (t) {
-  await applyRandomTests(t, mapTransactions, 1800);
+test('y-xml: Random tests (1000)', async function xmlRandom1000 (t) {
+  await applyRandomTests(t, xmlTransactions, 1000);
 });
 
 Object.defineProperty(exports, '__esModule', { value: true });