@fluid-experimental/property-changeset 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/lib/changeset_operations/array.js

@@ -12,7 +12,7 @@ import isEqual from "lodash/isEqual";
 // @ts-ignore
 import { ConsoleUtils, constants } from "@fluid-experimental/property-common";
 import { TypeIdHelper } from "../helpers/typeidHelper";
-import { ArrayChangeSetIterator } from "./arrayChangesetIterator";
+import { ArrayChangeSetIterator, } from "./arrayChangesetIterator";
 import { ConflictType } from "./changesetConflictTypes";
 const { MSG } = constants;
 const { isPrimitiveType } = TypeIdHelper;
@@ -90,7 +90,8 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
             io_resultingRange.end = io_operation.operation[0];
             io_resultingRange.op = io_operation;
             io_resultingRange.flag = ArrayChangeSetRangeType.completeA;
-            io_resultingRange.removeInsertOperation = io_operation.removeInsertOperation;
+            io_resultingRange.removeInsertOperation =
+                io_operation.removeInsertOperation;
             return;
         case ArrayChangeSetIterator.types.MODIFY:
             io_resultingRange.begin = io_operation.operation[0];
@@ -102,7 +103,7 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
             throw new Error(`getRangeForCurrentStateOperation: ${MSG.UNKNOWN_OPERATION}`);
     }
 };
