@fluid-experimental/property-properties 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/lib/propertyFactory.js

@@ -6,44 +6,44 @@
  * @fileoverview Declaration of the PropertyFactory class.
  * Responsible for creating property sets and registering property templates
  */
-const _ = require('lodash');
-const fastestJSONCopy = require('fastest-json-copy');
+const _ = require("lodash");
+const fastestJSONCopy = require("fastest-json-copy");
 const deepCopy = fastestJSONCopy.copy;
-const { Collection, ConsoleUtils, EventEmitter, SortedCollection, constants, GuidUtils, } = require('@fluid-experimental/property-common');
+const { Collection, ConsoleUtils, EventEmitter, SortedCollection, constants, GuidUtils, } = require("@fluid-experimental/property-common");
 const { MSG } = constants;
-const { TypeIdHelper, TemplateValidator, PathHelper, ChangeSet, } = require('@fluid-experimental/property-changeset');
-const semver = require('semver');
-const async = require('async');
-const { PropertyTemplate } = require('./propertyTemplate');
-const { PropertyTemplateWrapper } = require('./propertyTemplateWrapper');
+const { TypeIdHelper, TemplateValidator, PathHelper, ChangeSet, } = require("@fluid-experimental/property-changeset");
+const semver = require("semver");
+const async = require("async");
+const { PropertyTemplate } = require("./propertyTemplate");
+const { PropertyTemplateWrapper } = require("./propertyTemplateWrapper");
 // Include the property classes
-const { BaseProperty } = require('./properties/baseProperty');
-const { NamedProperty } = require('./properties/namedProperty');
-const { NodeProperty } = require('./properties/nodeProperty');
-const { NamedNodeProperty } = require('./properties/namedNodeProperty');
-const { ContainerProperty } = require('./properties/containerProperty');
-const { ValueProperty } = require('./properties/valueProperty');
+const { BaseProperty } = require("./properties/baseProperty");
+const { NamedProperty } = require("./properties/namedProperty");
+const { NodeProperty } = require("./properties/nodeProperty");
+const { NamedNodeProperty } = require("./properties/namedNodeProperty");
+const { ContainerProperty } = require("./properties/containerProperty");
+const { ValueProperty } = require("./properties/valueProperty");
 // Include all primitive properties –- will register at the end.
-const { Uint8Property, Uint16Property, Uint32Property, } = require('./properties/uintProperties');
-const { Float32Property, Float64Property, } = require('./properties/floatProperties');
-const { Int8Property, Int16Property, Int32Property, Int64Property, Uint64Property, } = require('./properties/intProperties');
-const { StringProperty } = require('./properties/stringProperty');
-const { BoolProperty } = require('./properties/boolProperty');
-const { ReferenceProperty } = require('./properties/referenceProperty');
-const { EnumProperty } = require('./properties/enumProperty');
+const { Uint8Property, Uint16Property, Uint32Property } = require("./properties/uintProperties");
+const { Float32Property, Float64Property } = require("./properties/floatProperties");
+const { Int8Property, Int16Property, Int32Property, Int64Property, Uint64Property, } = require("./properties/intProperties");
+const { StringProperty } = require("./properties/stringProperty");
+const { BoolProperty } = require("./properties/boolProperty");
+const { ReferenceProperty } = require("./properties/referenceProperty");
+const { EnumProperty } = require("./properties/enumProperty");
 // Include collection properties
-const { ArrayProperty } = require('./properties/arrayProperty');
-const { SetProperty } = require('./properties/setProperty');
-const { MapProperty } = require('./properties/mapProperty');
-const { ValueMapProperty } = require('./properties/valueMapProperty');
-const { IndexedCollectionBaseProperty } = require('./properties/indexedCollectionBaseProperty');
-const { AbstractStaticCollectionProperty } = require('./properties/abstractStaticCollectionProperty');
-const { Float32ArrayProperty, Float64ArrayProperty, Uint32ArrayProperty, Int32ArrayProperty, Uint64ArrayProperty, Int64ArrayProperty, Uint16ArrayProperty, Int16ArrayProperty, Uint8ArrayProperty, Int8ArrayProperty, StringArrayProperty, BoolArrayProperty, } = require('./properties/valueArrayProperty');
-const { ReferenceMapProperty } = require('./properties/referenceMapProperty');
-const { ReferenceArrayProperty } = require('./properties/referenceArrayProperty');
-const { EnumArrayProperty } = require('./properties/enumArrayProperty');
-const { Float64MapProperty, Float32MapProperty, Uint32MapProperty, Uint64MapProperty, Uint16MapProperty, Uint8MapProperty, Int32MapProperty, Int64MapProperty, Int16MapProperty, Int8MapProperty, StringMapProperty, BoolMapProperty, } = require('./properties/valueMapProperty');
-const { LazyLoadedProperties } = require('./properties/lazyLoadedProperties');
+const { ArrayProperty } = require("./properties/arrayProperty");
+const { SetProperty } = require("./properties/setProperty");
+const { MapProperty } = require("./properties/mapProperty");
+const { ValueMapProperty } = require("./properties/valueMapProperty");
+const { IndexedCollectionBaseProperty } = require("./properties/indexedCollectionBaseProperty");
+const { AbstractStaticCollectionProperty, } = require("./properties/abstractStaticCollectionProperty");
+const { Float32ArrayProperty, Float64ArrayProperty, Uint32ArrayProperty, Int32ArrayProperty, Uint64ArrayProperty, Int64ArrayProperty, Uint16ArrayProperty, Int16ArrayProperty, Uint8ArrayProperty, Int8ArrayProperty, StringArrayProperty, BoolArrayProperty, } = require("./properties/valueArrayProperty");
+const { ReferenceMapProperty } = require("./properties/referenceMapProperty");
+const { ReferenceArrayProperty } = require("./properties/referenceArrayProperty");
+const { EnumArrayProperty } = require("./properties/enumArrayProperty");
+const { Float64MapProperty, Float32MapProperty, Uint32MapProperty, Uint64MapProperty, Uint16MapProperty, Uint8MapProperty, Int32MapProperty, Int64MapProperty, Int16MapProperty, Int8MapProperty, StringMapProperty, BoolMapProperty, } = require("./properties/valueMapProperty");
+const { LazyLoadedProperties } = require("./properties/lazyLoadedProperties");
 /**
  * Creates an instance of the TemplateValidator
  *
@@ -97,7 +97,9 @@ var registerLocal = function (in_template) {
             var serializedInTemplate = in_template.serializeCanonical();
             var localValidationResults = { isValid: true };
             if (this._localPrimitivePropertiesAndTemplates.has(typeid)) {
-                var localRegisteredTemplate = this._localPrimitivePropertiesAndTemplates.item(typeid).getPropertyTemplate();
+                var localRegisteredTemplate = this._localPrimitivePropertiesAndTemplates
+                    .item(typeid)
+                    .getPropertyTemplate();
                 localValidationResults = templateValidator.validate(localRegisteredTemplate.serializeCanonical(), serializedInTemplate);
             }
             if (localValidationResults.isValid) {
@@ -110,12 +112,16 @@ var registerLocal = function (in_template) {
                 }
             }
             if (!localValidationResults.isValid) {
-                throw new Error(MSG.TEMPLATE_MISMATCH + typeid +
-                    '\n  errors = ' + JSON.stringify(_extractErrorMessage(localValidationResults.errors), 0, 2));
+                throw new Error(MSG.TEMPLATE_MISMATCH +
+                    typeid +
+                    "\n  errors = " +
+                    JSON.stringify(_extractErrorMessage(localValidationResults.errors), 0, 2));
             }
             else if (!remoteValidationResults.isValid) {
-                throw new Error(MSG.REMOTE_TEMPLATE_MISMATCH + typeid +
-                    '\n  errors = ' + JSON.stringify(_extractErrorMessage(remoteValidationResults.errors), 0, 2));
+                throw new Error(MSG.REMOTE_TEMPLATE_MISMATCH +
+                    typeid +
+                    "\n  errors = " +
+                    JSON.stringify(_extractErrorMessage(remoteValidationResults.errors), 0, 2));
             }
             else if (this._localPrimitivePropertiesAndTemplates.has(typeid)) {
                 // Template is already registered. Do nothing.
@@ -130,7 +136,9 @@ var registerLocal = function (in_template) {
                 this._validateSemver(in_template, true);
                 // Semver validation passed. Add the template to the local versioned templates collection
                 if (this._localVersionedTemplates.has(typeidWithoutVersion)) {
-                    this._localVersionedTemplates.item(typeidWithoutVersion).add(version, in_template);
+                    this._localVersionedTemplates
+                        .item(typeidWithoutVersion)
+                        .add(version, in_template);
                 }
                 else {
                     var collection = _createVersionedSortedCollection();
@@ -139,12 +147,17 @@ var registerLocal = function (in_template) {
                 }
             }
             else {
-                throw new Error(MSG.FAILED_TO_REGISTER + typeid +
-                    '\n  errors = ' + JSON.stringify(_extractErrorMessage(validationResult.errors), 0, 2));
+                throw new Error(MSG.FAILED_TO_REGISTER +
+                    typeid +
+                    "\n  errors = " +
+                    JSON.stringify(_extractErrorMessage(validationResult.errors), 0, 2));
             }
         }
         else {
-            throw new Error(MSG.UNVERSIONED_TEMPLATE + ' Template with typeid = ' + typeid + ' is not versioned.');
+            throw new Error(MSG.UNVERSIONED_TEMPLATE +
+                " Template with typeid = " +
+                typeid +
+                " is not versioned.");
         }
         // Forward to the internal function
         this._registerTypeId(typeid, in_template);
@@ -293,26 +306,26 @@ class PropertyFactory {
         this._init();
     }
     /**
-    * Add a listener for a given type of event.
-    *
-    * @param {string} eventName - A string representing the type of event upon which the
-    * listener will be notified.
-    * @param {function} eventListener - The function to call when the "type" of event
-    * is emitted.
-    * @public
-    */
+     * Add a listener for a given type of event.
+     *
+     * @param {string} eventName - A string representing the type of event upon which the
+     * listener will be notified.
+     * @param {function} eventListener - The function to call when the "type" of event
+     * is emitted.
+     * @public
+     */
     addListener(eventName, eventListener) {
         this._eventEmitter.addListener(eventName, eventListener);
     }
     /**
-    * Remove a listener for a given type of event. Iff a listener was removed,
-    * an event 'removeListener' will be emitted.
-    *
-    * @param {string} eventName - A string representing the type of event on which the
-    * listener was attached.
-    * @param {function} eventListener - The function to remove from the list of functions
-    * @public
-    */
+     * Remove a listener for a given type of event. Iff a listener was removed,
+     * an event 'removeListener' will be emitted.
+     *
+     * @param {string} eventName - A string representing the type of event on which the
+     * listener was attached.
+     * @param {function} eventListener - The function to remove from the list of functions
+     * @public
+     */
     removeListener(eventName, eventListener) {
         this._eventEmitter.removeListener(eventName, eventListener);
     }
