feat: add support for copy

Author: jasoniangreen

src/__tests__/new.test.ts

@@ -137,14 +137,58 @@ describe('JSONPatchOT', () => {
     ]);
   });
 
+  it('should handle array index changes with accepted copies', () => {
+    // [0, 1, 2, 3, 4, 5, 6]; <- Starting array
+    const acceptedOps: Operation[] = [
+      {op: OpType.copy, path: '/array/3', from: '/someval'},
+      {op: OpType.copy, path: '/array/5', from: '/someval'},
+    ];
+
+    // [0, 1, 2, val, 3, val, 4, 5, 6]; <- Array after accepted copies
+
+    // Actions to double some specific values
+    const proposedOps: Operation[] = [
+      {op: OpType.replace, path: '/array/3', value: 6}, // 3 -> 6
+      {op: OpType.replace, path: '/array/4', value: 8}, // 4 -> 8
+      {op: OpType.replace, path: '/array/6', value: 12}, // 6 -> 12
+    ];
+
+    expect(JSONPatchOT(acceptedOps, proposedOps)).toEqual([
+      {op: OpType.replace, path: '/array/4', value: 6},
+      {op: OpType.replace, path: '/array/6', value: 8},
+      {op: OpType.replace, path: '/array/8', value: 12},
+    ]);
+  });
+
+  // it('should handle array index changes with accepted moves to and out of an array', () => {
+  //   // [0, 1, 2, 3, 4, 5, 6]; <- Starting array
+  //   const acceptedOps: Operation[] = [
+  //     // {op: OpType.move, path: '/array/3', from: '/someval'}, //acts like an add
+  //     {op: OpType.move, path: '/someval', from: '/array/5'}, // acts like a remove
+  //   ];
+
+  //   // [0, 1, 2, val, 3, 5, 6]; <- Array after accepted copies
+
+  //   // Actions to double some specific values
+  //   const proposedOps: Operation[] = [
+  //     {op: OpType.replace, path: '/array/5', value: 6}, // 3 -> 6
+  //   ];
+
+  //   expect(JSONPatchOT(acceptedOps, proposedOps)).toEqual([
+  //     {op: OpType.replace, path: '/array/4', value: 6},
+  //     //{op: OpType.replace, path: '/array/6', value: 8}, <- removed
+  //     {op: OpType.replace, path: '/array/8', value: 12},
+  //   ]);
+  // });
+
   it('should handle array index changes with accepted adds and removes', () => {
     // [0, 1, 2, 3, 4, 5, 6]; <- Starting array
     const acceptedOps: Operation[] = [
       {op: OpType.remove, path: '/array/1'},
       {op: OpType.add, path: '/array/3', value: 30},
     ];
 
-    // [0, 2, 3, 30, 4, 5, 6]; <- Array after accepted adds
+    // [0, 2, 3, 30, 4, 5, 6]; <- Array after accepted add and remove
 
     // Actions to double some specific values
     const proposedOps: Operation[] = [

src/index.ts

@@ -58,40 +58,36 @@ export type Operation =
 import {isValidIndex, replacePathIndices} from './utils';
 
 const shiftIndices = function(acceptedOp: Operation, proposedOps: Operation[], isAdd: boolean = false): void {
-  // shift indexes
   const lastSlash = acceptedOp.path.lastIndexOf('/');
 
-  if (lastSlash > -1) {
-    const index = acceptedOp.path.substr(lastSlash + 1);
-    const arrayPath = acceptedOp.path.substr(0, lastSlash + 1);
+  if (lastSlash === -1) return;
 
-    if (isValidIndex(index)) {
-      const propChangesLen = proposedOps.length;
-      let currentIndex = 0;
+  const index = acceptedOp.path.substr(lastSlash + 1);
+  const arrayPath = acceptedOp.path.substr(0, lastSlash + 1);
 
-      while (currentIndex < propChangesLen) {
-        const proposedOp = proposedOps[currentIndex];
-        currentIndex++;
+  if (!isValidIndex(index)) return;
 
-        if (proposedOp.path.indexOf(arrayPath) === 0) {
-          //item from the same array
-          proposedOp.path = replacePathIndices(proposedOp.path, arrayPath, index, isAdd);
-        }
+  proposedOps.forEach((proposedOp) => {
+    const pathOfSameArray = proposedOp.path.indexOf(arrayPath) === 0;
 
-        if (proposedOp.from && proposedOp.from.indexOf(arrayPath) === 0) {
-          //item from the same array
-          proposedOp.from = replacePathIndices(proposedOp.from, arrayPath, index, isAdd);
-        }
-      }
+    if (pathOfSameArray) {
+      proposedOp.path = replacePathIndices(proposedOp.path, arrayPath, index, isAdd);
     }
-  }
+
+    const hasFromOp = proposedOp.op === OpType.move || proposedOp.op === OpType.copy ? proposedOp : null;
+    const fromOfSameArray = hasFromOp && hasFromOp.from && hasFromOp.from.indexOf(arrayPath) === 0;
+
+    if (hasFromOp && fromOfSameArray) {
+      hasFromOp.from = replacePathIndices(hasFromOp.from, arrayPath, index, isAdd);
+    }
+  });
 };
 
 const removeOperations = function(
   acceptedOp: Operation,
   proposedOps: Operation[],
   options: Options,
-  skipCondition?: Function,
+  skipCondition?: (acceptedOp: Operation, proposedOp: Operation) => boolean,
 ) {
   const {acceptedWinsOnEqualPath} = options;
   let currentIndex = 0;
@@ -104,10 +100,9 @@ const removeOperations = function(
     const matchesPathToPath =
       (acceptedWinsOnEqualPath && acceptedOp.path === proposedOp.path) ||
       proposedOp.path.indexOf(acceptedOp.path + '/') === 0;
+    const shouldSkip = !!(skipCondition && skipCondition(acceptedOp, proposedOp));
 
-    if (skipCondition && skipCondition(acceptedOp, proposedOp)) {
-
-    } else if (matchesFromToPath || matchesPathToPath) {
+    if (!shouldSkip && (matchesFromToPath || matchesPathToPath)) {
       proposedOps.splice(currentIndex, 1);
       currentIndex--;
     }
@@ -117,29 +112,10 @@ const removeOperations = function(
 };
 
 const removeTransformer = function(acceptedOp: Operation, proposedOps: Operation[]): void {
-  removeOperations(acceptedOp, proposedOps, {acceptedWinsOnEqualPath: true}, function (acceptedOp, proposedOp) {
+  removeOperations(acceptedOp, proposedOps, {acceptedWinsOnEqualPath: true}, function(acceptedOp, proposedOp) {
     return (proposedOp.op === 'add' || proposedOp.op === 'test') && acceptedOp.path === proposedOp.path;
   });
   shiftIndices(acceptedOp, proposedOps);
-  /*let currentIndex = 0;
-  let proposedOp;
-
-  while ((proposedOp = proposedOps[currentIndex])) {
-    const matchesFromToPath =
-      proposedOp.from && (proposedOp.from === acceptedOp.path || proposedOp.from.indexOf(acceptedOp.path + '/') === 0);
-    const matchesPathToPath =
-      acceptedOp.path === proposedOp.path || proposedOp.path.indexOf(acceptedOp.path + '/') === 0;
-
-    if ((proposedOp.op === 'add' || proposedOp.op === 'test') && acceptedOp.path === proposedOp.path) {
-      // do nothing ? (tomalec)
-    } else if (matchesFromToPath || matchesPathToPath) {
-      proposedOps.splice(currentIndex, 1);
-      currentIndex--;
-    }
-    currentIndex++;
-  }
-
-  shiftIndices(acceptedOp, proposedOps);*/
 };
 
 const replaceTransformer = function(acceptedOp: Operation, proposedOps: Operation[], options: Options): void {
@@ -155,6 +131,7 @@ const transformAgainst = {
   remove: removeTransformer,
   replace: replaceTransformer,
   add: addTransformer,
+  copy: addTransformer,
 };
 
 const reduceJSONPatches = function(proposedOps: Operation[], acceptedOp: Operation, options: Options) {