@verdant-web/common 2.8.0 → 2.9.1

package/dist/esm/diffing.test.js

@@ -72,6 +72,26 @@ describe('generating diff operations', () => {
 			`);
             expectDiffProducesResult(from, ops, to);
         });
+        it('handles null values properly', () => {
+            const from = { foo: 'bar', baz: null };
+            assignOid(from, 'test/a');
+            const to = { foo: null, baz: null };
+            assignOid(to, 'test/a');
+            const ops = diffToPatches(from, to, createClock());
+            expect(ops).toEqual([
+                {
+                    authz: undefined,
+                    data: {
+                        name: 'foo',
+                        op: 'set',
+                        value: null,
+                    },
+                    oid: 'test/a',
+                    timestamp: '0',
+                },
+            ]);
+            expectDiffProducesResult(from, ops, to);
+        });
     });
     describe('on nested objects', () => {
         it('replaces whole nested objects', () => {
@@ -391,38 +411,50 @@ describe('generating diff operations', () => {
             const from = assignOid([1, 2, 4, 5, 6, 7], 'test/a');
             const to = assignOid([1, 2, 3, 5, 8], 'test/a');
             const patches = diffToPatches(from, to, createClock());
-            expect(patches).toEqual([
-                {
-                    authz: undefined,
-                    data: {
-                        op: 'list-set',
-                        value: 3,
-                        index: 2,
-                    },
-                    oid: 'test/a',
-                    timestamp: '0',
-                },
-                {
-                    authz: undefined,
-                    data: {
-                        op: 'list-insert',
-                        value: 8,
-                        index: 4,
-                    },
-                    oid: 'test/a',
-                    timestamp: '1',
-                },
-                {
-                    authz: undefined,
-                    data: {
-                        op: 'list-delete',
-                        index: 5,
-                        count: 2,
-                    },
-                    oid: 'test/a',
-                    timestamp: '2',
-                },
-            ]);
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-set",
+				      "value": 3,
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 4,
+				      "op": "list-insert",
+				      "value": 8,
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": 7,
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": 6,
+				    },
+				    "oid": "test/a",
+				    "timestamp": "3",
+				  },
+				]
+			`);
             expectDiffProducesResult(from, patches, to);
         });
     });