@@ -321,70 +334,66 @@ class PropertyFactory {
      */
     _init() {
         // Register all primitive properties
-        this._registerTypeId('BaseProperty', BaseProperty, 'all');
-        this._registerTypeId('NodeProperty', NodeProperty, 'all');
-        this._registerTypeId('ContainerProperty', ContainerProperty, 'all');
+        this._registerTypeId("BaseProperty", BaseProperty, "all");
+        this._registerTypeId("NodeProperty", NodeProperty, "all");
+        this._registerTypeId("ContainerProperty", ContainerProperty, "all");
         // Register the primitive types for the context single
-        this._registerTypeId('Int8', Int8Property);
-        this._registerTypeId('Uint8', Uint8Property);
-        this._registerTypeId('Int16', Int16Property);
-        this._registerTypeId('Uint16', Uint16Property);
-        this._registerTypeId('Int32', Int32Property);
-        this._registerTypeId('Int64', Int64Property);
-        this._registerTypeId('Uint64', Uint64Property);
-        this._registerTypeId('Uint32', Uint32Property);
-        this._registerTypeId('Float32', Float32Property);
-        this._registerTypeId('Float64', Float64Property);
-        this._registerTypeId('Bool', BoolProperty);
-        this._registerTypeId('String', StringProperty);
-        this._registerTypeId('Reference', ReferenceProperty);
-        this._registerTypeId('Enum', EnumProperty);
+        this._registerTypeId("Int8", Int8Property);
+        this._registerTypeId("Uint8", Uint8Property);
+        this._registerTypeId("Int16", Int16Property);
+        this._registerTypeId("Uint16", Uint16Property);
+        this._registerTypeId("Int32", Int32Property);
+        this._registerTypeId("Int64", Int64Property);
+        this._registerTypeId("Uint64", Uint64Property);
+        this._registerTypeId("Uint32", Uint32Property);
+        this._registerTypeId("Float32", Float32Property);
+        this._registerTypeId("Float64", Float64Property);
+        this._registerTypeId("Bool", BoolProperty);
+        this._registerTypeId("String", StringProperty);
+        this._registerTypeId("Reference", ReferenceProperty);
+        this._registerTypeId("Enum", EnumProperty);
         // Register the primitive types for the context array
-        this._registerTypeId('Int8', Int8ArrayProperty, 'array');
-        this._registerTypeId('Uint8', Uint8ArrayProperty, 'array');
-        this._registerTypeId('Int16', Int16ArrayProperty, 'array');
-        this._registerTypeId('Uint16', Uint16ArrayProperty, 'array');
-        this._registerTypeId('Int32', Int32ArrayProperty, 'array');
-        this._registerTypeId('Uint32', Uint32ArrayProperty, 'array');
-        this._registerTypeId('Int64', Int64ArrayProperty, 'array');
-        this._registerTypeId('Uint64', Uint64ArrayProperty, 'array');
-        this._registerTypeId('Float32', Float32ArrayProperty, 'array');
-        this._registerTypeId('Float64', Float64ArrayProperty, 'array');
-        this._registerTypeId('String', StringArrayProperty, 'array');
-        this._registerTypeId('Bool', BoolArrayProperty, 'array');
-        this._registerTypeId('Reference', ReferenceArrayProperty, 'array');
-        this._registerTypeId('Enum', EnumArrayProperty, 'array');
+        this._registerTypeId("Int8", Int8ArrayProperty, "array");
+        this._registerTypeId("Uint8", Uint8ArrayProperty, "array");
+        this._registerTypeId("Int16", Int16ArrayProperty, "array");
+        this._registerTypeId("Uint16", Uint16ArrayProperty, "array");
+        this._registerTypeId("Int32", Int32ArrayProperty, "array");
+        this._registerTypeId("Uint32", Uint32ArrayProperty, "array");
+        this._registerTypeId("Int64", Int64ArrayProperty, "array");
+        this._registerTypeId("Uint64", Uint64ArrayProperty, "array");
+        this._registerTypeId("Float32", Float32ArrayProperty, "array");
+        this._registerTypeId("Float64", Float64ArrayProperty, "array");
+        this._registerTypeId("String", StringArrayProperty, "array");
+        this._registerTypeId("Bool", BoolArrayProperty, "array");
+        this._registerTypeId("Reference", ReferenceArrayProperty, "array");
+        this._registerTypeId("Enum", EnumArrayProperty, "array");
         // Register the primitive types for the context map
-        this._registerTypeId('Int8', Int8MapProperty, 'map');
-        this._registerTypeId('Uint8', Uint8MapProperty, 'map');
-        this._registerTypeId('Int16', Int16MapProperty, 'map');
-        this._registerTypeId('Uint16', Uint16MapProperty, 'map');
-        this._registerTypeId('Int32', Int32MapProperty, 'map');
-        this._registerTypeId('Uint32', Uint32MapProperty, 'map');
-        this._registerTypeId('Int64', Int64MapProperty, 'map');
-        this._registerTypeId('Uint64', Uint64MapProperty, 'map');
-        this._registerTypeId('Float32', Float32MapProperty, 'map');
-        this._registerTypeId('Float64', Float64MapProperty, 'map');
-        this._registerTypeId('Bool', BoolMapProperty, 'map');
-        this._registerTypeId('String', StringMapProperty, 'map');
-        this._registerTypeId('Reference', ReferenceMapProperty, 'map');
+        this._registerTypeId("Int8", Int8MapProperty, "map");
+        this._registerTypeId("Uint8", Uint8MapProperty, "map");
+        this._registerTypeId("Int16", Int16MapProperty, "map");
+        this._registerTypeId("Uint16", Uint16MapProperty, "map");
+        this._registerTypeId("Int32", Int32MapProperty, "map");
+        this._registerTypeId("Uint32", Uint32MapProperty, "map");
+        this._registerTypeId("Int64", Int64MapProperty, "map");
+        this._registerTypeId("Uint64", Uint64MapProperty, "map");
+        this._registerTypeId("Float32", Float32MapProperty, "map");
+        this._registerTypeId("Float64", Float64MapProperty, "map");
+        this._registerTypeId("Bool", BoolMapProperty, "map");
+        this._registerTypeId("String", StringMapProperty, "map");
+        this._registerTypeId("Reference", ReferenceMapProperty, "map");
         // Register the default templates
         var NamedPropertyTemplate = {
-            typeid: 'NamedProperty',
-            properties: [
-                { id: 'guid', typeid: 'String' },
-            ],
+            typeid: "NamedProperty",
+            properties: [{ id: "guid", typeid: "String" }],
         };
         var NamedNodePropertyTemplate = {
-            typeid: 'NamedNodeProperty',
-            inherits: ['NodeProperty', 'NamedProperty'],
+            typeid: "NamedNodeProperty",
+            inherits: ["NodeProperty", "NamedProperty"],
         };
         var RelationshipPropertyTemplate = {
-            typeid: 'RelationshipProperty',
-            inherits: ['NodeProperty', 'NamedProperty'],
-            properties: [
-                { id: 'to', typeid: 'Reference' },
-            ],
+            typeid: "RelationshipProperty",
+            inherits: ["NodeProperty", "NamedProperty"],
+            properties: [{ id: "to", typeid: "Reference" }],
         };
         this._registerTypeId(NamedPropertyTemplate.typeid, NamedPropertyTemplate);
         this._registerTypeId(NamedNodePropertyTemplate.typeid, NamedNodePropertyTemplate);
@@ -423,21 +432,21 @@ class PropertyFactory {
             return !isInvalid;
         };
         var input_array = undefined;
-        if (PropertyTemplate.isTemplate(in_input) || typeof in_input === 'string') {
+        if (PropertyTemplate.isTemplate(in_input) || typeof in_input === "string") {
             input_array = [in_input];
         }
         else if (_.isArray(in_input)) {
             input_array = in_input;
         }
         else {
-            throw (new TypeError(MSG.ATTEMPT_TO_REGISTER_WITH_BAD_ARGUMENT));
+            throw new TypeError(MSG.ATTEMPT_TO_REGISTER_WITH_BAD_ARGUMENT);
         }
         if (!validateArray(input_array)) {
-            throw (new Error(MSG.ATTEMPT_TO_REGISTER_WITH_BAD_ARGUMENT));
+            throw new Error(MSG.ATTEMPT_TO_REGISTER_WITH_BAD_ARGUMENT);
         }
         for (var i = 0; i < input_array.length; i++) {
             var elem = input_array[i];
-            if (typeof elem === 'string') {
+            if (typeof elem === "string") {
                 if (!this._localPrimitivePropertiesAndTemplates.has(elem)) {
                     if (this.missingDependencies[elem] === undefined) {
                         this.missingDependencies[elem] = { requested: false };
@@ -519,18 +528,19 @@ class PropertyFactory {
         var validationResults;
         var warnings = [];
         if (this._localVersionedTemplates.has(typeidWithoutVersion)) {
-            var previousLocalVersion = this._localVersionedTemplates.item(typeidWithoutVersion)
+            var previousLocalVersion = this._localVersionedTemplates
+                .item(typeidWithoutVersion)
                 .getNearestPreviousItem(version);
             if (previousLocalVersion) {
-                validationResults = this._templateValidator
-                    .validate(in_template.serializeCanonical(), previousLocalVersion.serializeCanonical());
+                validationResults = this._templateValidator.validate(in_template.serializeCanonical(), previousLocalVersion.serializeCanonical());
                 warnings.push.apply(warnings, validationResults.warnings);
             }
             else {
-                var nextLocalVersion = this._localVersionedTemplates.item(typeidWithoutVersion).getNearestNextItem(version);
+                var nextLocalVersion = this._localVersionedTemplates
+                    .item(typeidWithoutVersion)
+                    .getNearestNextItem(version);
                 if (nextLocalVersion) {
-                    validationResults = this._templateValidator
-                        .validate(nextLocalVersion.serializeCanonical(), in_template.serializeCanonical());
+                    validationResults = this._templateValidator.validate(nextLocalVersion.serializeCanonical(), in_template.serializeCanonical());
                     warnings.push.apply(warnings, validationResults.warnings);
                 }
             }
@@ -539,14 +549,17 @@ class PropertyFactory {
             var that = this;
             this._remoteScopedAndVersionedTemplates.iterate(function (scope, remoteVersionedTemplates) {
                 if (remoteVersionedTemplates.has(typeidWithoutVersion)) {
-                    var previousRemoteVersion = remoteVersionedTemplates.item(typeidWithoutVersion)
+                    var previousRemoteVersion = remoteVersionedTemplates
+                        .item(typeidWithoutVersion)
                         .getNearestPreviousItem(version);
                     if (previousRemoteVersion) {
                         validationResults = that._templateValidator.validate(in_template.serializeCanonical(), previousRemoteVersion.getPropertyTemplate().serializeCanonical());
                         warnings.push.apply(warnings, validationResults.warnings);
                     }
                     else {
-                        var nextRemoteVersion = remoteVersionedTemplates.item(typeidWithoutVersion).getNearestNextItem(version);
+                        var nextRemoteVersion = remoteVersionedTemplates
+                            .item(typeidWithoutVersion)
+                            .getNearestNextItem(version);
                         if (nextRemoteVersion) {
                             validationResults = that._templateValidator.validate(nextRemoteVersion.getPropertyTemplate().serializeCanonical(), in_template.serializeCanonical());
                             warnings.push.apply(warnings, validationResults.warnings);
@@ -556,8 +569,10 @@ class PropertyFactory {
             });
         }
         if (!_.isEmpty(warnings)) {
-            console.warn('Template with typeid = ' + typeid +
-                ' is valid but with the following warnings = ' + JSON.stringify(warnings, 0, 2));
+            console.warn("Template with typeid = " +
+                typeid +
+                " is valid but with the following warnings = " +
+                JSON.stringify(warnings, 0, 2));
         }
     }
     /**
@@ -579,12 +594,16 @@ class PropertyFactory {
             // Template already exists. The incoming template MUST match what is registered.
             // If they do not match, throw an error letting the user know that the templates are incompatible.
             // This is likely due to the fact that the developer did not bump its version.
-            var registeredTemplate = this._localPrimitivePropertiesAndTemplates.item(typeid).getPropertyTemplate();
+            var registeredTemplate = this._localPrimitivePropertiesAndTemplates
+                .item(typeid)
+                .getPropertyTemplate();
             var templateValidator = _createTemplateValidator.call(this);
             var validationResults = templateValidator.validate(registeredTemplate.serializeCanonical(), in_remoteTemplate.serializeCanonical());
             if (!validationResults.isValid) {
-                throw new Error(MSG.TEMPLATE_MISMATCH + typeid +
-                    '\n  errors = ' + JSON.stringify(_extractErrorMessage(validationResults.errors), 0, 2));
+                throw new Error(MSG.TEMPLATE_MISMATCH +
+                    typeid +
+                    "\n  errors = " +
+                    JSON.stringify(_extractErrorMessage(validationResults.errors), 0, 2));
             }
         }
         else if (in_remoteTemplate._isVersioned()) {
@@ -592,8 +611,12 @@ class PropertyFactory {
             var wrappedTemplate = new PropertyTemplateWrapper(in_remoteTemplate, in_scope);
             if (this._remoteScopedAndVersionedTemplates.has(in_scope)) {
                 if (this._remoteScopedAndVersionedTemplates.item(in_scope).has(typeidWithoutVersion)) {
-                    if (!this._remoteScopedAndVersionedTemplates.item(in_scope).item(typeidWithoutVersion).has(version)) {
-                        this._remoteScopedAndVersionedTemplates.item(in_scope)
+                    if (!this._remoteScopedAndVersionedTemplates
+                        .item(in_scope)
+                        .item(typeidWithoutVersion)
+                        .has(version)) {
+                        this._remoteScopedAndVersionedTemplates
+                            .item(in_scope)
                             .item(typeidWithoutVersion)
                             .add(version, wrappedTemplate);
                     }
@@ -601,7 +624,9 @@ class PropertyFactory {
                 else {
                     var versionCollection = _createVersionedSortedCollection();
                     versionCollection.add(version, wrappedTemplate);
-                    this._remoteScopedAndVersionedTemplates.item(in_scope).add(typeidWithoutVersion, versionCollection);
+                    this._remoteScopedAndVersionedTemplates
+                        .item(in_scope)
+                        .add(typeidWithoutVersion, versionCollection);
                 }
             }
             else {
@@ -613,7 +638,7 @@ class PropertyFactory {
             }
         }
         else {
-            throw new Error(MSG.UNVERSIONED_REMOTE_TEMPLATE + ' \n' + JSON.stringify(in_remoteTemplate, 0, 2));
+            throw new Error(MSG.UNVERSIONED_REMOTE_TEMPLATE + " \n" + JSON.stringify(in_remoteTemplate, 0, 2));
         }
     }
     /**
@@ -662,19 +687,21 @@ class PropertyFactory {
         // If no context is specified we assign one
         if (!in_context) {
             // By default templates are registered for all contexts together, BaseProperties are registered separately
-            in_context = in_templateOrProperty instanceof PropertyTemplate ? 'all' : 'single';
+            in_context = in_templateOrProperty instanceof PropertyTemplate ? "all" : "single";
         }
-        if (in_context !== 'all') {
+        if (in_context !== "all") {
             if (!this._localPrimitivePropertiesAndTemplates.has(in_typeid)) {
                 this._localPrimitivePropertiesAndTemplates.add(in_typeid, new Collection());
             }
-            this._localPrimitivePropertiesAndTemplates.item(in_typeid).add(in_context, in_templateOrProperty);
+            this._localPrimitivePropertiesAndTemplates
+                .item(in_typeid)
+                .add(in_context, in_templateOrProperty);
         }
         else if (!this._localPrimitivePropertiesAndTemplates.has(in_typeid)) {
             var wrapper = new PropertyTemplateWrapper(in_templateOrProperty);
             this._localPrimitivePropertiesAndTemplates.add(in_typeid, wrapper);
         }
-        this._eventEmitter.emit('registered', in_templateOrProperty);
+        this._eventEmitter.emit("registered", in_templateOrProperty);
     }
     /**
      * Validate a template.
@@ -738,7 +765,7 @@ class PropertyFactory {
                 return typeidItem;
             }
             else {
-                var context = in_context || 'single';
+                var context = in_context || "single";
                 return this._localPrimitivePropertiesAndTemplates.item(in_typeid).item(context);
             }
         }
@@ -747,9 +774,17 @@ class PropertyFactory {
             if (splitTypeId.version) {
                 var typeidWithoutVersion = splitTypeId.typeidWithoutVersion;
                 var version = splitTypeId.version;
-                if (this._remoteScopedAndVersionedTemplates.item(in_scope).has(typeidWithoutVersion) &&
-                    this._remoteScopedAndVersionedTemplates.item(in_scope).item(typeidWithoutVersion).has(version)) {
-                    return this._remoteScopedAndVersionedTemplates.item(in_scope).item(typeidWithoutVersion).item(version);
+                if (this._remoteScopedAndVersionedTemplates
+                    .item(in_scope)
+                    .has(typeidWithoutVersion) &&
+                    this._remoteScopedAndVersionedTemplates
+                        .item(in_scope)
+                        .item(typeidWithoutVersion)
+                        .has(version)) {
+                    return this._remoteScopedAndVersionedTemplates
+                        .item(in_scope)
+                        .item(typeidWithoutVersion)
+                        .item(version);
                 }
             }
         }
@@ -762,7 +797,8 @@ class PropertyFactory {
      * @returns {property-properties.PropertyTemplate|undefined} Template identified by the typeid.
      */
     getTemplate(in_typeid) {
-        return this._localPrimitivePropertiesAndTemplates.has(in_typeid) && !TypeIdHelper.isPrimitiveType(in_typeid)
+        return this._localPrimitivePropertiesAndTemplates.has(in_typeid) &&
+            !TypeIdHelper.isPrimitiveType(in_typeid)
             ? this._localPrimitivePropertiesAndTemplates.item(in_typeid).getPropertyTemplate()
             : undefined;
     }
@@ -780,7 +816,10 @@ class PropertyFactory {
         this._remoteScopedAndVersionedTemplates.iterate(function (scope, remoteVersionedTemplates) {
             if (remoteVersionedTemplates.has(typeidWithoutVersion) &&
                 remoteVersionedTemplates.item(typeidWithoutVersion).item(version)) {
-                templatesFound.push(remoteVersionedTemplates.item(typeidWithoutVersion).item(version).getPropertyTemplate());
+                templatesFound.push(remoteVersionedTemplates
+                    .item(typeidWithoutVersion)
+                    .item(version)
+                    .getPropertyTemplate());
             }
         });
         return templatesFound;
@@ -798,7 +837,7 @@ class PropertyFactory {
      * @private
      */
     _createProperty(in_typeid, in_context, in_initialProperties, in_scope) {
-        const ifNotSingleOrUndefined = (in_context || 'single') !== 'single';
+        const ifNotSingleOrUndefined = (in_context || "single") !== "single";
         ConsoleUtils.assert(ifNotSingleOrUndefined || _.isString(in_typeid), MSG.UNKNOWN_TYPEID_SPECIFIED + in_typeid);
         let context = in_context;
         if (!context) {
@@ -824,14 +863,15 @@ class PropertyFactory {
             propertyDef = {};
             this._createDefFromPropertyDeclaration({
                 typeid: in_typeid,
-                context: context || 'single',
+                context: context || "single",
             }, in_scope, propertyDef);
         }
         let property;
         if (!this._forceInstantion) {
             // If we don't yet have a creation function, we will create one here
-            propertyCreationFunction = propertyCreationFunction ||
-                this._definePropertyCreationFunction(propertyDef, in_typeid, in_scope, context);
+            propertyCreationFunction =
+                propertyCreationFunction ||
+                    this._definePropertyCreationFunction(propertyDef, in_typeid, in_scope, context);
             // Create the property by invoking the precompiled creation function
             property = propertyCreationFunction();
             // If initial properties have been provided, we will assign them to the
@@ -866,11 +906,13 @@ class PropertyFactory {
     _instantiatePropertyDef(propertyDef, in_scope, in_initialProperties) {
         let rootProperty = undefined;
         // This stack is used to recursively iterate over the property definition
-        const creationStack = [{
+        const creationStack = [
+            {
                 id: undefined,
                 entry: propertyDef,
                 parent: undefined,
-            }];
+            },
+        ];
         while (creationStack.length > 0) {
             const currentEntry = creationStack.pop();
             // We have an entry on the stack that is just waiting for its children to finish, but has already
@@ -883,7 +925,7 @@ class PropertyFactory {
                 continue;
             }
             // Create the property instance
-            let property = new (currentEntry.entry.constructorFunction)(currentEntry.entry.entry);
+            let property = new currentEntry.entry.constructorFunction(currentEntry.entry.entry);
             // Insert / append the property to the parent
             if (currentEntry.parent) {
                 if (currentEntry.entry.optional) {
@@ -923,8 +965,7 @@ class PropertyFactory {
                         parent: property,
                         id: id,
                         entry: child,
-                        setGuid: currentEntry.entry.assignGuid && id ===
-                            'guid',
+                        setGuid: currentEntry.entry.assignGuid && id === "guid",
                     });
                 }
             }
@@ -956,11 +997,13 @@ class PropertyFactory {
      */
     _definePropertyCreationFunction(propertyDef, in_typeid, in_scope, in_context) {
         // This stack is used to recursively iterate over the property definition
-        const creationStack = [{
+        const creationStack = [
+            {
                 id: null,
                 def: propertyDef,
                 parent: undefined,
-            }];
+            },
+        ];
         let creationFunctionSource = "";
         let currentParameterIndex = 0;
         let parameters = [];
@@ -973,14 +1016,13 @@ class PropertyFactory {
             // been created
             if (currentEntry.signalChildrenFinished) {
                 // Add the signalling function
-                creationFunctionSource +=
-                    `${currentEntry.propertyVarname}._signalAllStaticMembersHaveBeenAdded(${JSON.stringify(in_scope)});\n`;
+                creationFunctionSource += `${currentEntry.propertyVarname}._signalAllStaticMembersHaveBeenAdded(${JSON.stringify(in_scope)});\n`;
                 continue;
             }
             // Determine the initial value for this property
-            let initialValue = currentEntry.def.initialValue !== undefined ?
-                currentEntry.def.initialValue :
-                undefined;
+            let initialValue = currentEntry.def.initialValue !== undefined
+                ? currentEntry.def.initialValue
+                : undefined;
             if (currentEntry.def.entry.id) {
                 let parentEntry = currentEntry.parentStackEntry;
                 let path = [currentEntry.def.entry.id];
@@ -1006,7 +1048,7 @@ class PropertyFactory {
                                 Object.assign(initialValue.value, filteredChangeSet);
                             }
                             else {
-                                throw new TypeError('Invalid default values specified');
+                                throw new TypeError("Invalid default values specified");
                             }
                         }
                         else if (filteredChangeSet !== undefined) {
@@ -1037,8 +1079,7 @@ class PropertyFactory {
                     // we use this flag to indicate that for all nested properties, we do not want to use
                     // the precompiled instantiation functions.
                     this._forceInstantion = true;
-                    instantiatedChild =
-                        this._instantiatePropertyDef(currentEntry.def, in_scope, currentEntry.def.initialValue);
+                    instantiatedChild = this._instantiatePropertyDef(currentEntry.def, in_scope, currentEntry.def.initialValue);
                 }
                 finally {
                     this._forceInstantion = false;
@@ -1060,8 +1101,7 @@ class PropertyFactory {
                 // and add the instantiation call to the generated function
                 currentPropertyNumber++;
                 currentPropertyVarName = `property${currentPropertyNumber}`;
-                creationFunctionSource +=
-                    `const ${currentPropertyVarName} =
+                creationFunctionSource += `const ${currentPropertyVarName} =
                     new parameters[${currentParameterIndex}](parameters[${currentParameterIndex + 1}]);\n`;
                 currentParameterIndex += 2;
                 // Insert / append the property to the parent
@@ -1110,7 +1150,7 @@ class PropertyFactory {
                             id: id,
                             def: child,
                             signalParent: false,
-                            setGuid: currentEntry.def.assignGuid && id === 'guid',
+                            setGuid: currentEntry.def.assignGuid && id === "guid",
                             parentStackEntry,
                         });
                     }
@@ -1120,12 +1160,12 @@ class PropertyFactory {
                     // we directly assign it here
                     if (initialValue !== undefined) {
                         creationFunctionSource += !_.isObject(initialValue.value)
-                            // We have a primitive property and thus direclty invoke the setValue function
-                            ? `${currentPropertyVarName}.setValue(${JSON.stringify(initialValue.value)})\n`
-                            // For non primitive properties, we currently use the member on the property factory,
-                            // probably we could further optimize this to directly call the correct function on the
-                            // property
-                            : `this._setInitialValue(${currentPropertyVarName},
+                            ? // We have a primitive property and thus direclty invoke the setValue function
+                                `${currentPropertyVarName}.setValue(${JSON.stringify(initialValue.value)})\n`
+                            : // For non primitive properties, we currently use the member on the property factory,
+                                // probably we could further optimize this to directly call the correct function on the
+                                // property
+                                `this._setInitialValue(${currentPropertyVarName},
                                                         ${JSON.stringify(initialValue)},
                                                         false);\n`;
                     }
@@ -1145,7 +1185,7 @@ class PropertyFactory {
         // Add the return statement at the end of the function
         creationFunctionSource += ` return ${resultVarName};`;
         // Finally, create the actual JS function with the source we compiled above
-        let creationFunction = new Function('parameters', ' GuidUtils', creationFunctionSource).bind(this, parameters, GuidUtils);
+        let creationFunction = new Function("parameters", " GuidUtils", creationFunctionSource).bind(this, parameters, GuidUtils);
         // Add the created function to the cache
         let scopesFunction = this._cachedCreationFunctions.get(in_typeid);
         if (!scopesFunction) {
@@ -1180,11 +1220,12 @@ class PropertyFactory {
         else if (valueParsed.typed) {
             property._setValues(valueParsed.value, true, true);
         }
-        else if ((property.getTypeid() !== 'ContainerProperty') || (property._getChildrenCount() > 0)) {
+        else if (property.getTypeid() !== "ContainerProperty" ||
+            property._getChildrenCount() > 0) {
             property._setValues(valueParsed.value, false, true);
         }
         else if (!valueParsed.typeid) {
-            throw new Error(MSG.FIELD_TYPEID_IS_REQUIRED + property._id + '.typeid');
+            throw new Error(MSG.FIELD_TYPEID_IS_REQUIRED + property._id + ".typeid");
         }
         else {
             property._setValues(valueParsed.value, false, true);
@@ -1220,14 +1261,12 @@ class PropertyFactory {
      */
     _getConstructorFunctionForTypeidAndID(in_context, in_typeid, in_baseConstructor, in_id, in_scope) {
         // Create a unique key for this constructor
-        let key = in_context === 'single' ?
-            in_typeid :
-            in_context + '<' + in_typeid + '>';
+        let key = in_context === "single" ? in_typeid : in_context + "<" + in_typeid + ">";
         if (in_id !== undefined) {
-            key = key + '-' + in_id;
+            key = key + "-" + in_id;
         }
         if (in_scope && !this._localPrimitivePropertiesAndTemplates.has(in_typeid)) {
-            key += '-' + in_scope;
+            key += "-" + in_scope;
         }
         // Check, whether we already have this function in the cache
         if (this._typedPropertyConstructorCache[key]) {
@@ -1241,7 +1280,9 @@ class PropertyFactory {
         var propertyConstructorFunction = class extends in_baseConstructor {
         };
         propertyConstructorFunction.prototype._typeid = in_typeid;
-        Object.defineProperty(propertyConstructorFunction, 'name', { value: in_baseConstructor.name });
+        Object.defineProperty(propertyConstructorFunction, "name", {
+            value: in_baseConstructor.name,
+        });
         if (in_id !== undefined) {
             propertyConstructorFunction.prototype._id = in_id;
         }
@@ -1267,34 +1308,34 @@ class PropertyFactory {
             typeid: in_typeid,
             id: in_id,
         };
-        if (this.inheritsFrom(in_typeid, 'NamedProperty', { scope: in_scope })) {
+        if (this.inheritsFrom(in_typeid, "NamedProperty", { scope: in_scope })) {
             // An id of NULL means that the GUID of the property is used if it is a named property
             params.id = in_id || null;
         }
         const wrapper = this._getWrapper(in_typeid, undefined, in_scope);
         const creationType = wrapper.getCreationType();
         switch (creationType) {
-            case 'Enum':
+            case "Enum":
                 params._enumDictionary = in_templateOrConstructor._enumDictionary;
                 ConstructorFunction = EnumProperty;
                 break;
-            case 'NodeProperty':
+            case "NodeProperty":
                 ConstructorFunction = NodeProperty;
-                params.typeid = params.typeid || 'NodeProperty';
+                params.typeid = params.typeid || "NodeProperty";
                 break;
-            case 'NamedProperty':
+            case "NamedProperty":
                 ConstructorFunction = NamedProperty;
-                params.typeid = params.typeid || 'NamedProperty';
+                params.typeid = params.typeid || "NamedProperty";
                 break;
             default:
                 ConstructorFunction = ContainerProperty;
-                params.typeid = params.typeid || 'ContainerProperty';
+                params.typeid = params.typeid || "ContainerProperty";
         }
-        ConstructorFunction = this._getConstructorFunctionForTypeidAndID('single', in_typeid, ConstructorFunction, in_id, in_scope);
+        ConstructorFunction = this._getConstructorFunctionForTypeidAndID("single", in_typeid, ConstructorFunction, in_id, in_scope);
         propertyDef.constructorFunction = ConstructorFunction;
         propertyDef.signal = true;
         propertyDef.entry = params;
-        propertyDef.context = 'single';
+        propertyDef.context = "single";
         propertyDef.typeid = in_typeid;
     }
     /**
@@ -1317,7 +1358,7 @@ class PropertyFactory {
      * @private
      */
     _hasCorrespondingRegisteredTypeid(in_typeid, in_scope) {
-        if (in_typeid.includes('-')) {
+        if (in_typeid.includes("-")) {
             return this._isRegisteredTypeid(in_typeid, in_scope);
         }
         var registered = this._localVersionedTemplates.has(in_typeid) ||
@@ -1353,19 +1394,20 @@ class PropertyFactory {
      */
     _computeTypeid(in_propertiesEntry, in_scope, context) {
         var typeid = in_propertiesEntry.typeid;
-        if (context === 'single') {
+        if (context === "single") {
             var valueParsed = this._parseTypedValue(in_propertiesEntry, in_scope, context);
-            if ((valueParsed.typed) && (valueParsed.typeid)) {
+            if (valueParsed.typed && valueParsed.typeid) {
                 typeid = in_propertiesEntry.typedValue.typeid;
             }
         }
         // We create a polymorphic collection (one inheriting from BaseProperty), if no typeid is specified
         // but a context is given
-        if (!typeid && context !== 'single') {
-            typeid = context !== 'set' ? 'ContainerProperty' : 'NamedProperty';
+        if (!typeid && context !== "single") {
+            typeid = context !== "set" ? "ContainerProperty" : "NamedProperty";
         }
-        if (in_propertiesEntry.typeid && TypeIdHelper.isReferenceTypeId(in_propertiesEntry.typeid)) {
-            typeid = 'Reference';
+        if (in_propertiesEntry.typeid &&
+            TypeIdHelper.isReferenceTypeId(in_propertiesEntry.typeid)) {
+            typeid = "Reference";
         }
         return typeid;
     }
@@ -1382,18 +1424,21 @@ class PropertyFactory {
      * @param {Object} out_propertyDef - The created property definition
      */
     _createDefFromPropertyDeclaration(in_propertiesEntry, in_scope, out_propertyDef) {
-        var context = in_propertiesEntry.context !== undefined ? in_propertiesEntry.context : 'single';
+        var context = in_propertiesEntry.context !== undefined ? in_propertiesEntry.context : "single";
         var typeid = this._computeTypeid(in_propertiesEntry, in_scope, context);
-        var referenceTarget = typeid === 'Reference' ?
-            TypeIdHelper.extractReferenceTargetTypeIdFromReference(in_propertiesEntry.typeid) : undefined;
+        var referenceTarget = typeid === "Reference"
+            ? TypeIdHelper.extractReferenceTargetTypeIdFromReference(in_propertiesEntry.typeid)
+            : undefined;
         if (typeid) {
             if (this._isRegisteredTypeid(typeid, in_scope) &&
-                (!referenceTarget || this._hasCorrespondingRegisteredTypeid(referenceTarget, in_scope))) {
+                (!referenceTarget ||
+                    this._hasCorrespondingRegisteredTypeid(referenceTarget, in_scope))) {
                 var templateOrConstructor = this._get(typeid, context, in_scope);
                 var isSpecializedConstructor = this._isSpecializedConstructor(typeid);
                 if (this._isNativePropertyConstructor(templateOrConstructor) &&
-                    (isSpecializedConstructor || context === 'single')) {
-                    if (TypeIdHelper.isReferenceTypeId(typeid) || in_propertiesEntry.id !== undefined) {
+                    (isSpecializedConstructor || context === "single")) {
+                    if (TypeIdHelper.isReferenceTypeId(typeid) ||
+                        in_propertiesEntry.id !== undefined) {
                         templateOrConstructor = this._getConstructorFunctionForTypeidAndID(in_propertiesEntry.context, in_propertiesEntry.typeid, templateOrConstructor, in_propertiesEntry.id, in_scope);
                     }
                     out_propertyDef.constructorFunction = templateOrConstructor;
@@ -1408,22 +1453,23 @@ class PropertyFactory {
                 else {
                     const templateWrapper = this._getWrapper(typeid, context, in_scope);
                     templateOrConstructor = templateWrapper.getCompiledTemplate(this);
-                    if (context === 'single') {
+                    if (context === "single") {
                         // If we have a template in a single context, we create it directly here
                         // Create the base object
                         this._createNonCollectionPropertyDef(typeid, in_propertiesEntry.id, templateOrConstructor, in_scope, out_propertyDef);
-                        this._parseTemplate(templateOrConstructor, in_scope, !!(templateOrConstructor.inherits), out_propertyDef);
+                        this._parseTemplate(templateOrConstructor, in_scope, !!templateOrConstructor.inherits, out_propertyDef);
                     }
                     else {
                         // If we have other contexts, we have to create the corresponding property object for that context
                         // check if a specialized collection is needed
-                        var isEnum = this.inheritsFrom(typeid, 'Enum', { scope: in_scope });
+                        var isEnum = this.inheritsFrom(typeid, "Enum", { scope: in_scope });
                         var constructorFunction;
                         switch (context) {
-                            case 'array':
+                            case "array":
                                 if (isEnum) {
                                     var enumPropertyEntry = deepCopy(in_propertiesEntry);
-                                    enumPropertyEntry._enumDictionary = templateOrConstructor._enumDictionary;
+                                    enumPropertyEntry._enumDictionary =
+                                        templateOrConstructor._enumDictionary;
                                     in_propertiesEntry = enumPropertyEntry;
                                     constructorFunction = EnumArrayProperty;
                                 }
@@ -1431,15 +1477,15 @@ class PropertyFactory {
                                     constructorFunction = ArrayProperty;
                                 }
                                 break;
-                            case 'set':
+                            case "set":
                                 // Validate that a set inherit from a NamedProperty
                                 var typeid = in_propertiesEntry.typeid;
-                                if (!this.inheritsFrom(typeid, 'NamedProperty', { scope: in_scope })) {
+                                if (!this.inheritsFrom(typeid, "NamedProperty", { scope: in_scope })) {
                                     throw new Error(MSG.SET_ONLY_NAMED_PROPS + typeid);
                                 }
                                 constructorFunction = SetProperty;
                                 break;
-                            case 'map':
+                            case "map":
                                 constructorFunction = MapProperty;
                                 break;
                             default:
@@ -1466,17 +1512,17 @@ class PropertyFactory {
                 in_propertiesEntry.properties = [];
             }
             // If this is a declaration which contains a properties list, we have to create a new container property for it
-            let copiedPropertyEntry = Object.assign({ typeid: 'ContainerProperty' }, in_propertiesEntry);
+            let copiedPropertyEntry = Object.assign({ typeid: "ContainerProperty" }, in_propertiesEntry);
             out_propertyDef.constructorFunction = ContainerProperty;
             out_propertyDef.entry = copiedPropertyEntry;
             out_propertyDef.signal = false;
             out_propertyDef.typeid = copiedPropertyEntry.typeid;
-            out_propertyDef.context = 'single';
+            out_propertyDef.context = "single";
             // And then parse the entry like a template
             this._parseTemplate(in_propertiesEntry, in_scope, false, out_propertyDef);
         }
         // If this property inherits from NamedProperty we assign a random GUID
-        if (typeid && this.inheritsFrom(typeid, 'NamedProperty', { scope: in_scope })) {
+        if (typeid && this.inheritsFrom(typeid, "NamedProperty", { scope: in_scope })) {
             out_propertyDef.assignGuid = true;
         }
     }
@@ -1490,7 +1536,7 @@ class PropertyFactory {
     _isNativePropertyConstructor(in_obj) {
         // TODO: This tests seems dangerous. I think it is based on the assumption that constructor is not
         //       overwritten in the derived classes (which it probably should be)
-        return (in_obj.constructor && in_obj.constructor === ContainerProperty.constructor);
+        return in_obj.constructor && in_obj.constructor === ContainerProperty.constructor;
     }
     /**
      * Checks whether the property has a typedValue and replaces the value and the typeid
@@ -1509,19 +1555,21 @@ class PropertyFactory {
             typeid: in_property.typeid,
         };
         if (in_property.typedValue) {
-            var typeid = in_property.typeid || 'ContainerProperty';
+            var typeid = in_property.typeid || "ContainerProperty";
             // Setting typedValue to a primitive is not supported
             if (TypeIdHelper.isPrimitiveType(typeid)) {
                 throw new Error(MSG.TYPED_VALUES_FOR_PRIMITIVES_NOT_SUPPORTED + in_property.id);
             }
             res.typed = true;
-            if (in_context === 'single') {
+            if (in_context === "single") {
                 if (!in_property.typedValue.typeid) {
-                    throw new Error(MSG.FIELD_TYPEID_IS_REQUIRED + 'typedValue ' + typeid);
+                    throw new Error(MSG.FIELD_TYPEID_IS_REQUIRED + "typedValue " + typeid);
                 }
                 if (!this.inheritsFrom(in_property.typedValue.typeid, typeid, { scope: in_scope })) {
                     throw new Error(MSG.TYPED_VALUES_MUST_DERIVE_FROM_BASE_TYPE +
-                        in_property.typedValue.typeid + ' must be a subclass of ' + typeid);
+                        in_property.typedValue.typeid +
+                        " must be a subclass of " +
+                        typeid);
                 }
                 res.value = in_property.typedValue.value;
                 res.typeid = in_property.typedValue.typeid;
@@ -1544,13 +1592,13 @@ class PropertyFactory {
      */
     _parseTemplate(in_template, in_scope, in_allowChildMerges, propertyDef) {
         // Check if there are nested property arrays
-        if (!(in_template.inherits && in_template.inherits.indexOf('Enum') !== -1)) {
+        if (!(in_template.inherits && in_template.inherits.indexOf("Enum") !== -1)) {
             if (in_template.properties) {
                 const properties = in_template.properties;
                 for (let i = 0; i < properties.length; i++) {
                     const id = properties[i].id;
-                    const typeid = properties[i].typeid || 'ContainerProperty';
-                    const context = properties[i].context || 'single';
+                    const typeid = properties[i].typeid || "ContainerProperty";
+                    const context = properties[i].context || "single";
                     const optional = properties[i].optional || false;
                     const valueParsed = this._parseTypedValue(properties[i], in_scope, context);
                     if (optional) {
@@ -1581,7 +1629,7 @@ class PropertyFactory {
             if (in_template.constants) {
                 const constants = in_template.constants;
                 for (let i = 0; i < constants.length; i++) {
-                    const context = constants[i].context || 'single';
+                    const context = constants[i].context || "single";
                     const valueParsed = this._parseTypedValue(constants[i], in_scope, context);
                     const newChildEntry = {
                         initialValue: undefined,
@@ -1662,9 +1710,9 @@ class PropertyFactory {
         in_options = in_options || {};
         // We just forward the request to the internal function
         var parents = {};
-        var scope = in_options.workspace ?
-            in_options.workspace.getRoot()._getCheckedOutRepositoryInfo().getScope() :
-            in_options.scope;
+        var scope = in_options.workspace
+            ? in_options.workspace.getRoot()._getCheckedOutRepositoryInfo().getScope()
+            : in_options.scope;
         this._getAllParentsForTemplateInternal(in_typeid, parents, !!in_options.includeBaseProperty, scope);
         return _.keys(parents);
     }
@@ -1681,8 +1729,8 @@ class PropertyFactory {
         if (TypeIdHelper.isPrimitiveType(in_typeid)) {
             // Everything inherits from BaseProperty.
             if (in_includeBaseProperty) {
-                out_parents['AbstractStaticCollectionProperty'] = true;
-                out_parents['BaseProperty'] = true;
+                out_parents["AbstractStaticCollectionProperty"] = true;
+                out_parents["BaseProperty"] = true;
             }
             return;
         }
@@ -1692,8 +1740,8 @@ class PropertyFactory {
         }
         // Everything inherits from BaseProperty.
         if (in_includeBaseProperty) {
-            out_parents['AbstractStaticCollectionProperty'] = true;
-            out_parents['BaseProperty'] = true;
+            out_parents["AbstractStaticCollectionProperty"] = true;
+            out_parents["BaseProperty"] = true;
         }
         // Run over all parents and insert them into the parents array
         if (template.inherits) {
@@ -1758,26 +1806,29 @@ class PropertyFactory {
         registerLocal.call(this, in_template);
     }
     /**
-    * Initializes the schema store.
-    * @public
-    * @param {Object} in_options - the store settings.
-    * @param {getBearerTokenFn} in_options.getBearerToken - Function that accepts a callback.
-    * Function that should be called with an error or the OAuth2 bearer token representing the user.
-    * @param {string} in_options.url - The root of the url used in the request to retrieve PropertySet schemas.
-    *
-    * @returns {Promise} Return an empty promise when checkout resolve or reject with error.
-    */
+     * Initializes the schema store.
+     * @public
+     * @param {Object} in_options - the store settings.
+     * @param {getBearerTokenFn} in_options.getBearerToken - Function that accepts a callback.
+     * Function that should be called with an error or the OAuth2 bearer token representing the user.
+     * @param {string} in_options.url - The root of the url used in the request to retrieve PropertySet schemas.
+     *
+     * @returns {Promise} Return an empty promise when checkout resolve or reject with error.
+     */
     async initializeSchemaStore(in_options) {
         // https://regex101.com/r/TlgGJp/2
         var regexBaseUrl = /^(https?:)?\/\/((.[-a-zA-Z0-9@:%_+~#=.]{2,256}){1,2}\.[a-z]{2,6}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(:\d{1,5})?(\/[-a-zA-Z0-9@:%_+.~#?&/=]*)*$/;
-        if (!in_options || !in_options.getBearerToken || !_.isFunction(in_options.getBearerToken) || !in_options.url) {
+        if (!in_options ||
+            !in_options.getBearerToken ||
+            !_.isFunction(in_options.getBearerToken) ||
+            !in_options.url) {
             return Promise.reject(new Error(MSG.MISSING_FSS_INIT_OPTIONS));
         }
         if (!regexBaseUrl.test(in_options.url)) {
             return Promise.reject(new Error(MSG.FSS_BASEURL_WRONG));
         }
-        if (in_options.url.slice(-1) !== '/') {
-            in_options.url = in_options.url + '/';
+        if (in_options.url.slice(-1) !== "/") {
+            in_options.url = in_options.url + "/";
         }
         this._templateStore = new ForgeSchemaStore(in_options);
         return Promise.resolve();
@@ -1793,9 +1844,12 @@ class PropertyFactory {
     _retrieveTemplateRequestWorker(in_task, in_callback) {
         var store = in_task.context;
         if (store) {
-            store.retrieveTemplate(in_task.typeid).then(function (response) {
+            store
+                .retrieveTemplate(in_task.typeid)
+                .then(function (response) {
                 in_callback(response);
-            }).catch(function (error) {
+            })
+                .catch(function (error) {
                 in_callback({ error: error });
             });
         }
@@ -1834,7 +1888,8 @@ class PropertyFactory {
         var that = this;
         // 0. Inspect locally registered templates for unknown dependencies
         this._localPrimitivePropertiesAndTemplates.iterate(function (key, type) {
-            if (!that._isSpecializedConstructor(key) && PropertyTemplate.isTemplate(type.getPropertyTemplate())) {
+            if (!that._isSpecializedConstructor(key) &&
+                PropertyTemplate.isTemplate(type.getPropertyTemplate())) {
                 var unknownDeps = _extractUnknownDependencies.call(that, type.getPropertyTemplate());
                 for (var d = 0; d < unknownDeps.length; d++) {
                     var dep = unknownDeps[d];
@@ -1864,7 +1919,7 @@ class PropertyFactory {
             }
             else {
                 that.templateRequestsQueue.drain = function () {
-                    var errors = _.compact(_.pluck(that.templateRequestsResults.errors, 'typeid'));
+                    var errors = _.compact(_.pluck(that.templateRequestsResults.errors, "typeid"));
                     var results = that.templateRequestsResults;
                     var resultsKeys = Object.keys(that.templateRequestsResults.schemas);
                     var tempMissingDependencies = [];
@@ -1877,14 +1932,15 @@ class PropertyFactory {
                             if (compiledTemplate.constants) {
                                 for (var s = 0; s < compiledTemplate.constants.length; s++) {
                                     tempConstant = compiledTemplate.constants[s];
-                                    if (tempConstant.contextKeyType === 'typeid' &&
-                                        tempConstant.context === 'map' &&
+                                    if (tempConstant.contextKeyType === "typeid" &&
+                                        tempConstant.context === "map" &&
                                         tempConstant.value) {
                                         var valueKeys = Object.keys(tempConstant.value);
                                         for (var z = 0; z < valueKeys.length; z++) {
                                             if (TypeIdHelper.isTemplateTypeid(valueKeys[z]) &&
-                                                !(valueKeys[z] in that.templateRequestsResults.schemas) &&
-                                                !(tempMissingDependencies.includes(valueKeys[z]))) {
+                                                !(valueKeys[z] in
+                                                    that.templateRequestsResults.schemas) &&
+                                                !tempMissingDependencies.includes(valueKeys[z])) {
                                                 tempMissingDependencies.push(valueKeys[z]);
                                             }
                                         }
@@ -1901,7 +1957,8 @@ class PropertyFactory {
                                 if (that.templateRequestsResults.errors[missingTypeid] === undefined) {
                                     that.templateRequestsResults.errors[missingTypeid] = {};
                                 }
-                                if (that.templateRequestsResults.schemas[missingTypeid] === undefined) {
+                                if (that.templateRequestsResults.schemas[missingTypeid] ===
+                                    undefined) {
                                     that.templateRequestsResults.schemas[missingTypeid] = {};
                                 }
                             }
@@ -1911,7 +1968,7 @@ class PropertyFactory {
                     if (that.templateRequestsQueue.length() === 0) {
                         that.templateRequestsResults = { errors: {}, schemas: {} };
                         if (errors.length && errors.length > 0) {
-                            reject(new Error('Some errors occured'));
+                            reject(new Error("Some errors occured"));
                         }
                         else {
                             that.missingDependencies = {};