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

package/dist/changeset_operations/array.js

@@ -96,7 +96,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_1.ArrayChangeSetIterator.types.MODIFY:
             io_resultingRange.begin = io_operation.operation[0];
@@ -108,7 +109,7 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
             throw new Error(`getRangeForCurrentStateOperation: ${MSG.UNKNOWN_OPERATION}`);
     }
 };
-const getOpLength = (op) => (0, isNumber_1.default)(op[1]) ? op[1] : op[1].length;
+const getOpLength = (op) => ((0, isNumber_1.default)(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
@@ -284,7 +285,8 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
     }
     if (io_rangeB.removeInsertOperation &&
         io_rangeB.op.type === arrayChangesetIterator_1.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];
@@ -321,17 +323,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_1.ArrayChangeSetIterator.types.REMOVE) &&
+        io_rangeA.begin <= io_rangeB.begin &&
+        io_rangeA.begin + nextInsertOffset >= io_rangeB.begin &&
+        io_rangeA.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE &&
         Array.isArray(io_rangeA.op.operation[1]) && // This is a reversible remove operation
-        (io_rangeB.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT)) {
+        io_rangeB.op.type === arrayChangesetIterator_1.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) {
@@ -340,13 +343,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 &&
                         (0, isEqual_1.default)(io_rangeA.op.operation[1].slice(startOffset, startOffset + rangeLength), io_rangeB.op.operation[1].slice(rangeStart, rangeStart + rangeLength))) {
@@ -415,14 +421,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 ||
@@ -439,9 +447,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_1.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;
@@ -456,18 +464,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;
@@ -685,16 +695,20 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
     }
     switch (in_op.type) {
         case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
-            if (in_options && in_options.applyAfterMetaInformation && !(0, isNumber_1.default)(in_op.operation[1])) {
+            if (in_options &&
+                in_options.applyAfterMetaInformation &&
+                !(0, isNumber_1.default)(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],
-                            }],
+                            },
+                        ],
                     });
                 }
             }
@@ -717,7 +731,11 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
         case arrayChangesetIterator_1.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]]);
@@ -753,7 +771,9 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
                 }
                 case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
                     // Attention: B removes A completely, kill A to avoid zero inserts
-                    const opBLen = (0, isNumber_1.default)(opB.operation[1]) ? opB.operation[1] : opB.operation[1].length;
+                    const opBLen = (0, isNumber_1.default)(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");
                     }
@@ -918,11 +938,13 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
             if (!(0, isNumber_1.default)(insertEntries)) {
                 length = insertEntries.length;
                 in_options.applyAfterMetaInformation.set(insertEntries, {
-                    rebasedRemoveInsertRanges: [{
+                    rebasedRemoveInsertRanges: [
+                        {
                             rangeStart: 0,
                             rangeLength: length,
                             originalStartPosition,
-                        }],
+                        },
+                    ],
                 });
             }
         }
@@ -981,8 +1003,12 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                 }
                 case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
                     // Remove already in A, no need to add the same again -> write nop
-                    const opBLen = (0, isNumber_1.default)(opB.operation[1]) ? opB.operation[1] : opB.operation[1].length;
-                    const opALen = (0, isNumber_1.default)(opA.operation[1]) ? opA.operation[1] : opA.operation[1].length;
+                    const opBLen = (0, isNumber_1.default)(opB.operation[1])
+                        ? opB.operation[1]
+                        : opB.operation[1].length;
+                    const opALen = (0, isNumber_1.default)(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.");
@@ -1016,7 +1042,8 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
         case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
             if (in_isPrimitiveType) {
                 // just use opB and notify accordingly
-                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY && opB.operation[1].length > 0) {
+                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY &&
+                    opB.operation[1].length > 0) {
                     delete opA._absoluteBegin;
                     delete opB.offset;
                     let conflict = {
@@ -1079,7 +1106,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 ||
@@ -1142,8 +1171,8 @@ var ChangeSetArrayFunctions;
         property_common_1.ConsoleUtils.assert(!(0, isString_1.default)(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_1.ArrayChangeSetIterator((io_basePropertyChanges));
-        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator((in_appliedPropertyChanges));
+        const iteratorA = new arrayChangesetIterator_1.ArrayChangeSetIterator(io_basePropertyChanges);
+        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator(in_appliedPropertyChanges);
         const rangeA = {};
         const rangeB = {};
         const opA = iteratorA.opDescription;
@@ -1168,8 +1197,7 @@ var ChangeSetArrayFunctions;
             }
             else {
                 iteratorB.next();
-                if (skipIteratorBOperation &&
-                    opB.operation === skipIteratorBOperation) {
+                if (skipIteratorBOperation && opB.operation === skipIteratorBOperation) {
                     iteratorB.next();
                 }
                 skipIteratorBOperation = undefined;
@@ -1186,13 +1214,14 @@ var ChangeSetArrayFunctions;
             let indexOffset = currentIndexOffset;
             if (lastOpWasNop &&
                 (rangeA.begin === undefined || rangeA.begin >= segment.begin) &&
-                (segment.flag === ArrayChangeSetRangeType.completeB &&
-                    segment.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT &&
-                    segment.op.operation[0] === canceledSegmentBegin)) {
+                segment.flag === ArrayChangeSetRangeType.completeB &&
+                segment.op.type === arrayChangesetIterator_1.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_1.ArrayChangeSetIterator.types.NOP;
+            lastOpWasNop =
+                segment.opB !== undefined && segment.opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
             if (lastOpWasNop) {
                 canceledSegmentBegin = segment.begin;
             }
@@ -1206,8 +1235,7 @@ var ChangeSetArrayFunctions;
                 // be placed behind the remove. We detect this case and correct the offset accordingly
                 // in pushOp
                 if (opA.type === arrayChangesetIterator_1.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),
@@ -1218,7 +1246,8 @@ 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);
                             }
                         }
@@ -1228,7 +1257,8 @@ 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);
@@ -1301,8 +1331,8 @@ 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_1.ArrayChangeSetIterator((in_ownPropertyChangeSet));
-        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator((io_rebasePropertyChangeSet));
+        const iteratorA = new arrayChangesetIterator_1.ArrayChangeSetIterator(in_ownPropertyChangeSet);
+        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator(io_rebasePropertyChangeSet);
         const opA = iteratorA.opDescription;
         const rangeA = {};
         getRangeForAppliedOperation(opA, rangeA, ArrayChangeSetRangeType.completeA, in_options);
@@ -1438,8 +1468,9 @@ 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 ((0, isString_1.default)(io_rebasePropertyChangeSetParent[in_key]) || (io_rebasePropertyChangeSetParent[in_key] &&
-            io_rebasePropertyChangeSetParent[in_key].hasOwnProperty("value"))) {
+        if ((0, isString_1.default)(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,
@@ -1460,8 +1491,8 @@ var ChangeSetArrayFunctions;
                 delete io_rebasePropertyChangeSetParent[in_key];
             }
         }
-        else if ((0, isString_1.default)(in_ownPropertyChangeSet) || (in_ownPropertyChangeSet &&
-            in_ownPropertyChangeSet.hasOwnProperty("value"))) {
+        else if ((0, isString_1.default)(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 = {