@fluid-experimental/property-changeset 1.2.7 → 2.0.0-dev.1.3.0.96595

package/lib/changeset_operations/array.js

@@ -23,21 +23,44 @@ const { isPrimitiveType } = TypeIdHelper;
  */
 var ArrayChangeSetRangeType;
 (function (ArrayChangeSetRangeType) {
+    /**
+     * A complete operation of change set A.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["completeA"] = 0] = "completeA";
+    /**
+     * A complete operation of change set B.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["completeB"] = 1] = "completeB";
+    /**
+     * A partial operation of change set A.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["partOfA"] = 2] = "partOfA";
+    /**
+     * A partial operation of change set B.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["partOfB"] = 3] = "partOfB";
+    /**
+     * A complete operation of change set A overlapping with a partial operation of change set B.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["completeApartOfB"] = 4] = "completeApartOfB";
+    /**
+     * A complete operation of change set B overlapping with a partial operation of change set A.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["completeBpartOfA"] = 5] = "completeBpartOfA";
+    /**
+     * A complete operation of change set A overlapping a complete operation of change set B.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["completeAcompleteB"] = 6] = "completeAcompleteB";
+    /**
+     * A partial operation of change set A, a partial operation of change set B.
+     */
     ArrayChangeSetRangeType[ArrayChangeSetRangeType["partOfApartOfB"] = 7] = "partOfApartOfB";
 })(ArrayChangeSetRangeType || (ArrayChangeSetRangeType = {}));
 /**
- * compute a range for an operation of the current change set
- * @param io_operation input
- * @param in_aOffset the offset that needs to be added to transform the operation
- * @param io_resultingRange
- * the computed range
+ * Computes a range for an operation of the current change set
+ * @param io_operation - Input
+ * @param in_aOffset - The offset that needs to be added to transform the operation
+ * @param io_resultingRange - The computed range
  */
 const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_resultingRange) {
     if (!io_operation) {
@@ -81,10 +104,10 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
 };
 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
- * @param io_resultingRange the computed range
- * @param in_flag the flag for the resulting range, default is 'complete B'
+ * Computes the impact range for a given operation of the applied change set
+ * @param in_operation - The op
+ * @param io_resultingRange - The computed range
+ * @param in_flag - The flag for the resulting range, default is 'complete B'
  * @param in_options - Optional additional parameters
  */
 const getRangeForAppliedOperation = function (in_operation, io_resultingRange, in_flag, in_options) {
@@ -106,12 +129,7 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
     io_resultingRange.op.operation[0] = in_operation.operation[0];
     io_resultingRange.begin = in_operation.operation[0];
     io_resultingRange.op._absoluteBegin = in_operation.operation[0];
-    if (in_flag !== undefined) {
-        io_resultingRange.flag = in_flag;
-    }
-    else {
-        io_resultingRange.flag = ArrayChangeSetRangeType.completeB;
-    }
+    io_resultingRange.flag = in_flag !== undefined ? in_flag : ArrayChangeSetRangeType.completeB;
     switch (in_operation.type) {
         case ArrayChangeSetIterator.types.INSERT:
             io_resultingRange.end = in_operation.operation[0];
@@ -126,12 +144,9 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
         case ArrayChangeSetIterator.types.REMOVE:
             let numberOfRemovedElements = getOpLength(in_operation.operation);
             io_resultingRange.end = in_operation.operation[0] + numberOfRemovedElements;
-            if (Array.isArray(in_operation.operation[1])) {
-                io_resultingRange.op.operation[1] = in_operation.operation[1].slice();
-            }
-            else {
-                io_resultingRange.op.operation[1] = in_operation.operation[1];
-            }
+            io_resultingRange.op.operation[1] = Array.isArray(in_operation.operation[1])
+                ? in_operation.operation[1].slice()
+                : in_operation.operation[1];
             io_resultingRange.removeInsertOperation = in_operation.removeInsertOperation;
             return;
         case ArrayChangeSetIterator.types.MODIFY:
@@ -149,10 +164,10 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
  * Splits the second and third parameter in an array remove or modify operation into two segments.
  * This treats the three possible cases array, string and length that are allowed in a remove operation
  *
- * @param in_firstResult  - Place where the first half is stored
+ * @param in_firstResult - Place where the first half is stored
  * @param in_secondResult - Place where the second half is stored
- * @param in_data         - The original operation
- * @param in_start        - Index at which the operation is split
+ * @param in_data - The original operation
+ * @param in_start - Index at which the operation is split
  * @private
  */
 const _splitArrayParameter = function (in_firstResult, in_secondResult, in_data, in_start) {
@@ -230,13 +245,13 @@ const _copyOperation = function (in_sourceOperation, in_targetOperation) {
 /**
  * cut overlapping ranges in non-overlapping and completely overlapping segments
  * ranges of length 0 just cut lengthy ranges
- * @param io_rangeA input A
- * @param io_rangeB input B
- * @param io_resultingSegment the resulting overlapping segment
- * @param in_rebasing is this function called for rebasing - we have to implement two different
- *     behaviors of this function: one for squashing and one for rebasing, because an insert-insert
- *     operation in squashing should be separte segments, while for rebasing, we need one segment
- *     for both inserts to be able to report a conflict.
+ * @param io_rangeA - Input A
+ * @param io_rangeB - Input B
+ * @param io_resultingSegment - The resulting overlapping segment
+ * @param in_rebasing - Is this function called for rebasing - we have to implement two different
+ * behaviors of this function: one for squashing and one for rebasing, because an insert-insert
+ * operation in squashing should be separte segments, while for rebasing, we need one segment
+ * for both inserts to be able to report a conflict.
  * overlapping range or
  * (partial) A or B
  */
@@ -394,22 +409,14 @@ 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) {
-                    if (io_rangeA.op.operation[1].length === rangeLength) {
-                        // We consume both A and B
-                        io_resultingSegment.flag = ArrayChangeSetRangeType.completeAcompleteB;
-                    }
-                    else {
-                        io_resultingSegment.flag = ArrayChangeSetRangeType.completeBpartOfA;
-                    }
+                    io_resultingSegment.flag = io_rangeA.op.operation[1].length === rangeLength
+                        ? ArrayChangeSetRangeType.completeAcompleteB
+                        : ArrayChangeSetRangeType.completeBpartOfA;
                 }
                 else {
-                    if (io_rangeA.op.operation[1].length === rangeLength) {
-                        // We consume A and leave a part of B
-                        io_resultingSegment.flag = ArrayChangeSetRangeType.completeApartOfB;
-                    }
-                    else {
-                        io_resultingSegment.flag = 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 ||
@@ -550,9 +557,9 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
 /**
  * merge in_op with the last op of that category in io_changeset (if possible)
  * e.g. merge an delete [1,3] with delete [3,2] to delete [1,5]
- * @param in_op - the op to merge
- * @param io_changeset - the changeset to merge the op to
- * @param in_targetIndex the transformed target index offset
+ * @param in_op - The op to merge
+ * @param io_changeset - The changeset to merge the op to
+ * @param in_targetIndex - The transformed target index offset
  * @returns true if the merge was possible and executed
  */
 const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, in_options) {
@@ -640,12 +647,12 @@ const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, i
 };
 /**
  * push an operation to a changeset, will try to merge the op if possible
- * @param in_op the operation we want to push
- * @param io_changeset target
- * @param the current offset
+ * @param in_op - The operation we want to push
+ * @param io_changeset - The target
+ * @param the - The current offset
  * @param in_options - Optional additional parameters
- * @param in_lastIteratorARemove - Information about the last remove operation in iterator A
- * @param in_segment - Segment this operation is part of
+ * @param in_lastIteratorARemove - The information about the last remove operation in iterator A
+ * @param in_segment - The segment this operation is part of
  */
 const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_lastIteratorARemove, in_segment) {
     let writeTargetIndex;
@@ -723,8 +730,8 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
 /**
  * handle combinations of range operations
  * e.g. an insert and delete at the same place and same length nullify each other
- * @param in_segment the two ops to be combined
- * @param in_isPrimitiveType is it an array of primitive types
+ * @param in_segment - The two ops to be combined
+ * @param in_isPrimitiveType - Is it an array of primitive types
  * ATTENTION: We overwrite opB to save garbage (instead of creating a result OP)
  */
 const handleCombinations = function (in_segment, in_isPrimitiveType) {
@@ -740,13 +747,7 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
                 }
                 case ArrayChangeSetIterator.types.REMOVE: {
                     // Attention: B removes A completely, kill A to avoid zero inserts
-                    let opBLen;
-                    if (isNumber(opB.operation[1])) {
-                        opBLen = opB.operation[1];
-                    }
-                    else {
-                        opBLen = 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");
                     }
@@ -850,21 +851,27 @@ const arraysHaveSameValues = function (in_arr1, in_arr2) {
  *
  * We have to handle the conflicting rebase changes. The changes we do, are summarized in this table.
  * Other is the modified, rebased (on own) changeset.
+ *
+ * ```
  *                   BASE
  *                  /    \
  *                 /      \
  *               OWN      OTHER
+ * ```
  *
  * gets rebased to:
  *
+ * ```
  *                 BASE
  *                  /
  *               OWN
  *                  \
  *                OTHER
+ * ```
  *
  * conflict default behavior in ()
  *
+ * ```
  * -------|-----------------+------------------+------------------|
  *    \Own|    insert       |       modify     |     remove       |
  *     \  |                 |                  |                  |
@@ -883,16 +890,16 @@ const arraysHaveSameValues = function (in_arr1, in_arr2) {
  * remove | change          | change           | change           |
  *        | [rem orig. data]| (note the user)  | [rem dupl. rem]  |
  * -------|-----------------+------------------+------------------|
+ * ```
  *
- * @param {{opA:{}, opB:{}}} in_segment the two ops to be combined
- * @param {Array.<property-changeset.ChangeSet.ConflictInfo>} out_conflicts -
- *     A list of paths that resulted in conflicts together with the type of the conflict
- * @param {string} in_basePath -
- *     Base path to get to the property processed by this function
- * @param {boolean} in_isPrimitiveType is it an array of primitive types
+ * @param {{opA:{}, opB:{}}} in_segment - The two ops to be combined
+ * @param {Array.<property-changeset.ChangeSet.ConflictInfo>} out_conflicts - A list of paths that resulted in
+ * conflicts together with the type of the conflict
+ * @param {string} in_basePath - Base path to get to the property processed by this function
+ * @param {boolean} in_isPrimitiveType - is it an array of primitive types
  * @param {Object} [in_options] - Optional additional parameters
  * @param {Map} [in_options.applyAfterMetaInformation] - Additional meta information which help later to obtain
- *                                                       more compact changeset during the apply operation
+ * more compact changeset during the apply operation
  */
 const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePath, in_isPrimitiveType, in_options) {
     const opA = in_segment.opA;
@@ -968,20 +975,8 @@ 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
-                    let opBLen;
-                    let opALen;
-                    if (isNumber(opB.operation[1])) {
-                        opBLen = opB.operation[1];
-                    }
-                    else {
-                        opBLen = opB.operation[1].length;
-                    }
-                    if (isNumber(opA.operation[1])) {
-                        opALen = opA.operation[1];
-                    }
-                    else {
-                        opALen = 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.");
@@ -1068,10 +1063,10 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
 };
 /**
  * apply a range's operation to the changeset
- * @param in_segment to be applied
- * @param io_changeset target
- * @param in_currentIndexOffset current offset
- * @param in_isPrimitiveType is it an array of primitive types
+ * @param in_segment - to be applied
+ * @param io_changeset - target
+ * @param in_currentIndexOffset - current offset
+ * @param in_isPrimitiveType - is it an array of primitive types
  */
 const applySegment = function (in_segment, io_changeset, in_currentIndexOffset, lastIteratorARemove, in_isPrimitiveType, in_options) {
     if (!in_segment) {
@@ -1097,12 +1092,12 @@ const applySegment = function (in_segment, io_changeset, in_currentIndexOffset,
 };
 /**
  * apply a range's operation to the rebased changeset
- * @param in_segment to be applied
- * @param io_changeset target
- * @param in_currentIndexOffset current offset
+ * @param in_segment - to be applied
+ * @param io_changeset - target
+ * @param in_currentIndexOffset - current offset
  * @param out_conflicts - A list of paths that resulted in conflicts together with the type of the conflict
  * @param in_basePath - Base path to get to the property processed by this function
- * @param in_isPrimitiveType is it an array of primitive types
+ * @param in_isPrimitiveType - is it an array of primitive types
  */
 const applyRebaseSegment = function (in_segment, io_changeset, in_currentIndexOffset, out_conflicts, in_basePath, in_isPrimitiveType, in_options) {
     if (!in_segment) {
@@ -1123,6 +1118,7 @@ const applyRebaseSegment = function (in_segment, io_changeset, in_currentIndexOf
         pushOp(in_segment.opB, io_changeset, in_currentIndexOffset, in_options);
     }
 };
+// eslint-disable-next-line @typescript-eslint/no-namespace
 export var ChangeSetArrayFunctions;
 (function (ChangeSetArrayFunctions) {
     /**
@@ -1130,9 +1126,9 @@ export var ChangeSetArrayFunctions;
      * property root and it will be applied behind the base ChangeSet (assuming that the changes are relative to the
      * state after the base ChangeSet has been applied. It will change the base ChangeSet.)
      *
-     * @param io_basePropertyChanges    - The ChangeSet describing the initial state
+     * @param io_basePropertyChanges - The ChangeSet describing the initial state
      * @param in_appliedPropertyChanges - The ChangeSet to apply to this state
-     * @param in_typeid                 - The typeid of the contents of the collection (without the collection type)
+     * @param in_typeid - The typeid of the contents of the collection (without the collection type)
      */
     function _performApplyAfterOnPropertyArray(io_basePropertyChanges, in_appliedPropertyChanges, in_typeid, in_options) {
         ConsoleUtils.assert(in_typeid, "_performApplyAfterOnPropertyArray: typeid missing");
@@ -1386,21 +1382,27 @@ export var ChangeSetArrayFunctions;
      *
      * We have to handle the conflicting rebase changes. The changes we do, are summarized in this table.
      * Other is the modified, rebased (on own) changeset.
+     *
+     * ```
      *                   BASE
      *                  /    \
      *                 /      \
      *               OWN      OTHER
+     * ```
      *
      * gets rebased to:
      *
+     * ```
      *                 BASE
      *                  /
      *               OWN
      *                  \
      *                OTHER
+     * ```
      *
      * conflict default behavior in ()
      *
+     * ```
      * -------|-----------------+------------------+------------------|----------------|
      *    \Own|    insert       |       modify     |     remove       |   String set   |
      *     \  |                 |                  |                  |                |
@@ -1421,10 +1423,11 @@ export var ChangeSetArrayFunctions;
      *  set   |           'other's set overwrites whatever happend before              |
      *        |                 |                  |                  |                |
      * --------------------------------------------------------------------------------|
+     * ```
      *
      * @param in_ownPropertyChangeSet - The ChangeSet for the property stored in this object
      * @param io_rebasePropertyChangeSetParent - The Array containing the ChangeSet for the property to be rebased
-     * @param in_key the key to the ChangeSet in io_rebasePropertyChangeSetParent we are rebasing on
+     * @param in_key - The key to the ChangeSet in io_rebasePropertyChangeSetParent we are rebasing on
      * @param in_basePath - Base path to get to the property processed by this function
      * @param out_conflicts - A list of paths that resulted in conflicts together with the type of the conflict
      */