@verdant-web/common 1.11.0

package/dist/cjs/operation.test.js

@@ -0,0 +1,827 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const files_js_1 = require("./files.js");
+const oids_js_1 = require("./oids.js");
+const operation_js_1 = require("./operation.js");
+function createClock(init = 0) {
+    let i = init;
+    return () => (i++).toString();
+}
+(0, vitest_1.describe)('creating diff patch operations', () => {
+    (0, vitest_1.describe)('on flat objects', () => {
+        (0, vitest_1.it)('generates and applies set and remove operations', () => {
+            const from = { foo: 'bar', baz: 'qux', zing: 1 };
+            (0, oids_js_1.assignOid)(from, 'test/a');
+            const to = { foo: 'bar', baz: 'pop' };
+            (0, oids_js_1.assignOid)(to, 'test/a');
+            const ops = (0, operation_js_1.diffToPatches)(from, to, createClock(), []);
+            (0, vitest_1.expect)(ops).toMatchInlineSnapshot(`
+				[
+				  {
+				    "data": {
+				      "name": "baz",
+				      "op": "set",
+				      "value": "pop",
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				  {
+				    "data": {
+				      "name": "zing",
+				      "op": "remove",
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				]
+			`);
+            const result = (0, operation_js_1.applyOperations)(from, ops);
+            (0, vitest_1.expect)(result).toEqual(to);
+        });
+    });
+    (0, vitest_1.describe)('on nested objects', () => {
+        (0, vitest_1.it)('replaces whole nested objects', () => {
+            const from = (0, oids_js_1.assignOid)({
+                foo: 'bar',
+                baz: (0, oids_js_1.assignOid)({ qux: 'corge' }, 'test/a:0'),
+            }, 'test/a');
+            const to = (0, oids_js_1.assignOid)({
+                foo: 'bar',
+                baz: (0, oids_js_1.assignOid)({ qux: 'grault' }, 'test/a:1'),
+            }, 'test/a');
+            const patches = (0, operation_js_1.diffToPatches)(from, to, createClock(), []);
+            (0, vitest_1.expect)(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "data": {
+				      "op": "initialize",
+				      "value": {
+				        "qux": "grault",
+				      },
+				    },
+				    "oid": "test/a:1",
+				    "timestamp": "0",
+				  },
+				  {
+				    "data": {
+				      "name": "baz",
+				      "op": "set",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "data": {
+				      "op": "delete",
+				    },
+				    "oid": "test/a:0",
+				    "timestamp": "2",
+				  },
+				]
+			`);
+        });
+        (0, vitest_1.it)('replaces whole nested objects with different ids even if fields are the same', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(from, 'test/a');
+            (0, oids_js_1.assignOid)(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(to, 'test/a');
+            (0, oids_js_1.assignOid)(to.baz, 'test/a:1');
+            const patches = (0, operation_js_1.diffToPatches)(from, to, createClock(), []);
+            (0, vitest_1.expect)(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "data": {
+				      "op": "initialize",
+				      "value": {
+				        "qux": "corge",
+				      },
+				    },
+				    "oid": "test/a:1",
+				    "timestamp": "0",
+				  },
+				  {
+				    "data": {
+				      "name": "baz",
+				      "op": "set",
+				      "value": {
+				        "@@type": "ref",
+				        "id": "test/a:1",
+				      },
+				    },
+				    "oid": "test/a",
+				    "timestamp": "1",
+				  },
+				  {
+				    "data": {
+				      "op": "delete",
+				    },
+				    "oid": "test/a:0",
+				    "timestamp": "2",
+				  },
+				]
+			`);
+        });
+        (0, vitest_1.it)('does not replace objects with the same identity and same fields', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(from, 'test/a');
+            (0, oids_js_1.assignOid)(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(to, 'test/a');
+            (0, oids_js_1.assignOid)(to.baz, 'test/a:0');
+            const patches = (0, operation_js_1.diffToPatches)(from, to, createClock(), []);
+            (0, vitest_1.expect)(patches).toEqual([]);
+        });
+        (0, vitest_1.it)('patches sub-objects with same identity', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(from, 'test/a');
+            (0, oids_js_1.assignOid)(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bar',
+                baz: { qux: 'fig' },
+            };
+            (0, oids_js_1.assignOid)(to, 'test/a');
+            (0, oids_js_1.assignOid)(to.baz, 'test/a:0');
+            const patches = (0, operation_js_1.diffToPatches)(from, to, createClock(), []);
+            (0, vitest_1.expect)(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "data": {
+				      "name": "qux",
+				      "op": "set",
+				      "value": "fig",
+				    },
+				    "oid": "test/a:0",
+				    "timestamp": "0",
+				  },
+				]
+			`);
+        });
+        (0, vitest_1.it)('retains keys which are undefined in new object if defaultUndefined is set', () => {
+            const from = {
+                foo: 'bar',
+                baz: { qux: 'corge' },
+            };
+            (0, oids_js_1.assignOid)(from, 'test/a');
+            (0, oids_js_1.assignOid)(from.baz, 'test/a:0');
+            const to = {
+                foo: 'bip',
+            };
+            (0, oids_js_1.assignOid)(to, 'test/a');
+            const patches = (0, operation_js_1.diffToPatches)(from, to, createClock(), [], undefined, [], {
+                defaultUndefined: true,
+                mergeUnknownObjects: true,
+            });
+            (0, vitest_1.expect)(patches).toMatchInlineSnapshot(`
+				[
+				  {
+				    "data": {
+				      "name": "foo",
+				      "op": "set",
+				      "value": "bip",
+				    },
+				    "oid": "test/a",
+				    "timestamp": "0",
+				  },
+				]
+			`);
+        });
+    });
+    (0, vitest_1.describe)('on lists of primitives', () => {
+        (0, vitest_1.it)('pushes items', async () => {
+            (0, vitest_1.expect)((0, operation_js_1.applyOperations)((0, oids_js_1.assignOid)(['foo', 'bar'], 'test/a'), [
+                {
+                    oid: 'test/a',
+                    timestamp: 'meh',
+                    data: {
+                        op: 'list-push',
+                        value: 'baz',
+                    },
+                },
+            ])).toEqual((0, oids_js_1.assignOid)(['foo', 'bar', 'baz'], 'test/a'));
+        });
+        vitest_1.it.todo('sets items');
+        vitest_1.it.todo('inserts items');
+        vitest_1.it.todo('removes items by index');
+        vitest_1.it.todo('removes items by value');
+        vitest_1.it.todo('moves items by index');
+        vitest_1.it.todo('moves items by value');
+    });
+    vitest_1.describe.todo('on lists of objects', () => {
+        vitest_1.it.todo('pushes items');
+        vitest_1.it.todo('moves objects by identity');
+        vitest_1.it.todo('removes objects by identity');
+    });
+    vitest_1.describe.todo('on lists of lists', () => {
+        vitest_1.it.todo('rejects operations by value or identity');
+    });
+    (0, vitest_1.it)('should work for complex nested arrays and objects', () => {
+        const from = {
+            foo: {
+                bar: [1, 2, 3],
+            },
+            baz: [
+                {
+                    corge: true,
+                },
+            ],
+        };
+        (0, oids_js_1.assignOid)(from, 'test/a');
+        (0, oids_js_1.assignOid)(from.foo, 'test/a:1');
+        (0, oids_js_1.assignOid)(from.foo.bar, 'test/a:2');
+        (0, oids_js_1.assignOid)(from.baz, 'test/a:3');
+        (0, oids_js_1.assignOid)(from.baz[0], 'test/a:4');
+        const to = {
+            foo: {
+                bar: [1, 2],
+                bop: [0],
+            },
+            baz: [
+                {
+                    corge: false,
+                },
+                {
+                    corge: false,
+                },
+            ],
+        };
+        (0, oids_js_1.assignOid)(to, 'test/a');
+        (0, oids_js_1.assignOid)(to.foo, 'test/a:1');
+        (0, oids_js_1.assignOid)(to.foo.bar, 'test/a:2');
+        (0, oids_js_1.assignOid)(to.foo.bop, 'test/a:6');
+        (0, oids_js_1.assignOid)(to.baz, 'test/a:3');
+        (0, oids_js_1.assignOid)(to.baz[0], 'test/a:4');
+        (0, oids_js_1.assignOid)(to.baz[1], 'test/a:5');
+        (0, vitest_1.expect)((0, operation_js_1.diffToPatches)(from, to, createClock(), [])).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": {
+			      "count": 1,
+			      "index": 2,
+			      "op": "list-delete",
+			    },
+			    "oid": "test/a:2",
+			    "timestamp": "0",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": [
+			        0,
+			      ],
+			    },
+			    "oid": "test/a:6",
+			    "timestamp": "1",
+			  },
+			  {
+			    "data": {
+			      "name": "bop",
+			      "op": "set",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a:6",
+			      },
+			    },
+			    "oid": "test/a:1",
+			    "timestamp": "2",
+			  },
+			  {
+			    "data": {
+			      "name": "corge",
+			      "op": "set",
+			      "value": false,
+			    },
+			    "oid": "test/a:4",
+			    "timestamp": "3",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "corge": false,
+			      },
+			    },
+			    "oid": "test/a:5",
+			    "timestamp": "4",
+			  },
+			  {
+			    "data": {
+			      "name": 1,
+			      "op": "set",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a:5",
+			      },
+			    },
+			    "oid": "test/a:3",
+			    "timestamp": "5",
+			  },
+			]
+		`);
+    });
+    (0, vitest_1.it)('should try to merge unknown objects if specified to do so', () => {
+        const from = {
+            foo: {
+                bar: [1, 2, 3],
+            },
+            baz: [
+                {
+                    corge: true,
+                },
+            ],
+        };
+        (0, oids_js_1.assignOid)(from, 'test/a');
+        (0, oids_js_1.assignOidsToAllSubObjects)(from, createClock());
+        const to = {
+            foo: {
+                bar: [1, 2],
+                bop: [0],
+            },
+            baz: [
+                {
+                    corge: false,
+                },
+                {
+                    corge: false,
+                },
+            ],
+        };
+        (0, vitest_1.expect)((0, operation_js_1.diffToPatches)(from, to, createClock(), [], createClock(5), [], {
+            mergeUnknownObjects: true,
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": {
+			      "count": 1,
+			      "index": 2,
+			      "op": "list-delete",
+			    },
+			    "oid": "test/a.foo.bar:1",
+			    "timestamp": "0",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": [
+			        0,
+			      ],
+			    },
+			    "oid": "test/a.foo.bop:5",
+			    "timestamp": "1",
+			  },
+			  {
+			    "data": {
+			      "name": "bop",
+			      "op": "set",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a.foo.bop:5",
+			      },
+			    },
+			    "oid": "test/a.foo:0",
+			    "timestamp": "2",
+			  },
+			  {
+			    "data": {
+			      "name": "corge",
+			      "op": "set",
+			      "value": false,
+			    },
+			    "oid": "test/a.baz.#:3",
+			    "timestamp": "3",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "corge": false,
+			      },
+			    },
+			    "oid": "test/a.baz.#:6",
+			    "timestamp": "4",
+			  },
+			  {
+			    "data": {
+			      "name": 1,
+			      "op": "set",
+			      "value": {
+			        "@@type": "ref",
+			        "id": "test/a.baz.#:6",
+			      },
+			    },
+			    "oid": "test/a.baz:2",
+			    "timestamp": "5",
+			  },
+			]
+		`);
+    });
+    (0, vitest_1.it)('should not diff file refs', () => {
+        const from = {
+            foo: {
+                file: (0, files_js_1.createFileRef)('abc123'),
+            },
+            bar: [(0, files_js_1.createFileRef)('def456'), (0, files_js_1.createFileRef)('ghi789')],
+        };
+        (0, oids_js_1.assignOid)(from, 'test/a');
+        (0, oids_js_1.assignOidsToAllSubObjects)(from, createClock());
+        const to = {
+            foo: {
+                file: (0, files_js_1.createFileRef)('abc456'),
+            },
+            bar: [(0, files_js_1.createFileRef)('def456')],
+        };
+        (0, vitest_1.expect)((0, operation_js_1.diffToPatches)(from, to, createClock(), [], createClock(5), [], {
+            mergeUnknownObjects: true,
+        })).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": {
+			      "name": "file",
+			      "op": "set",
+			      "value": {
+			        "@@type": "file",
+			        "id": "abc456",
+			      },
+			    },
+			    "oid": "test/a.foo:0",
+			    "timestamp": "0",
+			  },
+			  {
+			    "data": {
+			      "count": 1,
+			      "index": 1,
+			      "op": "list-delete",
+			    },
+			    "oid": "test/a.bar:1",
+			    "timestamp": "1",
+			  },
+			]
+		`);
+    });
+});
+(0, vitest_1.describe)('substituting refs with objects', () => {
+    (0, vitest_1.it)('does nothing when no refs exist', () => {
+        const root = {
+            foo: 'bar',
+        };
+        (0, oids_js_1.assignOid)(root, 'test/a');
+        const substituted = (0, operation_js_1.substituteRefsWithObjects)(root, new Map());
+        (0, vitest_1.expect)(root).toEqual((0, oids_js_1.assignOid)({
+            foo: 'bar',
+        }, 'test/a'));
+        (0, vitest_1.expect)(substituted).toEqual([]);
+    });
+    (0, vitest_1.it)('inserts top level objects with oids', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:a',
+            },
+            qux: 1,
+        };
+        (0, oids_js_1.assignOid)(root, 'test/1');
+        const substituted = (0, operation_js_1.substituteRefsWithObjects)(root, new Map([['test/1:a', { foo: 'bar' }]]));
+        (0, vitest_1.expect)(root).toEqual((0, oids_js_1.assignOid)({
+            foo: (0, oids_js_1.assignOid)({
+                foo: 'bar',
+            }, 'test/1:a'),
+            qux: 1,
+        }, 'test/1'));
+        (0, vitest_1.expect)(substituted).toEqual(['test/1:a']);
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root)).toEqual('test/1');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo)).toEqual('test/1:a');
+    });
+    (0, vitest_1.it)('inserts nested objects with oids', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:a',
+            },
+        };
+        (0, oids_js_1.assignOid)(root, 'test/1');
+        const substituted = (0, operation_js_1.substituteRefsWithObjects)(root, new Map([
+            [
+                'test/1:a',
+                {
+                    foo: 'bar',
+                    baz: {
+                        '@@type': 'ref',
+                        id: 'test/1:b',
+                    },
+                },
+            ],
+            [
+                'test/1:b',
+                {
+                    qux: 'corge',
+                },
+            ],
+        ]));
+        (0, vitest_1.expect)(root).toEqual((0, oids_js_1.assignOid)({
+            foo: (0, oids_js_1.assignOid)({
+                foo: 'bar',
+                baz: (0, oids_js_1.assignOid)({
+                    qux: 'corge',
+                }, 'test/1:b'),
+            }, 'test/1:a'),
+        }, 'test/1'));
+        (0, vitest_1.expect)(substituted).toEqual(['test/1:a', 'test/1:b']);
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root)).toEqual('test/1');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo)).toEqual('test/1:a');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo.baz)).toEqual('test/1:b');
+    });
+    (0, vitest_1.it)('substitutes arrays of objects', () => {
+        const root = {
+            foo: {
+                '@@type': 'ref',
+                id: 'test/1:c',
+            },
+        };
+        (0, oids_js_1.assignOid)(root, 'test/1');
+        const substituted = (0, operation_js_1.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',
+                },
+            ],
+        ]));
+        (0, vitest_1.expect)(root).toEqual({
+            foo: (0, oids_js_1.assignOid)([
+                (0, oids_js_1.assignOid)({
+                    foo: 'bar',
+                }, 'test/1:a'),
+                (0, oids_js_1.assignOid)({
+                    qux: 'corge',
+                }, 'test/1:b'),
+            ], 'test/1:c'),
+        });
+        (0, vitest_1.expect)(substituted).toEqual(['test/1:c', 'test/1:a', 'test/1:b']);
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root)).toEqual('test/1');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo)).toEqual('test/1:c');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo[0])).toEqual('test/1:a');
+        (0, vitest_1.expect)((0, oids_js_1.getOid)(root.foo[1])).toEqual('test/1:b');
+    });
+    vitest_1.it.todo('substitutes arrays of arrays of objects');
+});
+(0, vitest_1.describe)('creating patches from initial state', () => {
+    (0, vitest_1.it)('adds oids to all sub-objects', async () => {
+        let i = 0;
+        function createSubId() {
+            return (i++).toString();
+        }
+        const result = (0, operation_js_1.initialToPatches)({
+            foo: {
+                bar: 'baz',
+            },
+            qux: [
+                {
+                    corge: 'grault',
+                },
+                {
+                    bin: {
+                        oof: 1,
+                    },
+                },
+            ],
+        }, 'test/a', createClock(), createSubId);
+        /**
+         * Patches should not include assigned OID property
+         */
+        (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+			[
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "bar": "baz",
+			      },
+			    },
+			    "oid": "test/a.foo:0",
+			    "timestamp": "0",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "corge": "grault",
+			      },
+			    },
+			    "oid": "test/a.qux.#:2",
+			    "timestamp": "1",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "oof": 1,
+			      },
+			    },
+			    "oid": "test/a.qux.#.bin:4",
+			    "timestamp": "2",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "bin": {
+			          "@@type": "ref",
+			          "id": "test/a.qux.#.bin:4",
+			        },
+			      },
+			    },
+			    "oid": "test/a.qux.#:3",
+			    "timestamp": "3",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": [
+			        {
+			          "@@type": "ref",
+			          "id": "test/a.qux.#:2",
+			        },
+			        {
+			          "@@type": "ref",
+			          "id": "test/a.qux.#:3",
+			        },
+			      ],
+			    },
+			    "oid": "test/a.qux:1",
+			    "timestamp": "4",
+			  },
+			  {
+			    "data": {
+			      "op": "initialize",
+			      "value": {
+			        "foo": {
+			          "@@type": "ref",
+			          "id": "test/a.foo:0",
+			        },
+			        "qux": {
+			          "@@type": "ref",
+			          "id": "test/a.qux:1",
+			        },
+			      },
+			    },
+			    "oid": "test/a",
+			    "timestamp": "5",
+			  },
+			]
+		`);
+    });
+});
+(0, vitest_1.describe)('applying individual operations', () => {
+    (0, vitest_1.it)('applies a list-remove of only the last instance', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+            only: 'last',
+        })).toEqual(['a', 'b', 'c', 'b']);
+    });
+    (0, vitest_1.it)('applies a list-remove of only the first instance', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+            only: 'first',
+        })).toEqual(['b', 'c', 'a', 'b']);
+    });
+    (0, vitest_1.it)('applies a list-remove of all instances', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)(['a', 'b', 'c', 'a', 'b'], {
+            op: 'list-remove',
+            value: 'a',
+        })).toEqual(['b', 'c', 'b']);
+    });
+    (0, vitest_1.it)('applies a list-remove of an object ref', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)([
+            (0, oids_js_1.createRef)('a'),
+            (0, oids_js_1.createRef)('b'),
+            (0, oids_js_1.createRef)('c'),
+            (0, oids_js_1.createRef)('a'),
+            (0, oids_js_1.createRef)('b'),
+        ], {
+            op: 'list-remove',
+            value: (0, oids_js_1.createRef)('a'),
+            only: 'last',
+        })).toEqual([(0, oids_js_1.createRef)('a'), (0, oids_js_1.createRef)('b'), (0, oids_js_1.createRef)('c'), (0, oids_js_1.createRef)('b')]);
+    });
+    (0, vitest_1.it)('applies a list-add of a nonexistent item', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)(['a', 'b', 'c'], {
+            op: 'list-add',
+            value: 'd',
+        })).toEqual(['a', 'b', 'c', 'd']);
+    });
+    (0, vitest_1.it)('does not apply a list-add if the item is already present', () => {
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)(['a', 'b', 'c'], {
+            op: 'list-add',
+            value: 'b',
+        })).toEqual(['a', 'b', 'c']);
+    });
+});
+(0, vitest_1.describe)('collecting deleted refs during patch application', () => {
+    (0, vitest_1.it)('collects refs that are removed from a list', () => {
+        const refs = [];
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)([
+            (0, oids_js_1.createRef)('a'),
+            (0, oids_js_1.createRef)('b'),
+            (0, oids_js_1.createRef)('c'),
+            (0, oids_js_1.createRef)('d'),
+            (0, oids_js_1.createRef)('e'),
+        ], {
+            op: 'list-remove',
+            value: (0, oids_js_1.createRef)('c'),
+        }, refs)).toEqual([(0, oids_js_1.createRef)('a'), (0, oids_js_1.createRef)('b'), (0, oids_js_1.createRef)('d'), (0, oids_js_1.createRef)('e')]);
+        (0, vitest_1.expect)(refs).toEqual([(0, oids_js_1.createRef)('c')]);
+    });
+    (0, vitest_1.it)('collects a deleted ref field from an object', () => {
+        const refs = [];
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)({
+            a: (0, oids_js_1.createRef)('a'),
+            b: (0, oids_js_1.createRef)('b'),
+            c: (0, oids_js_1.createRef)('c'),
+        }, {
+            op: 'remove',
+            name: 'b',
+        }, refs)).toEqual({
+            a: (0, oids_js_1.createRef)('a'),
+            c: (0, oids_js_1.createRef)('c'),
+        });
+        (0, vitest_1.expect)(refs).toEqual([(0, oids_js_1.createRef)('b')]);
+    });
+    (0, vitest_1.it)('collects all refs in a deleted object', () => {
+        const refs = [];
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)({
+            a: (0, oids_js_1.createRef)('a'),
+            b: (0, oids_js_1.createRef)('b'),
+            c: (0, oids_js_1.createRef)('c'),
+        }, {
+            op: 'delete',
+        }, refs)).toEqual(undefined);
+        (0, vitest_1.expect)(refs).toEqual([(0, oids_js_1.createRef)('a'), (0, oids_js_1.createRef)('b'), (0, oids_js_1.createRef)('c')]);
+    });
+    (0, vitest_1.it)('collects all refs in a deleted list', () => {
+        const refs = [];
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)([(0, oids_js_1.createRef)('a'), (0, oids_js_1.createRef)('b'), (0, oids_js_1.createRef)('c')], {
+            op: 'delete',
+        }, refs)).toEqual(undefined);
+        (0, vitest_1.expect)(refs).toEqual([(0, oids_js_1.createRef)('a'), (0, oids_js_1.createRef)('b'), (0, oids_js_1.createRef)('c')]);
+    });
+    (0, vitest_1.it)('collects a ref in a replaced field', () => {
+        const refs = [];
+        (0, vitest_1.expect)((0, operation_js_1.applyPatch)({
+            a: (0, oids_js_1.createRef)('a'),
+            b: (0, oids_js_1.createRef)('b'),
+            c: (0, oids_js_1.createRef)('c'),
+        }, {
+            op: 'set',
+            name: 'b',
+            value: (0, oids_js_1.createRef)('d'),
+        }, refs)).toEqual({
+            a: (0, oids_js_1.createRef)('a'),
+            b: (0, oids_js_1.createRef)('d'),
+            c: (0, oids_js_1.createRef)('c'),
+        });
+        (0, vitest_1.expect)(refs).toEqual([(0, oids_js_1.createRef)('b')]);
+    });
+});
+//# sourceMappingURL=operation.test.js.map