@fluid-experimental/property-changeset 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/README.md

@@ -1,4 +1,5 @@
 # @fluid-experimental/property-changeset
 
 ## Overview
+
 This package contains the Changeset class and template validators.

package/dist/changeset.d.ts

@@ -5,8 +5,8 @@
 /**
  * @fileoverview Serialized representation of the changes in a repository
  */
-import { ChangeSetArrayFunctions } from './changeset_operations/array';
-import { ConflictType } from './changeset_operations/changesetConflictTypes';
+import { ChangeSetArrayFunctions } from "./changeset_operations/array";
+import { ConflictType } from "./changeset_operations/changesetConflictTypes";
 import { ChangeSetIndexedCollectionFunctions } from "./changeset_operations/indexedCollection";
 export interface ApplyChangeSetOptions {
     /**

package/dist/changeset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"changeset.d.ts","sourceRoot":"","sources":["../src/changeset.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"changeset.d.ts","sourceRoot":"","sources":["../src/changeset.ts"],"names":[],"mappings":"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"}

package/dist/changeset.js

@@ -46,7 +46,8 @@ class ChangeSet {
         if (in_changes === undefined || in_changes === null) {
             this._changes = {};
         }
-        else if ((0, isString_1.default)(in_changes)) { // Stringified Serialized JSON
+        else if ((0, isString_1.default)(in_changes)) {
+            // Stringified Serialized JSON
             this._changes = JSON.parse(in_changes);
         }
         else if (in_changes instanceof ChangeSet) {
@@ -114,7 +115,9 @@ class ChangeSet {
             changes = in_changeSet.getSerializedChangeSet();
         }
         if (!(0, isObject_1.default)(this._changes) || Array.isArray(this._changes)) {
-            const oldValue = (0, isObject_1.default)(changes) && changes.value !== undefined ? changes.value : changes;
+            const oldValue = (0, isObject_1.default)(changes) && changes.value !== undefined
+                ? changes.value
+                : changes;
             this._changes = Array.isArray(oldValue) ? oldValue.slice() : oldValue;
         }
         else {
@@ -172,14 +175,16 @@ class ChangeSet {
      * @param in_appliedValue - applied changes to be applied
      */
     _applyValue(io_baseChanges, in_baseKey, in_appliedValue) {
-        const newValue = (in_appliedValue && in_appliedValue.hasOwnProperty("value")) ?
-            in_appliedValue.value : in_appliedValue;
+        const newValue = in_appliedValue && in_appliedValue.hasOwnProperty("value")
+            ? in_appliedValue.value
+            : in_appliedValue;
         if (io_baseChanges[in_baseKey] && io_baseChanges[in_baseKey].hasOwnProperty("value")) {
             io_baseChanges[in_baseKey].value = newValue;
         }
         else {
             if (io_baseChanges[in_baseKey] === undefined &&
-                in_appliedValue && in_appliedValue.hasOwnProperty("oldValue")) {
+                in_appliedValue &&
+                in_appliedValue.hasOwnProperty("oldValue")) {
                 io_baseChanges[in_baseKey] = {
                     value: newValue,
                     oldValue: in_appliedValue.oldValue,
@@ -204,8 +209,7 @@ class ChangeSet {
      */
     performApplyAfterOnPropertyWithTypeid(in_changedKey, in_baseChanges, in_appliedPropertyChanges, in_typeid, in_removeEmpty, in_options) {
         const splitTypeid = extractContext(in_typeid);
-        if (splitTypeid.context === "set" ||
-            splitTypeid.context === "map") {
+        if (splitTypeid.context === "set" || splitTypeid.context === "map") {
             in_baseChanges[in_changedKey] = in_baseChanges[in_changedKey] || {};
             this._performApplyAfterOnPropertyIndexedCollection(in_baseChanges[in_changedKey], in_appliedPropertyChanges[in_changedKey], splitTypeid.typeid, in_options);
             // Remove the key, when it no longer contains a changeset
@@ -214,27 +218,26 @@ class ChangeSet {
             }
         }
         else if (splitTypeid.context === "array" || splitTypeid.typeid === "String") {
-            in_baseChanges[in_changedKey] = in_baseChanges[in_changedKey] !== undefined ? in_baseChanges[in_changedKey] : {};
+            in_baseChanges[in_changedKey] =
+                in_baseChanges[in_changedKey] !== undefined ? in_baseChanges[in_changedKey] : {};
             let baseIsSetChange = false;
             let oldValue;
             if (splitTypeid.typeid === "String" &&
                 ((0, isString_1.default)(in_baseChanges[in_changedKey]) ||
-                    (in_baseChanges[in_changedKey] && in_baseChanges[in_changedKey].hasOwnProperty("value")))) {
+                    (in_baseChanges[in_changedKey] &&
+                        in_baseChanges[in_changedKey].hasOwnProperty("value")))) {
                 oldValue = in_baseChanges[in_changedKey].oldValue;
                 // we need to convert the format to allow the application of the changes
                 // since _performApplyAfterOnPropertyArray only understands insert/modify/remove commands
-                if (in_baseChanges[in_changedKey] && in_baseChanges[in_changedKey].hasOwnProperty("value")) {
+                if (in_baseChanges[in_changedKey] &&
+                    in_baseChanges[in_changedKey].hasOwnProperty("value")) {
                     in_baseChanges[in_changedKey] = {
-                        insert: [
-                            [0, in_baseChanges[in_changedKey].value],
-                        ],
+                        insert: [[0, in_baseChanges[in_changedKey].value]],
                     };
                 }
                 else {
                     in_baseChanges[in_changedKey] = {
-                        insert: [
-                            [0, in_baseChanges[in_changedKey]],
-                        ],
+                        insert: [[0, in_baseChanges[in_changedKey]]],
                     };
                 }
                 baseIsSetChange = true;
@@ -398,14 +401,16 @@ class ChangeSet {
             if (typeid === "modify" && "modify" in io_rebasePropertyChangeSet) {
                 for (let j = 0; j < paths.length; j++) {
                     const tempTypeid = paths[i];
-                    if ((isPrimitiveType(tempTypeid)) &&
+                    if (isPrimitiveType(tempTypeid) &&
                         tempTypeid in io_rebasePropertyChangeSet.modify) {
                         const tempPaths = Object.keys(in_ownPropertyChangeSet.modify[tempTypeid]);
                         for (let z = 0; z < tempPaths.length; z++) {
                             if (tempPaths[z] in io_rebasePropertyChangeSet.modify[tempTypeid]) {
                                 let rebasedPropContent = io_rebasePropertyChangeSet.modify[tempTypeid][tempPaths[z]];
-                                if ((0, isObject_1.default)(rebasedPropContent) && "oldValue" in rebasedPropContent) {
-                                    rebasedPropContent.oldValue = in_ownPropertyChangeSet.modify[tempTypeid][tempPaths[z]].value;
+                                if ((0, isObject_1.default)(rebasedPropContent) &&
+                                    "oldValue" in rebasedPropContent) {
+                                    rebasedPropContent.oldValue =
+                                        in_ownPropertyChangeSet.modify[tempTypeid][tempPaths[z]].value;
                                 }
                             }
                         }
@@ -417,13 +422,15 @@ class ChangeSet {
                 // io_rebasePropertyChangeSet && in_ownPropertyChangeSet contain only property type, name and value, we update
                 // oldValue of io_rebasePropertyChangeSet.
                 for (let j = 0; j < paths.length; j++) {
-                    if (typeid in io_rebasePropertyChangeSet && paths[j] in io_rebasePropertyChangeSet[typeid]) {
+                    if (typeid in io_rebasePropertyChangeSet &&
+                        paths[j] in io_rebasePropertyChangeSet[typeid]) {
                         let rebasedPropContent = io_rebasePropertyChangeSet[typeid][paths[j]];
                         if ((0, isObject_1.default)(rebasedPropContent) && "oldValue" in rebasedPropContent) {
                             // if oldValue already be update above, we don't need to update
                             if (io_rebasePropertyChangeSet[typeid][paths[j]].oldValue !==
                                 in_ownPropertyChangeSet[typeid][paths[j]].value) {
-                                io_rebasePropertyChangeSet[typeid][paths[j]].oldValue = in_ownPropertyChangeSet[typeid][paths[j]].value;
+                                io_rebasePropertyChangeSet[typeid][paths[j]].oldValue =
+                                    in_ownPropertyChangeSet[typeid][paths[j]].value;
                             }
                         }
                     }
@@ -431,8 +438,7 @@ class ChangeSet {
             }
             // The reserved keywords have already been handled above and changes which are not present in
             // the other ChangeSet can be ignored
-            if (ChangeSet.isReservedKeyword(typeid) ||
-                !io_rebasePropertyChangeSet[typeid]) {
+            if (ChangeSet.isReservedKeyword(typeid) || !io_rebasePropertyChangeSet[typeid]) {
                 continue;
             }
             // Check, whether we have a collision in a path update
@@ -450,11 +456,15 @@ class ChangeSet {
                         // own internal ChangeSet and we want to be sure, nobody changes our internal data-structures
                         changeSet[typeid][paths[j]] = (0, fastest_json_copy_1.copy)(in_ownPropertyChangeSet[typeid][paths[j]]);
                     }
-                    // Remove the typeid, when it no longer contains any keys
-                    if ((0, isEmpty_1.default)(io_rebasePropertyChangeSet[typeid])) {
-                        delete io_rebasePropertyChangeSet[typeid];
-                    }
                 }
+                // Remove the typeid, when it no longer contains any keys
+                if ((0, isEmpty_1.default)(io_rebasePropertyChangeSet[typeid][paths[j]])) {
+                    delete io_rebasePropertyChangeSet[typeid][paths[j]];
+                }
+            }
+            // Remove the typeid, when it no longer contains any keys
+            if ((0, isEmpty_1.default)(io_rebasePropertyChangeSet[typeid])) {
+                delete io_rebasePropertyChangeSet[typeid];
             }
         }
         // If there were conflicts in the set operations, report them
@@ -489,8 +499,7 @@ class ChangeSet {
      */
     rebaseChangeSetForPropertyEntryWithTypeid(in_key, in_ownPropertyChangeSet, io_rebasePropertyChangeSet, in_typeid, in_basePath, in_removeEmpty, out_conflicts, in_options) {
         const splitTypeid = extractContext(in_typeid);
-        if (splitTypeid.context === "set" ||
-            splitTypeid.context === "map") {
+        if (splitTypeid.context === "set" || splitTypeid.context === "map") {
             this._rebaseIndexedCollectionChangeSetForProperty(in_ownPropertyChangeSet[in_key], io_rebasePropertyChangeSet[in_key], in_basePath, splitTypeid.typeid, true, // use square brackets
             out_conflicts, in_options);
             // Remove the key, when it no longer contains a changeset
@@ -646,14 +655,13 @@ class ChangeSet {
             }
             else if (splitType.context === "map" ||
                 // node property test: (we have to do the test this way, because of inheritance)
-                (nestedChangeset.insert ||
-                    nestedChangeset.modify ||
-                    nestedChangeset.remove)) {
+                nestedChangeset.insert ||
+                nestedChangeset.modify ||
+                nestedChangeset.remove) {
                 // This prevents an error, if the changeset only contains an insert operation. In that case
                 // we don't actually need the corresponding old state and thus do not need to throw an error
                 // This type of situation can occur in the materialized history, if an insert happens right at a chunk boundary.
-                if (Object.keys(nestedChangeset).length === 1 &&
-                    nestedChangeset.insert) {
+                if (Object.keys(nestedChangeset).length === 1 && nestedChangeset.insert) {
                     in_context._traversalStopped = true;
                     return;
                 }
@@ -706,7 +714,8 @@ class ChangeSet {
                                         if (!newRemove[oldTypeKeys[k]]) {
                                             newRemove[oldTypeKeys[k]] = {};
                                         }
-                                        newRemove[oldTypeKeys[k]][removedKeys[i]] = (0, fastest_json_copy_1.copy)(entry);
+                                        newRemove[oldTypeKeys[k]][removedKeys[i]] =
+                                            (0, fastest_json_copy_1.copy)(entry);
                                     }
                                 }
                             }
@@ -742,13 +751,16 @@ class ChangeSet {
         if (!(0, isObject_1.default)(in_oldSerializedState) || Array.isArray(in_oldSerializedState)) {
             if (!(0, isObject_1.default)(this._changes) || Array.isArray(this._changes)) {
                 this._changes = {
-                    oldValue: Array.isArray(in_oldSerializedState) ? in_oldSerializedState.slice() : in_oldSerializedState,
+                    oldValue: Array.isArray(in_oldSerializedState)
+                        ? in_oldSerializedState.slice()
+                        : in_oldSerializedState,
                     value: this._changes,
                 };
             }
             else {
-                this._changes.oldValue = Array.isArray(in_oldSerializedState) ? in_oldSerializedState.slice() :
-                    in_oldSerializedState;
+                this._changes.oldValue = Array.isArray(in_oldSerializedState)
+                    ? in_oldSerializedState.slice()
+                    : in_oldSerializedState;
             }
         }
         else {
@@ -825,7 +837,8 @@ class ChangeSet {
                     // TODO: Remove in_withoutRoot when it will not be used anymore
                 }
                 else if (splitType.context === "map" ||
-                    (!in_withoutRoot && splitType.context === "single")) { // For NodeProperty / inserts at the root
+                    (!in_withoutRoot && splitType.context === "single")) {
+                    // For NodeProperty / inserts at the root
                     let nestedChangeset = in_context.getNestedChangeSet();
                     if (isPrimitiveType(splitType.typeid)) {
                         if (nestedChangeset.modify) {
@@ -927,7 +940,8 @@ class ChangeSet {
                 (type === "String" && (0, isString_1.default)(nestedChangeset.oldValue))) {
                 // check if we were called with an irreversible changeset
                 if (in_context.getOperationType() === "modify" &&
-                    (!(0, isObject_1.default)(nestedChangeset) || typeof nestedChangeset.oldValue === "undefined")) {
+                    (!(0, isObject_1.default)(nestedChangeset) ||
+                        typeof nestedChangeset.oldValue === "undefined")) {
                     throw new Error(MSG.OLD_VALUE_NOT_FOUND);
                 }
                 // switch oldValue and value
@@ -935,7 +949,8 @@ class ChangeSet {
                 nestedChangeset.oldValue = nestedChangeset.value;
                 nestedChangeset.value = tmp;
             }
-            else if ((type === "String" && !(0, isString_1.default)(nestedChangeset.oldValue)) || splitType.context === "array") {
+            else if ((type === "String" && !(0, isString_1.default)(nestedChangeset.oldValue)) ||
+                splitType.context === "array") {
                 // String and Arrays need special treatment:
                 const arrayIterator = new arrayChangesetIterator_1.ArrayChangeSetIterator(nestedChangeset);
                 const resultChangeset = {};
@@ -954,14 +969,16 @@ class ChangeSet {
                         case operationTypes_1.ArrayIteratorOperationTypes.INSERT:
                             // Handle inserts
                             resultChangeset.remove.push([
-                                arrayIterator.opDescription.operation[0] + arrayIterator.opDescription.offset,
+                                arrayIterator.opDescription.operation[0] +
+                                    arrayIterator.opDescription.offset,
                                 arrayIterator.opDescription.operation[1],
                             ]);
                             break;
                         case operationTypes_1.ArrayIteratorOperationTypes.REMOVE:
                             // Handle removes
                             resultChangeset.insert.push([
-                                arrayIterator.opDescription.operation[0] + arrayIterator.opDescription.offset,
+                                arrayIterator.opDescription.operation[0] +
+                                    arrayIterator.opDescription.offset,
                                 arrayIterator.opDescription.operation[1],
                             ]);
                             break;
@@ -969,14 +986,16 @@ class ChangeSet {
                             // Handle modifies
                             if (isPrimitiveType(splitType.typeid)) {
                                 resultChangeset.modify.push([
-                                    arrayIterator.opDescription.operation[0] + arrayIterator.opDescription.offset,
+                                    arrayIterator.opDescription.operation[0] +
+                                        arrayIterator.opDescription.offset,
                                     arrayIterator.opDescription.operation[2],
                                     arrayIterator.opDescription.operation[1],
                                 ]);
                             }
                             else {
                                 resultChangeset.modify.push([
-                                    arrayIterator.opDescription.operation[0] + arrayIterator.opDescription.offset,
+                                    arrayIterator.opDescription.operation[0] +
+                                        arrayIterator.opDescription.offset,
                                     arrayIterator.opDescription.operation[1],
                                 ]);
                             }
@@ -1039,8 +1058,7 @@ class ChangeSet {
      * in a later release
      */
     toInverseChangeSet() {
-        if (this._changes.value !== undefined &&
-            this._changes.oldValue !== undefined) {
+        if (this._changes.value !== undefined && this._changes.oldValue !== undefined) {
             const tmp = this._changes.value;
             this._changes.value = this._changes.oldValue;
             this._changes.oldValue = tmp;
@@ -1056,8 +1074,10 @@ exports.ChangeSet = ChangeSet;
 ChangeSet.ConflictType = changesetConflictTypes_1.ConflictType;
 ChangeSet.isEmptyChangeSet = isEmptyChangeset_1.isEmptyChangeSet;
 ChangeSet.isReservedKeyword = isReservedKeyword_1.isReservedKeyword;
-ChangeSet.prototype._performApplyAfterOnPropertyArray = array_1.ChangeSetArrayFunctions._performApplyAfterOnPropertyArray;
-ChangeSet.prototype._rebaseArrayChangeSetForProperty = array_1.ChangeSetArrayFunctions._rebaseArrayChangeSetForProperty;
+ChangeSet.prototype._performApplyAfterOnPropertyArray =
+    array_1.ChangeSetArrayFunctions._performApplyAfterOnPropertyArray;
+ChangeSet.prototype._rebaseArrayChangeSetForProperty =
+    array_1.ChangeSetArrayFunctions._rebaseArrayChangeSetForProperty;
 ChangeSet.prototype._rebaseChangeSetForString = array_1.ChangeSetArrayFunctions._rebaseChangeSetForString;
 // Add the indexed collection functions into the prototype of the ChangeSet
 ChangeSet.prototype._performApplyAfterOnPropertyIndexedCollection =