@verdant-web/common 1.15.2 → 1.15.3-next.0

package/dist/esm/operation.test.js

@@ -1,25 +1,25 @@
-import { describe, expect, it } from 'vitest';
-import { createFileRef } from './files.js';
-import { assignOid, assignOidsToAllSubObjects, createRef, getOid, } from './oids.js';
-import { applyPatch, applyOperations, diffToPatches, initialToPatches, substituteRefsWithObjects, } from './operation.js';
-function createClock(init = 0) {
-    let i = init;
-    const clock = () => (i++).toString();
-    Object.defineProperty(clock, 'current', {
-        get() {
-            return i;
-        },
-    });
-    return clock;
-}
-describe('creating diff patch operations', () => {
-    describe('on flat objects', () => {
-        it('generates and applies set and remove operations', () => {
-            const from = { foo: 'bar', baz: 'qux', zing: 1 };
-            assignOid(from, 'test/a');
-            const to = { foo: 'bar', baz: 'pop' };
-            assignOid(to, 'test/a');
-            const ops = diffToPatches(from, to, createClock());
+import { describe, expect, it } from 'vitest';
+import { createFileRef } from './files.js';
+import { assignOid, assignOidsToAllSubObjects, createRef, getOid, } from './oids.js';
+import { applyPatch, applyOperations, diffToPatches, initialToPatches, substituteRefsWithObjects, } from './operation.js';
+function createClock(init = 0) {
+    let i = init;
+    const clock = () => (i++).toString();
+    Object.defineProperty(clock, 'current', {
+        get() {
+            return i;
+        },
+    });
+    return clock;
+}
+describe('creating diff patch operations', () => {
+    describe('on flat objects', () => {
+        it('generates and applies set and remove operations', () => {
+            const from = { foo: 'bar', baz: 'qux', zing: 1 };
+            assignOid(from, 'test/a');
+            const to = { foo: 'bar', baz: 'pop' };
+            assignOid(to, 'test/a');
+            const ops = diffToPatches(from, to, createClock());
             expect(ops).toMatchInlineSnapshot(`
 				[
 				  {
@@ -40,22 +40,22 @@ describe('creating diff patch operations', () => {
 				    "timestamp": "1",
 				  },
 				]
-			`);
-            const result = applyOperations(from, ops);
-            expect(result).toEqual(to);
-        });
-    });
-    describe('on nested objects', () => {
-        it('replaces whole nested objects', () => {
-            const from = assignOid({
-                foo: 'bar',
-                baz: assignOid({ qux: 'corge' }, 'test/a:0'),
-            }, 'test/a');
-            const to = assignOid({
-                foo: 'bar',
-                baz: assignOid({ qux: 'grault' }, 'test/a:1'),
-            }, 'test/a');
-            const patches = diffToPatches(from, to, createClock());
+			`);
+            const result = applyOperations(from, ops);
+            expect(result).toEqual(to);
+        });
+    });
+    describe('on nested objects', () => {
+        it('replaces whole nested objects', () => {
+            const from = assignOid({
+                foo: 'bar',
+                baz: assignOid({ qux: 'corge' }, 'test/a:0'),
+            }, 'test/a');
+            const to = assignOid({
+                foo: 'bar',
+                baz: assignOid({ qux: 'grault' }, 'test/a:1'),
+            }, 'test/a');
+            const patches = diffToPatches(from, to, createClock());
             expect(patches).toMatchInlineSnapshot(`
 				[
 				  {
@@ -88,22 +88,22 @@ describe('creating diff patch operations', () => {
 				    "timestamp": "2",
 				  },
 				]
-			`);
-        });
-        it('replaces whole nested objects with different ids even if fields are the same', () => {
-            const from = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(from, 'test/a');
-            assignOid(from.baz, 'test/a:0');
-            const to = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(to, 'test/a');
-            assignOid(to.baz, 'test/a:1');
-            const patches = diffToPatches(from, to, createClock());
+			`);
+        });
+        it('replaces whole nested objects with different ids even if fields are the same', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(from, 'test/a');
+            assignOid(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(to, 'test/a');
+            assignOid(to.baz, 'test/a:1');
+            const patches = diffToPatches(from, to, createClock());
             expect(patches).toMatchInlineSnapshot(`
 				[
 				  {
@@ -136,38 +136,38 @@ describe('creating diff patch operations', () => {
 				    "timestamp": "2",
 				  },
 				]
-			`);
-        });
-        it('does not replace objects with the same identity and same fields', () => {
-            const from = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(from, 'test/a');
-            assignOid(from.baz, 'test/a:0');
-            const to = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(to, 'test/a');
-            assignOid(to.baz, 'test/a:0');
-            const patches = diffToPatches(from, to, createClock());
-            expect(patches).toEqual([]);
-        });
-        it('patches sub-objects with same identity', () => {
-            const from = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(from, 'test/a');
-            assignOid(from.baz, 'test/a:0');
-            const to = {
-                foo: 'bar',
-                baz: { qux: 'fig' },
-            };
-            assignOid(to, 'test/a');
-            assignOid(to.baz, 'test/a:0');
-            const patches = diffToPatches(from, to, createClock());
+			`);
+        });
+        it('does not replace objects with the same identity and same fields', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(from, 'test/a');
+            assignOid(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(to, 'test/a');
+            assignOid(to.baz, 'test/a:0');
+            const patches = diffToPatches(from, to, createClock());
+            expect(patches).toEqual([]);
+        });
+        it('patches sub-objects with same identity', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(from, 'test/a');
+            assignOid(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'fig' },
+            };
+            assignOid(to, 'test/a');
+            assignOid(to.baz, 'test/a:0');
+            const patches = diffToPatches(from, to, createClock());
             expect(patches).toMatchInlineSnapshot(`
 				[
 				  {
@@ -180,23 +180,23 @@ describe('creating diff patch operations', () => {
 				    "timestamp": "0",
 				  },
 				]
-			`);
-        });
-        it('retains keys which are undefined in new object if defaultUndefined is set', () => {
-            const from = {
-                foo: 'bar',
-                baz: { qux: 'corge' },
-            };
-            assignOid(from, 'test/a');
-            assignOid(from.baz, 'test/a:0');
-            const to = {
-                foo: 'bip',
-            };
-            assignOid(to, 'test/a');
-            const patches = diffToPatches(from, to, createClock(), undefined, [], {
-                defaultUndefined: true,
-                mergeUnknownObjects: true,
-            });
+			`);
+        });
+        it('retains keys which are undefined in new object if defaultUndefined is set', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            assignOid(from, 'test/a');
+            assignOid(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bip',
+            };
+            assignOid(to, 'test/a');
+            const patches = diffToPatches(from, to, createClock(), undefined, [], {
+                defaultUndefined: true,
+                mergeUnknownObjects: true,
+            });
             expect(patches).toMatchInlineSnapshot(`
 				[
 				  {
@@ -209,74 +209,74 @@ describe('creating diff patch operations', () => {
 				    "timestamp": "0",
 				  },
 				]
-			`);
-        });
-    });
-    describe('on lists of primitives', () => {
-        it('pushes items', async () => {
-            expect(applyOperations(assignOid(['foo', 'bar'], 'test/a'), [
-                {
-                    oid: 'test/a',
-                    timestamp: 'meh',
-                    data: {
-                        op: 'list-push',
-                        value: 'baz',
-                    },
-                },
-            ])).toEqual(assignOid(['foo', 'bar', 'baz'], 'test/a'));
-        });
-        it.todo('sets items');
-        it.todo('inserts items');
-        it.todo('removes items by index');
-        it.todo('removes items by value');
-        it.todo('moves items by index');
-        it.todo('moves items by value');
-    });
-    describe.todo('on lists of objects', () => {
-        it.todo('pushes items');
-        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');
+			`);
+        });
+    });
+    describe('on lists of primitives', () => {
+        it('pushes items', async () => {
+            expect(applyOperations(assignOid(['foo', 'bar'], 'test/a'), [
+                {
+                    oid: 'test/a',
+                    timestamp: 'meh',
+                    data: {
+                        op: 'list-push',
+                        value: 'baz',
+                    },
+                },
+            ])).toEqual(assignOid(['foo', 'bar', 'baz'], 'test/a'));
+        });
+        it.todo('sets items');
+        it.todo('inserts items');
+        it.todo('removes items by index');
+        it.todo('removes items by value');
+        it.todo('moves items by index');
+        it.todo('moves items by value');
+    });
+    describe.todo('on lists of objects', () => {
+        it.todo('pushes items');
+        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');
         expect(diffToPatches(from, to, createClock())).toMatchInlineSnapshot(`
 			[
 			  {
@@ -342,37 +342,37 @@ describe('creating diff patch operations', () => {
 			    "timestamp": "5",
 			  },
 			]
-		`);
-    });
-    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,
-                },
-            ],
-        };
-        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
-            mergeUnknownObjects: true,
+		`);
+    });
+    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,
+                },
+            ],
+        };
+        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
+            mergeUnknownObjects: true,
         })).toMatchInlineSnapshot(`
 			[
 			  {
@@ -438,25 +438,25 @@ describe('creating diff patch operations', () => {
 			    "timestamp": "5",
 			  },
 			]
-		`);
-    });
-    it('should not diff file refs', () => {
-        const from = {
-            foo: {
-                file: createFileRef('abc123'),
-            },
-            bar: [createFileRef('def456'), createFileRef('ghi789')],
-        };
-        assignOid(from, 'test/a');
-        assignOidsToAllSubObjects(from, createClock());
-        const to = {
-            foo: {
-                file: createFileRef('abc456'),
-            },
-            bar: [createFileRef('def456')],
-        };
-        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
-            mergeUnknownObjects: true,
+		`);
+    });
+    it('should not diff file refs', () => {
+        const from = {
+            foo: {
+                file: createFileRef('abc123'),
+            },
+            bar: [createFileRef('def456'), createFileRef('ghi789')],
+        };
+        assignOid(from, 'test/a');
+        assignOidsToAllSubObjects(from, createClock());
+        const to = {
+            foo: {
+                file: createFileRef('abc456'),
+            },
+            bar: [createFileRef('def456')],
+        };
+        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
+            mergeUnknownObjects: true,
         })).toMatchInlineSnapshot(`
 			[
 			  {
@@ -481,26 +481,26 @@ describe('creating diff patch operations', () => {
 			    "timestamp": "1",
 			  },
 			]
-		`);
-    });
-    it('should assign a new OID to objects which had an incompatible existing OID', () => {
-        const from = {
-            foo: {
-                bar: [1, 2, 3],
-            },
-        };
-        assignOid(from, 'test/a');
-        assignOidsToAllSubObjects(from, createClock());
-        const to = {
-            foo: {
-                bar: [1, 2],
-            },
-        };
-        assignOid(to, 'test/a');
-        assignOid(to.foo, 'uff/b');
-        assignOidsToAllSubObjects(to.foo, createClock());
-        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
-            mergeUnknownObjects: true,
+		`);
+    });
+    it('should assign a new OID to objects which had an incompatible existing OID', () => {
+        const from = {
+            foo: {
+                bar: [1, 2, 3],
+            },
+        };
+        assignOid(from, 'test/a');
+        assignOidsToAllSubObjects(from, createClock());
+        const to = {
+            foo: {
+                bar: [1, 2],
+            },
+        };
+        assignOid(to, 'test/a');
+        assignOid(to.foo, 'uff/b');
+        assignOidsToAllSubObjects(to.foo, createClock());
+        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
+            mergeUnknownObjects: true,
         })).toMatchInlineSnapshot(`
 			[
 			  {
@@ -547,25 +547,25 @@ describe('creating diff patch operations', () => {
 			    "timestamp": "3",
 			  },
 			]
-		`);
-    });
-    // an edge case - if a subobject which contains nested objects changes identity,
-    // this gets written as a new init patch tree - we want to ensure all init subobjects
-    // in that tree have compatible OIDs.
-    it('should assign a new OID to objects which have an incompatible OID when parent identity changes', () => {
-        const from = {
-            bar: [],
-        };
-        assignOid(from, 'test/a');
-        assignOid(from.bar, 'test/random');
-        const to = {
-            bar: [{ baz: 1 }, { baz: 2 }],
-        };
-        assignOid(to, 'test/a');
-        assignOidsToAllSubObjects(to, createClock());
-        assignOid(to.bar[0], 'uff/b');
-        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
-            mergeUnknownObjects: true,
+		`);
+    });
+    // an edge case - if a subobject which contains nested objects changes identity,
+    // this gets written as a new init patch tree - we want to ensure all init subobjects
+    // in that tree have compatible OIDs.
+    it('should assign a new OID to objects which have an incompatible OID when parent identity changes', () => {
+        const from = {
+            bar: [],
+        };
+        assignOid(from, 'test/a');
+        assignOid(from.bar, 'test/random');
+        const to = {
+            bar: [{ baz: 1 }, { baz: 2 }],
+        };
+        assignOid(to, 'test/a');
+        assignOidsToAllSubObjects(to, createClock());
+        assignOid(to.bar[0], 'uff/b');
+        expect(diffToPatches(from, to, createClock(), createClock(5), [], {
+            mergeUnknownObjects: true,
         })).toMatchInlineSnapshot(`
 			[
 			  {
@@ -625,157 +625,157 @@ describe('creating diff patch operations', () => {
 			    "timestamp": "4",
 			  },
 			]
-		`);
-    });
-});
-describe('substituting refs with objects', () => {
-    it('does nothing when no refs exist', () => {
-        const root = {
-            foo: 'bar',
-        };
-        assignOid(root, 'test/a');
-        const substituted = substituteRefsWithObjects(root, new Map());
-        expect(root).toEqual(assignOid({
-            foo: 'bar',
-        }, 'test/a'));
-        expect(substituted).toEqual([]);
-    });
-    it('inserts top level objects with oids', () => {
-        const root = {
-            foo: {
-                '@@type': 'ref',
-                id: 'test/1:a',
-            },
-            qux: 1,
-        };
-        assignOid(root, 'test/1');
-        const substituted = substituteRefsWithObjects(root, new Map([['test/1:a', { foo: 'bar' }]]));
-        expect(root).toEqual(assignOid({
-            foo: assignOid({
-                foo: 'bar',
-            }, 'test/1:a'),
-            qux: 1,
-        }, 'test/1'));
-        expect(substituted).toEqual(['test/1:a']);
-        expect(getOid(root)).toEqual('test/1');
-        expect(getOid(root.foo)).toEqual('test/1:a');
-    });
-    it('inserts nested objects with oids', () => {
-        const root = {
-            foo: {
-                '@@type': 'ref',
-                id: 'test/1:a',
-            },
-        };
-        assignOid(root, 'test/1');
-        const substituted = substituteRefsWithObjects(root, new Map([
-            [
-                'test/1:a',
-                {
-                    foo: 'bar',
-                    baz: {
-                        '@@type': 'ref',
-                        id: 'test/1:b',
-                    },
-                },
-            ],
-            [
-                'test/1:b',
-                {
-                    qux: 'corge',
-                },
-            ],
-        ]));
-        expect(root).toEqual(assignOid({
-            foo: assignOid({
-                foo: 'bar',
-                baz: assignOid({
-                    qux: 'corge',
-                }, 'test/1:b'),
-            }, 'test/1:a'),
-        }, 'test/1'));
-        expect(substituted).toEqual(['test/1:a', 'test/1:b']);
-        expect(getOid(root)).toEqual('test/1');
-        expect(getOid(root.foo)).toEqual('test/1:a');
-        expect(getOid(root.foo.baz)).toEqual('test/1:b');
-    });
-    it('substitutes arrays of objects', () => {
-        const root = {
-            foo: {
-                '@@type': 'ref',
-                id: 'test/1:c',
-            },
-        };
-        assignOid(root, 'test/1');
-        const substituted = substituteRefsWithObjects(root, new Map([
-            [
-                'test/1:c',
-                [
-                    {
-                        '@@type': 'ref',
-                        id: 'test/1:a',
-                    },
-                    {
-                        '@@type': 'ref',
-                        id: 'test/1:b',
-                    },
-                ],
-            ],
-            [
-                'test/1:a',
-                {
-                    foo: 'bar',
-                },
-            ],
-            [
-                'test/1:b',
-                {
-                    qux: 'corge',
-                },
-            ],
-        ]));
-        expect(root).toEqual({
-            foo: assignOid([
-                assignOid({
-                    foo: 'bar',
-                }, 'test/1:a'),
-                assignOid({
-                    qux: 'corge',
-                }, 'test/1:b'),
-            ], 'test/1:c'),
-        });
-        expect(substituted).toEqual(['test/1:c', 'test/1:a', 'test/1:b']);
-        expect(getOid(root)).toEqual('test/1');
-        expect(getOid(root.foo)).toEqual('test/1:c');
-        expect(getOid(root.foo[0])).toEqual('test/1:a');
-        expect(getOid(root.foo[1])).toEqual('test/1:b');
-    });
-    it.todo('substitutes arrays of arrays of objects');
-});
-describe('creating patches from initial state', () => {
-    it('adds oids to all sub-objects', async () => {
-        let i = 0;
-        function createSubId() {
-            return (i++).toString();
-        }
-        const result = initialToPatches({
-            foo: {
-                bar: 'baz',
-            },
-            qux: [
-                {
-                    corge: 'grault',
-                },
-                {
-                    bin: {
-                        oof: 1,
-                    },
-                },
-            ],
-        }, 'test/a', createClock(), createSubId);
-        /**
-         * Patches should not include assigned OID property
-         */
+		`);
+    });
+});
+describe('substituting refs with objects', () => {
+    it('does nothing when no refs exist', () => {
+        const root = {
+            foo: 'bar',
+        };
+        assignOid(root, 'test/a');
+        const substituted = substituteRefsWithObjects(root, new Map());
+        expect(root).toEqual(assignOid({
+            foo: 'bar',
+        }, 'test/a'));
+        expect(substituted).toEqual([]);
+    });
+    it('inserts top level objects with oids', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:a',
+            },
+            qux: 1,
+        };
+        assignOid(root, 'test/1');
+        const substituted = substituteRefsWithObjects(root, new Map([['test/1:a', { foo: 'bar' }]]));
+        expect(root).toEqual(assignOid({
+            foo: assignOid({
+                foo: 'bar',
+            }, 'test/1:a'),
+            qux: 1,
+        }, 'test/1'));
+        expect(substituted).toEqual(['test/1:a']);
+        expect(getOid(root)).toEqual('test/1');
+        expect(getOid(root.foo)).toEqual('test/1:a');
+    });
+    it('inserts nested objects with oids', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:a',
+            },
+        };
+        assignOid(root, 'test/1');
+        const substituted = substituteRefsWithObjects(root, new Map([
+            [
+                'test/1:a',
+                {
+                    foo: 'bar',
+                    baz: {
+                        '@@type': 'ref',
+                        id: 'test/1:b',
+                    },
+                },
+            ],
+            [
+                'test/1:b',
+                {
+                    qux: 'corge',
+                },
+            ],
+        ]));
+        expect(root).toEqual(assignOid({
+            foo: assignOid({
+                foo: 'bar',
+                baz: assignOid({
+                    qux: 'corge',
+                }, 'test/1:b'),
+            }, 'test/1:a'),
+        }, 'test/1'));
+        expect(substituted).toEqual(['test/1:a', 'test/1:b']);
+        expect(getOid(root)).toEqual('test/1');
+        expect(getOid(root.foo)).toEqual('test/1:a');
+        expect(getOid(root.foo.baz)).toEqual('test/1:b');
+    });
+    it('substitutes arrays of objects', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:c',
+            },
+        };
+        assignOid(root, 'test/1');
+        const substituted = substituteRefsWithObjects(root, new Map([
+            [
+                'test/1:c',
+                [
+                    {
+                        '@@type': 'ref',
+                        id: 'test/1:a',
+                    },
+                    {
+                        '@@type': 'ref',
+                        id: 'test/1:b',
+                    },
+                ],
+            ],
+            [
+                'test/1:a',
+                {
+                    foo: 'bar',
+                },
+            ],
+            [
+                'test/1:b',
+                {
+                    qux: 'corge',
+                },
+            ],
+        ]));
+        expect(root).toEqual({
+            foo: assignOid([
+                assignOid({
+                    foo: 'bar',
+                }, 'test/1:a'),
+                assignOid({
+                    qux: 'corge',
+                }, 'test/1:b'),
+            ], 'test/1:c'),
+        });
+        expect(substituted).toEqual(['test/1:c', 'test/1:a', 'test/1:b']);
+        expect(getOid(root)).toEqual('test/1');
+        expect(getOid(root.foo)).toEqual('test/1:c');
+        expect(getOid(root.foo[0])).toEqual('test/1:a');
+        expect(getOid(root.foo[1])).toEqual('test/1:b');
+    });
+    it.todo('substitutes arrays of arrays of objects');
+});
+describe('creating patches from initial state', () => {
+    it('adds oids to all sub-objects', async () => {
+        let i = 0;
+        function createSubId() {
+            return (i++).toString();
+        }
+        const result = initialToPatches({
+            foo: {
+                bar: 'baz',
+            },
+            qux: [
+                {
+                    corge: 'grault',
+                },
+                {
+                    bin: {
+                        oof: 1,
+                    },
+                },
+            ],
+        }, 'test/a', createClock(), createSubId);
+        /**
+         * Patches should not include assigned OID property
+         */
         expect(result).toMatchInlineSnapshot(`
 			[
 			  {
@@ -856,120 +856,120 @@ describe('creating patches from initial state', () => {
 			    "timestamp": "5",
 			  },
 			]
-		`);
-    });
-});
-describe('applying individual operations', () => {
-    it('applies a list-remove of only the last instance', () => {
-        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
-            op: 'list-remove',
-            value: 'a',
-            only: 'last',
-        })).toEqual(['a', 'b', 'c', 'b']);
-    });
-    it('applies a list-remove of only the first instance', () => {
-        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
-            op: 'list-remove',
-            value: 'a',
-            only: 'first',
-        })).toEqual(['b', 'c', 'a', 'b']);
-    });
-    it('applies a list-remove of all instances', () => {
-        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
-            op: 'list-remove',
-            value: 'a',
-        })).toEqual(['b', 'c', 'b']);
-    });
-    it('applies a list-remove of an object ref', () => {
-        expect(applyPatch([
-            createRef('a'),
-            createRef('b'),
-            createRef('c'),
-            createRef('a'),
-            createRef('b'),
-        ], {
-            op: 'list-remove',
-            value: createRef('a'),
-            only: 'last',
-        })).toEqual([createRef('a'), createRef('b'), createRef('c'), createRef('b')]);
-    });
-    it('applies a list-add of a nonexistent item', () => {
-        expect(applyPatch(['a', 'b', 'c'], {
-            op: 'list-add',
-            value: 'd',
-        })).toEqual(['a', 'b', 'c', 'd']);
-    });
-    it('does not apply a list-add if the item is already present', () => {
-        expect(applyPatch(['a', 'b', 'c'], {
-            op: 'list-add',
-            value: 'b',
-        })).toEqual(['a', 'b', 'c']);
-    });
-});
-describe('collecting deleted refs during patch application', () => {
-    it('collects refs that are removed from a list', () => {
-        const refs = [];
-        expect(applyPatch([
-            createRef('a'),
-            createRef('b'),
-            createRef('c'),
-            createRef('d'),
-            createRef('e'),
-        ], {
-            op: 'list-remove',
-            value: createRef('c'),
-        }, refs)).toEqual([createRef('a'), createRef('b'), createRef('d'), createRef('e')]);
-        expect(refs).toEqual([createRef('c')]);
-    });
-    it('collects a deleted ref field from an object', () => {
-        const refs = [];
-        expect(applyPatch({
-            a: createRef('a'),
-            b: createRef('b'),
-            c: createRef('c'),
-        }, {
-            op: 'remove',
-            name: 'b',
-        }, refs)).toEqual({
-            a: createRef('a'),
-            c: createRef('c'),
-        });
-        expect(refs).toEqual([createRef('b')]);
-    });
-    it('collects all refs in a deleted object', () => {
-        const refs = [];
-        expect(applyPatch({
-            a: createRef('a'),
-            b: createRef('b'),
-            c: createRef('c'),
-        }, {
-            op: 'delete',
-        }, refs)).toEqual(undefined);
-        expect(refs).toEqual([createRef('a'), createRef('b'), createRef('c')]);
-    });
-    it('collects all refs in a deleted list', () => {
-        const refs = [];
-        expect(applyPatch([createRef('a'), createRef('b'), createRef('c')], {
-            op: 'delete',
-        }, refs)).toEqual(undefined);
-        expect(refs).toEqual([createRef('a'), createRef('b'), createRef('c')]);
-    });
-    it('collects a ref in a replaced field', () => {
-        const refs = [];
-        expect(applyPatch({
-            a: createRef('a'),
-            b: createRef('b'),
-            c: createRef('c'),
-        }, {
-            op: 'set',
-            name: 'b',
-            value: createRef('d'),
-        }, refs)).toEqual({
-            a: createRef('a'),
-            b: createRef('d'),
-            c: createRef('c'),
-        });
-        expect(refs).toEqual([createRef('b')]);
-    });
-});
+		`);
+    });
+});
+describe('applying individual operations', () => {
+    it('applies a list-remove of only the last instance', () => {
+        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+            only: 'last',
+        })).toEqual(['a', 'b', 'c', 'b']);
+    });
+    it('applies a list-remove of only the first instance', () => {
+        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+            only: 'first',
+        })).toEqual(['b', 'c', 'a', 'b']);
+    });
+    it('applies a list-remove of all instances', () => {
+        expect(applyPatch(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+        })).toEqual(['b', 'c', 'b']);
+    });
+    it('applies a list-remove of an object ref', () => {
+        expect(applyPatch([
+            createRef('a'),
+            createRef('b'),
+            createRef('c'),
+            createRef('a'),
+            createRef('b'),
+        ], {
+            op: 'list-remove',
+            value: createRef('a'),
+            only: 'last',
+        })).toEqual([createRef('a'), createRef('b'), createRef('c'), createRef('b')]);
+    });
+    it('applies a list-add of a nonexistent item', () => {
+        expect(applyPatch(['a', 'b', 'c'], {
+            op: 'list-add',
+            value: 'd',
+        })).toEqual(['a', 'b', 'c', 'd']);
+    });
+    it('does not apply a list-add if the item is already present', () => {
+        expect(applyPatch(['a', 'b', 'c'], {
+            op: 'list-add',
+            value: 'b',
+        })).toEqual(['a', 'b', 'c']);
+    });
+});
+describe('collecting deleted refs during patch application', () => {
+    it('collects refs that are removed from a list', () => {
+        const refs = [];
+        expect(applyPatch([
+            createRef('a'),
+            createRef('b'),
+            createRef('c'),
+            createRef('d'),
+            createRef('e'),
+        ], {
+            op: 'list-remove',
+            value: createRef('c'),
+        }, refs)).toEqual([createRef('a'), createRef('b'), createRef('d'), createRef('e')]);
+        expect(refs).toEqual([createRef('c')]);
+    });
+    it('collects a deleted ref field from an object', () => {
+        const refs = [];
+        expect(applyPatch({
+            a: createRef('a'),
+            b: createRef('b'),
+            c: createRef('c'),
+        }, {
+            op: 'remove',
+            name: 'b',
+        }, refs)).toEqual({
+            a: createRef('a'),
+            c: createRef('c'),
+        });
+        expect(refs).toEqual([createRef('b')]);
+    });
+    it('collects all refs in a deleted object', () => {
+        const refs = [];
+        expect(applyPatch({
+            a: createRef('a'),
+            b: createRef('b'),
+            c: createRef('c'),
+        }, {
+            op: 'delete',
+        }, refs)).toEqual(undefined);
+        expect(refs).toEqual([createRef('a'), createRef('b'), createRef('c')]);
+    });
+    it('collects all refs in a deleted list', () => {
+        const refs = [];
+        expect(applyPatch([createRef('a'), createRef('b'), createRef('c')], {
+            op: 'delete',
+        }, refs)).toEqual(undefined);
+        expect(refs).toEqual([createRef('a'), createRef('b'), createRef('c')]);
+    });
+    it('collects a ref in a replaced field', () => {
+        const refs = [];
+        expect(applyPatch({
+            a: createRef('a'),
+            b: createRef('b'),
+            c: createRef('c'),
+        }, {
+            op: 'set',
+            name: 'b',
+            value: createRef('d'),
+        }, refs)).toEqual({
+            a: createRef('a'),
+            b: createRef('d'),
+            c: createRef('c'),
+        });
+        expect(refs).toEqual([createRef('b')]);
+    });
+});
 //# sourceMappingURL=operation.test.js.map