@@ -469,159 +501,908 @@ describe('generating diff operations', () => {
 			`);
             expectDiffProducesResult(from, patches, to);
         });
-        it.todo('moves objects by identity');
-        it.todo('removes objects by identity');
-    });
-    describe.todo('on lists of lists', () => {
-        it.todo('rejects operations by value or identity');
-    });
-    it('should work for complex nested arrays and objects', () => {
-        const from = {
-            foo: {
-                bar: [1, 2, 3],
-            },
-            baz: [
-                {
-                    corge: true,
-                },
-            ],
-        };
-        assignOid(from, 'test/a');
-        assignOid(from.foo, 'test/a:1');
-        assignOid(from.foo.bar, 'test/a:2');
-        assignOid(from.baz, 'test/a:3');
-        assignOid(from.baz[0], 'test/a:4');
-        const to = {
-            foo: {
-                bar: [1, 2],
-                bop: [0],
-            },
-            baz: [
-                {
-                    corge: false,
-                },
-                {
-                    corge: false,
-                },
-            ],
-        };
-        assignOid(to, 'test/a');
-        assignOid(to.foo, 'test/a:1');
-        assignOid(to.foo.bar, 'test/a:2');
-        assignOid(to.foo.bop, 'test/a:6');
-        assignOid(to.baz, 'test/a:3');
-        assignOid(to.baz[0], 'test/a:4');
-        assignOid(to.baz[1], 'test/a:5');
-        const patches = diffToPatches(from, to, createClock(), createClock(7));
-        expect(patches).toMatchInlineSnapshot(`
-			[
-			  {
-			    "authz": undefined,
-			    "data": {
-			      "count": 1,
-			      "index": 2,
-			      "op": "list-delete",
-			    },
-			    "oid": "test/a:2",
-			    "timestamp": "0",
-			  },
-			  {
-			    "data": {
-			      "op": "initialize",
-			      "value": [
-			        0,
-			      ],
-			    },
-			    "oid": "test/a:7",
-			    "timestamp": "1",
-			  },
-			  {
-			    "authz": undefined,
-			    "data": {
-			      "name": "bop",
-			      "op": "set",
-			      "value": {
-			        "@@type": "ref",
-			        "id": "test/a:7",
-			      },
-			    },
-			    "oid": "test/a:1",
-			    "timestamp": "2",
-			  },
-			  {
-			    "authz": undefined,
-			    "data": {
-			      "name": "corge",
-			      "op": "set",
-			      "value": false,
-			    },
-			    "oid": "test/a:4",
-			    "timestamp": "3",
-			  },
-			  {
-			    "data": {
-			      "op": "initialize",
-			      "value": {
-			        "corge": false,
-			      },
-			    },
-			    "oid": "test/a:8",
-			    "timestamp": "4",
-			  },
-			  {
-			    "authz": undefined,
-			    "data": {
-			      "op": "list-push",
-			      "value": {
-			        "@@type": "ref",
-			        "id": "test/a:8",
-			      },
-			    },
-			    "oid": "test/a:3",
-			    "timestamp": "5",
-			  },
-			]
-		`);
-        expectDiffProducesResult(from, patches, to);
-    });
-    it('should try to merge unknown objects if specified to do so', () => {
-        const from = {
-            foo: {
-                bar: [1, 2, 3],
-            },
-            baz: [
-                {
-                    corge: true,
-                },
-            ],
-        };
-        assignOid(from, 'test/a');
-        assignOidsToAllSubObjects(from, createClock());
-        const to = {
-            foo: {
-                bar: [1, 2],
-                bop: [0],
-            },
-            baz: [
-                {
-                    corge: false,
-                },
-                {
-                    corge: false,
-                },
-            ],
-        };
-        const patches = diffToPatches(from, to, createClock(), createClock(5), [], {
-            mergeUnknownObjects: true,
+        it('deletes one item from a list', () => {
+            // this replicates a bug I found while testing pruning canonization
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                {},
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({
+                    id: '1',
+                    value: 'Item one',
+                }, 'test/a:0'),
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "op": "delete",
+				    },
+				    "oid": "test/a:2",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
         });
-        expect(patches).toMatchInlineSnapshot(`
+        it('moves an item from the start to the end of the list', () => {
+            // FIXME: the operations end up very inefficient for this. each
+            // other item in the list gets moved before the target item is
+            // moved to the end. can this be improved?
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                { id: '3', value: 'Item three' },
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '3', value: 'Item three' }, 'test/a:2'),
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+                assignOid({ id: '1', value: 'Item one' }, 'test/a:0'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 0,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:0",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "3",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('moves an item from the end to the start of a list', () => {
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                { id: '3', value: 'Item three' },
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+                assignOid({ id: '1', value: 'Item one' }, 'test/a:0'),
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '3', value: 'Item three' }, 'test/a:2'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 0,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:0",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "3",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('swaps two items by reference', () => {
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                { id: '3', value: 'Item three' },
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({ id: '1', value: 'Item one' }, 'test/a:0'),
+                assignOid({ id: '3', value: 'Item three' }, 'test/a:2'),
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('swaps a lot of items by reference', () => {
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                { id: '3', value: 'Item three' },
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({ id: '1', value: 'Item one' }, 'test/a:0'),
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '3', value: 'Item three' }, 'test/a:2'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('produces changes which are resilient to intervening item moves', () => {
+            const from = assignOid([
+                { id: '1', value: 'Item one' },
+                { id: '2', value: 'Item two' },
+                { id: '3', value: 'Item three' },
+                { id: '4', value: 'Item four' },
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                assignOid({ id: '1', value: 'Item one' }, 'test/a:0'),
+                assignOid({ id: '4', value: 'Item four' }, 'test/a:3'),
+                assignOid({ id: '2', value: 'Item two' }, 'test/a:1'),
+                assignOid({ id: '3', value: 'Item three' }, 'test/a:2'),
+            ], 'test/a');
+            const patchClock = createClock(10); // 'the future'
+            const patches = diffToPatches(from, to, patchClock, createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "10",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "11",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-move-by-ref",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "12",
+				  },
+				]
+			`);
+            // in the meantime, suppose a user manipulates the list...
+            const interveningClock = createClock(0);
+            const interveningChanges = [
+                {
+                    oid: 'test/a',
+                    data: {
+                        op: 'list-move-by-index',
+                        from: 1,
+                        to: 2,
+                    },
+                    timestamp: interveningClock(),
+                },
+                {
+                    oid: 'test/a',
+                    data: {
+                        op: 'list-delete',
+                        index: 0,
+                        count: 1,
+                    },
+                    timestamp: interveningClock(),
+                },
+                {
+                    oid: 'test/a:x',
+                    data: {
+                        op: 'initialize',
+                        value: {
+                            id: 'x',
+                            value: 'Item x',
+                        },
+                    },
+                    timestamp: interveningClock(),
+                },
+                {
+                    oid: 'test/a',
+                    data: {
+                        op: 'list-push',
+                        value: {
+                            '@@type': 'ref',
+                            id: 'test/a:x',
+                        },
+                    },
+                    timestamp: interveningClock(),
+                },
+            ];
+            expectDiffProducesResult(from, [...interveningChanges, ...patches], [
+                { id: '4', value: 'Item four' },
+                { id: '2', value: 'Item two' },
+                { id: 'x', value: 'Item x' },
+                { id: '3', value: 'Item three' },
+            ]);
+        });
+    });
+    describe('on lists of files', () => {
+        // FIXME: file refs should work the same as object refs
+        it('pushes items', () => {
+            const from = assignOid([createFileRef('file-1'), createFileRef('file-2')], 'test/a');
+            const to = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(2));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "op": "list-push",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('deletes one item from a list', () => {
+            const from = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            const to = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-insert",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('moves an item from the start to the end of the list', () => {
+            // FIXME: the operations end up very inefficient for this. each
+            // other item in the list gets moved before the target item is
+            // moved to the end. can this be improved?
+            const from = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+                createFileRef('file-1'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 0,
+				      "op": "list-set",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-2",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-set",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 2,
+				      "op": "list-set",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-set",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "3",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('moves an item from the end to the start of a list', () => {
+            const from = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                createFileRef('file-4'),
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 0,
+				      "op": "list-insert",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('swaps two items by reference', () => {
+            const from = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-3'),
+                createFileRef('file-2'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-insert",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 3,
+				      "op": "list-insert",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "2",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-3",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "3",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+        it('swaps a lot of items by reference', () => {
+            const from = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+                createFileRef('file-4'),
+            ], 'test/a');
+            assignOidsToAllSubObjects(from, createClock());
+            const to = assignOid([
+                createFileRef('file-1'),
+                createFileRef('file-4'),
+                createFileRef('file-2'),
+                createFileRef('file-3'),
+            ], 'test/a');
+            const patches = diffToPatches(from, to, createClock(), createClock(4));
+            expect(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "index": 1,
+				      "op": "list-insert",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "authz": undefined,
+				    "data": {
+				      "only": "last",
+				      "op": "list-remove",
+				      "value": {
+				        "@@type": "file",
+				        "id": "file-4",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				]
+			`);
+            expectDiffProducesResult(from, patches, to);
+        });
+    });
+    it('should work for complex nested arrays and objects', () => {
+        const from = {
+            foo: {
+                bar: [1, 2, 3],
+            },
+            baz: [
+                {
+                    corge: true,
+                },
+            ],
+        };
+        assignOid(from, 'test/a');
+        assignOid(from.foo, 'test/a:1');
+        assignOid(from.foo.bar, 'test/a:2');
+        assignOid(from.baz, 'test/a:3');
+        assignOid(from.baz[0], 'test/a:4');
+        const to = {
+            foo: {
+                bar: [1, 2],
+                bop: [0],
+            },
+            baz: [
+                {
+                    corge: false,
+                },
+                {
+                    corge: false,
+                },
+            ],
+        };
+        assignOid(to, 'test/a');
+        assignOid(to.foo, 'test/a:1');
+        assignOid(to.foo.bar, 'test/a:2');
+        assignOid(to.foo.bop, 'test/a:6');
+        assignOid(to.baz, 'test/a:3');
+        assignOid(to.baz[0], 'test/a:4');
+        assignOid(to.baz[1], 'test/a:5');
+        const patches = diffToPatches(from, to, createClock(), createClock(7));
+        expect(patches).toMatchInlineSnapshot(`
+			[
+			  {
+			    "authz": undefined,
+			    "data": {
+			      "only": "last",
+			      "op": "list-remove",
+			      "value": 3,
+			    },
+			    "oid": "test/a:2",
+			    "timestamp": "0",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": [
+			        0,
+			      ],
+			    },
+			    "oid": "test/a:7",
+			    "timestamp": "1",
+			  },
+			  {
+			    "authz": undefined,
+			    "data": {
+			      "name": "bop",
+			      "op": "set",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a:7",
+			      },
+			    },
+			    "oid": "test/a:1",
+			    "timestamp": "2",
+			  },
+			  {
+			    "authz": undefined,
+			    "data": {
+			      "name": "corge",
+			      "op": "set",
+			      "value": false,
+			    },
+			    "oid": "test/a:4",
+			    "timestamp": "3",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "corge": false,
+			      },
+			    },
+			    "oid": "test/a:8",
+			    "timestamp": "4",
+			  },
+			  {
+			    "authz": undefined,
+			    "data": {
+			      "op": "list-push",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a:8",
+			      },
+			    },
+			    "oid": "test/a:3",
+			    "timestamp": "5",
+			  },
+			]
+		`);
+        expectDiffProducesResult(from, patches, to);
+    });
+    it('should try to merge unknown objects if specified to do so', () => {
+        const from = {
+            foo: {
+                bar: [1, 2, 3],
+            },
+            baz: [
+                {
+                    corge: true,
+                },
+            ],
+        };
+        assignOid(from, 'test/a');
+        assignOidsToAllSubObjects(from, createClock());
+        const to = {
+            foo: {
+                bar: [1, 2],
+                bop: [0],
+            },
+            baz: [
+                {
+                    corge: false,
+                },
+                {
+                    corge: false,
+                },
+            ],
+        };
+        const patches = diffToPatches(from, to, createClock(), createClock(5), [], {
+            mergeUnknownObjects: true,
+        });
+        expect(patches).toMatchInlineSnapshot(`
 			[
 			  {
 			    "authz": undefined,
 			    "data": {
-			      "count": 1,
-			      "index": 2,
-			      "op": "list-delete",
+			      "only": "last",
+			      "op": "list-remove",
+			      "value": 3,
 			    },
 			    "oid": "test/a:1",
 			    "timestamp": "0",
@@ -721,9 +1502,12 @@ describe('generating diff operations', () => {
 			  {
 			    "authz": undefined,
 			    "data": {
-			      "count": 1,
-			      "index": 1,
-			      "op": "list-delete",
+			      "only": "last",
+			      "op": "list-remove",
+			      "value": {
+			        "@@type": "file",
+			        "id": "ghi789",
+			      },
 			    },
 			    "oid": "test/a:1",
 			    "timestamp": "1",