-const getOpLength = (op) => isNumber(op[1]) ? op[1] : op[1].length;
+const getOpLength = (op) => (isNumber(op[1]) ? op[1] : op[1].length);
 /**
  * Computes the impact range for a given operation of the applied change set
  * @param in_operation - The op
@@ -278,7 +279,8 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
     }
     if (io_rangeB.removeInsertOperation &&
         io_rangeB.op.type === ArrayChangeSetIterator.types.REMOVE &&
-        (io_rangeA.begin === undefined || io_rangeB.removeInsertOperation[0] < io_rangeA.begin - io_rangeA.op.offset) &&
+        (io_rangeA.begin === undefined ||
+            io_rangeB.removeInsertOperation[0] < io_rangeA.begin - io_rangeA.op.offset) &&
         io_rangeB.removeInsertOperation[0] < io_rangeB.begin &&
         !io_rangeB.insertAlreadyProcessed) {
         io_resultingSegment.begin = io_rangeB.removeInsertOperation[0];
@@ -315,17 +317,18 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         nextInsertOffset = getOpLength(io_rangeA.removeInsertOperation);
     }
     if (!in_rebasing &&
-        (io_rangeA.begin <= io_rangeB.begin) &&
-        (io_rangeA.begin + nextInsertOffset >= io_rangeB.begin) &&
-        (io_rangeA.op.type === ArrayChangeSetIterator.types.REMOVE) &&
+        io_rangeA.begin <= io_rangeB.begin &&
+        io_rangeA.begin + nextInsertOffset >= io_rangeB.begin &&
+        io_rangeA.op.type === ArrayChangeSetIterator.types.REMOVE &&
         Array.isArray(io_rangeA.op.operation[1]) && // This is a reversible remove operation
-        (io_rangeB.op.type === ArrayChangeSetIterator.types.INSERT)) {
+        io_rangeB.op.type === ArrayChangeSetIterator.types.INSERT) {
         // Are the two operations canceling out?
         let startOffset = 0;
         let rangeStart = 0;
         let matchFound = false;
         let rangeLength = io_rangeB.op.operation[1].length;
-        const operationMetaInfo = in_options && in_options.applyAfterMetaInformation &&
+        const operationMetaInfo = in_options &&
+            in_options.applyAfterMetaInformation &&
             in_options.applyAfterMetaInformation.get(io_rangeB.op.operation[1]);
         if (operationMetaInfo && operationMetaInfo.rebasedRemoveInsertRanges) {
             if (operationMetaInfo.currentInsertOffset === undefined) {
@@ -334,13 +337,16 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
             }
             let i = 0;
             for (; i < operationMetaInfo.rebasedRemoveInsertRanges.length; i++) {
-                if (operationMetaInfo.rebasedRemoveInsertRanges[i].rangeStart >= operationMetaInfo.currentInsertOffset) {
-                    startOffset = operationMetaInfo.rebasedRemoveInsertRanges[i].originalStartPosition -
-                        io_rangeA.op.operation[0] +
-                        io_rangeA.op.offset +
-                        io_rangeB.op.offset;
-                    rangeStart = operationMetaInfo.rebasedRemoveInsertRanges[i].rangeStart -
-                        operationMetaInfo.currentInsertOffset;
+                if (operationMetaInfo.rebasedRemoveInsertRanges[i].rangeStart >=
+                    operationMetaInfo.currentInsertOffset) {
+                    startOffset =
+                        operationMetaInfo.rebasedRemoveInsertRanges[i].originalStartPosition -
+                            io_rangeA.op.operation[0] +
+                            io_rangeA.op.offset +
+                            io_rangeB.op.offset;
+                    rangeStart =
+                        operationMetaInfo.rebasedRemoveInsertRanges[i].rangeStart -
+                            operationMetaInfo.currentInsertOffset;
                     rangeLength = operationMetaInfo.rebasedRemoveInsertRanges[i].rangeLength;
                     if (io_rangeA.op.operation[1].length - startOffset >= rangeLength &&
                         isEqual(io_rangeA.op.operation[1].slice(startOffset, startOffset + rangeLength), io_rangeB.op.operation[1].slice(rangeStart, rangeStart + rangeLength))) {
@@ -409,14 +415,16 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
                 io_resultingSegment.end = io_rangeA.end;
                 io_resultingSegment.op = undefined; // This is used to indicate that we don't need any operation
                 if (io_rangeB.op.operation[1].length === rangeLength) {
-                    io_resultingSegment.flag = io_rangeA.op.operation[1].length === rangeLength
-                        ? ArrayChangeSetRangeType.completeAcompleteB
-                        : ArrayChangeSetRangeType.completeBpartOfA;
+                    io_resultingSegment.flag =
+                        io_rangeA.op.operation[1].length === rangeLength
+                            ? ArrayChangeSetRangeType.completeAcompleteB
+                            : ArrayChangeSetRangeType.completeBpartOfA;
                 }
                 else {
-                    io_resultingSegment.flag = io_rangeA.op.operation[1].length === rangeLength
-                        ? ArrayChangeSetRangeType.completeApartOfB
-                        : ArrayChangeSetRangeType.partOfApartOfB;
+                    io_resultingSegment.flag =
+                        io_rangeA.op.operation[1].length === rangeLength
+                            ? ArrayChangeSetRangeType.completeApartOfB
+                            : ArrayChangeSetRangeType.partOfApartOfB;
                 }
                 // cut the remaining segment entry
                 if (io_resultingSegment.flag === ArrayChangeSetRangeType.partOfApartOfB ||
@@ -433,9 +441,9 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
             }
         }
     }
-    if ((io_rangeA.end < io_rangeB.begin) || // please see in_rebasing comments in the function description
+    if (io_rangeA.end < io_rangeB.begin || // please see in_rebasing comments in the function description
         ((!in_rebasing || io_rangeA.op.type === ArrayChangeSetIterator.types.REMOVE) &&
-            (io_rangeA.end === io_rangeB.begin))) {
+            io_rangeA.end === io_rangeB.begin)) {
         io_resultingSegment.begin = io_rangeA.begin;
         io_resultingSegment.end = io_rangeA.end;
         io_resultingSegment.op = io_rangeA.op;
@@ -450,18 +458,20 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
                     length = length.length;
                 }
                 in_options.applyAfterMetaInformation.set(io_rangeB.op.operation[1], {
-                    rebasedRemoveInsertRanges: [{
+                    rebasedRemoveInsertRanges: [
+                        {
                             rangeStart: 0,
                             rangeLength: length,
                             originalStartPosition: io_rangeA.end + io_rangeB.op.offset,
-                        }],
+                        },
+                    ],
                 });
             }
         }
         return;
     }
-    if ((io_rangeB.end < io_rangeA.begin) || // please see in_rebasing comments in the function description
-        (!in_rebasing && (io_rangeB.end === io_rangeA.begin))) {
+    if (io_rangeB.end < io_rangeA.begin || // please see in_rebasing comments in the function description
+        (!in_rebasing && io_rangeB.end === io_rangeA.begin)) {
         io_resultingSegment.begin = io_rangeB.begin;
         io_resultingSegment.end = io_rangeB.end;
         io_resultingSegment.op = io_rangeB.op;
@@ -679,16 +689,20 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
     }
     switch (in_op.type) {
         case ArrayChangeSetIterator.types.INSERT: {
-            if (in_options && in_options.applyAfterMetaInformation && !isNumber(in_op.operation[1])) {
+            if (in_options &&
+                in_options.applyAfterMetaInformation &&
+                !isNumber(in_op.operation[1])) {
                 // If we don't have any meta information yet, we add an entry with the correct offset applied
                 const metaInfo = in_options.applyAfterMetaInformation.get(in_op.operation[1]);
                 if (!metaInfo) {
                     in_options.applyAfterMetaInformation.set(in_op.operation[1], {
-                        rebasedRemoveInsertRanges: [{
+                        rebasedRemoveInsertRanges: [
+                            {
                                 rangeStart: 0,
                                 rangeLength: in_op.operation[1].length,
                                 originalStartPosition: in_op.operation[0],
-                            }],
+                            },
+                        ],
                     });
                 }
             }
@@ -711,7 +725,11 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
         case ArrayChangeSetIterator.types.MODIFY: {
             if (!mergeWithLastIfPossible(in_op, io_changeset, writeTargetIndex, in_options)) {
                 if (in_op.operation[2] !== undefined) {
-                    io_changeset.modify.push([writeTargetIndex, in_op.operation[1], in_op.operation[2]]);
+                    io_changeset.modify.push([
+                        writeTargetIndex,
+                        in_op.operation[1],
+                        in_op.operation[2],
+                    ]);
                 }
                 else {
                     io_changeset.modify.push([writeTargetIndex, in_op.operation[1]]);
@@ -747,7 +765,9 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
                 }
                 case ArrayChangeSetIterator.types.REMOVE: {
                     // Attention: B removes A completely, kill A to avoid zero inserts
-                    const opBLen = isNumber(opB.operation[1]) ? opB.operation[1] : opB.operation[1].length;
+                    const opBLen = isNumber(opB.operation[1])
+                        ? opB.operation[1]
+                        : opB.operation[1].length;
                     if (opBLen !== opA.operation[1].length) {
                         throw new Error("handleCombinations: insert-remove: unequal number of affected entries");
                     }
@@ -912,11 +932,13 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
             if (!isNumber(insertEntries)) {
                 length = insertEntries.length;
                 in_options.applyAfterMetaInformation.set(insertEntries, {
-                    rebasedRemoveInsertRanges: [{
+                    rebasedRemoveInsertRanges: [
+                        {
                             rangeStart: 0,
                             rangeLength: length,
                             originalStartPosition,
-                        }],
+                        },
+                    ],
                 });
             }
         }
@@ -975,8 +997,12 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                 }
                 case ArrayChangeSetIterator.types.REMOVE: {
                     // Remove already in A, no need to add the same again -> write nop
-                    const opBLen = isNumber(opB.operation[1]) ? opB.operation[1] : opB.operation[1].length;
-                    const opALen = isNumber(opA.operation[1]) ? opA.operation[1] : opA.operation[1].length;
+                    const opBLen = isNumber(opB.operation[1])
+                        ? opB.operation[1]
+                        : opB.operation[1].length;
+                    const opALen = isNumber(opA.operation[1])
+                        ? opA.operation[1]
+                        : opA.operation[1].length;
                     if (opBLen !== opALen) {
                         throw new Error("handleRebaseCombinations: remove-remove: unequal number of affected entries, " +
                             "this should never happen! Probably a bug in splitRange.");
@@ -1010,7 +1036,8 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
         case ArrayChangeSetIterator.types.MODIFY: {
             if (in_isPrimitiveType) {
                 // just use opB and notify accordingly
-                if (opB.type === ArrayChangeSetIterator.types.MODIFY && opB.operation[1].length > 0) {
+                if (opB.type === ArrayChangeSetIterator.types.MODIFY &&
+                    opB.operation[1].length > 0) {
                     delete opA._absoluteBegin;
                     delete opB.offset;
                     let conflict = {
@@ -1073,7 +1100,9 @@ const applySegment = function (in_segment, io_changeset, in_currentIndexOffset,
         throw Error("applySegment: in_segment is undefined!");
     }
     // No operation needs to be performed
-    if (in_segment.op === undefined && in_segment.opA === undefined && in_segment.opB === undefined) {
+    if (in_segment.op === undefined &&
+        in_segment.opA === undefined &&
+        in_segment.opB === undefined) {
         return;
     }
     if (in_segment.flag === ArrayChangeSetRangeType.completeA ||
@@ -1136,8 +1165,8 @@ export var ChangeSetArrayFunctions;
         ConsoleUtils.assert(!isString(in_appliedPropertyChanges), in_appliedPropertyChanges);
         const isPrimitiveTypeid = isPrimitiveType(in_typeid);
         // Iterator to process the changes in the ChangeSet in the correct order
-        const iteratorA = new ArrayChangeSetIterator((io_basePropertyChanges));
-        const iteratorB = new ArrayChangeSetIterator((in_appliedPropertyChanges));
+        const iteratorA = new ArrayChangeSetIterator(io_basePropertyChanges);
+        const iteratorB = new ArrayChangeSetIterator(in_appliedPropertyChanges);
         const rangeA = {};
         const rangeB = {};
         const opA = iteratorA.opDescription;
@@ -1162,8 +1191,7 @@ export var ChangeSetArrayFunctions;
             }
             else {
                 iteratorB.next();
-                if (skipIteratorBOperation &&
-                    opB.operation === skipIteratorBOperation) {
+                if (skipIteratorBOperation && opB.operation === skipIteratorBOperation) {
                     iteratorB.next();
                 }
                 skipIteratorBOperation = undefined;
@@ -1180,13 +1208,14 @@ export var ChangeSetArrayFunctions;
             let indexOffset = currentIndexOffset;
             if (lastOpWasNop &&
                 (rangeA.begin === undefined || rangeA.begin >= segment.begin) &&
-                (segment.flag === ArrayChangeSetRangeType.completeB &&
-                    segment.op.type === ArrayChangeSetIterator.types.INSERT &&
-                    segment.op.operation[0] === canceledSegmentBegin)) {
+                segment.flag === ArrayChangeSetRangeType.completeB &&
+                segment.op.type === ArrayChangeSetIterator.types.INSERT &&
+                segment.op.operation[0] === canceledSegmentBegin) {
                 indexOffset = lastIndexOffset;
             }
             applySegment.call(this, segment, resultPropertyChanges, indexOffset, lastIteratorARemove, isPrimitiveTypeid);
-            lastOpWasNop = segment.opB !== undefined && segment.opB.type === ArrayChangeSetIterator.types.NOP;
+            lastOpWasNop =
+                segment.opB !== undefined && segment.opB.type === ArrayChangeSetIterator.types.NOP;
             if (lastOpWasNop) {
                 canceledSegmentBegin = segment.begin;
             }
@@ -1200,8 +1229,7 @@ export var ChangeSetArrayFunctions;
                 // be placed behind the remove. We detect this case and correct the offset accordingly
                 // in pushOp
                 if (opA.type === ArrayChangeSetIterator.types.REMOVE) {
-                    if (!lastIteratorARemove ||
-                        lastIteratorARemove.position !== opA.operation[0]) {
+                    if (!lastIteratorARemove || lastIteratorARemove.position !== opA.operation[0]) {
                         lastIteratorARemove = {
                             position: opA.operation[0],
                             length: getOpLength(opA.operation),
@@ -1212,7 +1240,8 @@ export var ChangeSetArrayFunctions;
                         // we have to adjust the position to the end of this operation (an insert that is
                         // applied at the position of the remove would be shifted behind this insert)
                         if (opA.removeInsertOperation) {
-                            if (opA.removeInsertOperation[0] + opA.offset === lastIteratorARemove.position) {
+                            if (opA.removeInsertOperation[0] + opA.offset ===
+                                lastIteratorARemove.position) {
                                 lastIteratorARemove.position += getOpLength(opA.removeInsertOperation);
                             }
                         }
@@ -1222,7 +1251,8 @@ export var ChangeSetArrayFunctions;
                 // The offset will only be incremented as soon as the iterator reaches an operation at a different index.
                 // We detect this case and keep track, whether the remove has already been added to the offset or not.
                 if (lastIteratorARemove &&
-                    (opA.operation === undefined || opA.operation[0] !== lastIteratorARemove.currentIndex)) {
+                    (opA.operation === undefined ||
+                        opA.operation[0] !== lastIteratorARemove.currentIndex)) {
                     lastIteratorARemove.offsetIncremented = true;
                 }
                 getRangeForCurrentStateOperation(iteratorA.opDescription, moreAs ? opA.offset : 0, rangeA);
@@ -1295,8 +1325,8 @@ export var ChangeSetArrayFunctions;
     function _rebaseArrayChangeSetForProperty(in_ownPropertyChangeSet, io_rebasePropertyChangeSet, in_basePath, out_conflicts, in_typeid, in_options) {
         const isPrimitiveTypeid = isPrimitiveType(in_typeid);
         // Iterator to process the changes in the ChangeSet in the correct order
-        const iteratorA = new ArrayChangeSetIterator((in_ownPropertyChangeSet));
-        const iteratorB = new ArrayChangeSetIterator((io_rebasePropertyChangeSet));
+        const iteratorA = new ArrayChangeSetIterator(in_ownPropertyChangeSet);
+        const iteratorB = new ArrayChangeSetIterator(io_rebasePropertyChangeSet);
         const opA = iteratorA.opDescription;
         const rangeA = {};
         getRangeForAppliedOperation(opA, rangeA, ArrayChangeSetRangeType.completeA, in_options);
@@ -1432,8 +1462,9 @@ export var ChangeSetArrayFunctions;
      * @param out_conflicts - A list of paths that resulted in conflicts together with the type of the conflict
      */
     function _rebaseChangeSetForString(in_ownPropertyChangeSet, io_rebasePropertyChangeSetParent, in_key, in_basePath, out_conflicts, in_options) {
-        if (isString(io_rebasePropertyChangeSetParent[in_key]) || (io_rebasePropertyChangeSetParent[in_key] &&
-            io_rebasePropertyChangeSetParent[in_key].hasOwnProperty("value"))) {
+        if (isString(io_rebasePropertyChangeSetParent[in_key]) ||
+            (io_rebasePropertyChangeSetParent[in_key] &&
+                io_rebasePropertyChangeSetParent[in_key].hasOwnProperty("value"))) {
             // other overwrites any old changes, we ignore them and report the conflict
             let conflict = {
                 path: in_basePath,
@@ -1454,8 +1485,8 @@ export var ChangeSetArrayFunctions;
                 delete io_rebasePropertyChangeSetParent[in_key];
             }
         }
-        else if (isString(in_ownPropertyChangeSet) || (in_ownPropertyChangeSet &&
-            in_ownPropertyChangeSet.hasOwnProperty("value"))) {
+        else if (isString(in_ownPropertyChangeSet) ||
+            (in_ownPropertyChangeSet && in_ownPropertyChangeSet.hasOwnProperty("value"))) {
             // we have a conflict since we cannot allow insert/remove/modify on an unknown state
             // we just ignore other's modifications and take own's set
             let conflict = {