@esri/solution-common 1.1.2 → 1.2.0

package/dist/esm/featureServiceHelpers.js

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { __assign } from "tslib";
 /**
  * Provides general helper functions.
  *
@@ -24,6 +23,7 @@ export { queryFeatures as rest_queryFeatures, addFeatures as rest_addFeatures }
 import { checkUrlPathTermination, deleteProp, fail, getProp, setCreateProp, setProp } from "./generalHelpers";
 import { replaceInTemplate, templatizeTerm, templatizeIds } from "./templatization";
 import { getFinalServiceUpdates, addToServiceDefinition, getLayerUpdates, getRequest, rest_request } from "./restHelpers";
+import { isTrackingViewTemplate, templatizeTracker } from "./trackingHelpers";
 //#endregion ------------------------------------------------------------------------------------------------------------//
 //#region Public functions ----------------------------------------------------------------------------------------------//
 /**
@@ -39,29 +39,36 @@ import { getFinalServiceUpdates, addToServiceDefinition, getLayerUpdates, getReq
 export function templatize(itemTemplate, dependencies, templatizeFieldReferences, templateDictionary) {
     templateDictionary = templateDictionary || {};
     // Common templatizations
-    var id = itemTemplate.item.id;
-    var fsUrl = itemTemplate.item.url;
-    itemTemplate.item = __assign(__assign({}, itemTemplate.item), { id: templatizeTerm(id, id, ".itemId"), url: _templatize(id, "url"), typeKeywords: templatizeIds(itemTemplate.item.typeKeywords) });
-    var jsonLayers = itemTemplate.properties.layers || [];
-    var jsonTables = itemTemplate.properties.tables || [];
-    var jsonItems = jsonLayers.concat(jsonTables);
-    var data = itemTemplate.data || {};
-    var layers = data.layers || [];
-    var tables = data.tables || [];
-    var _items = layers.concat(tables);
+    const id = itemTemplate.item.id;
+    const fsUrl = itemTemplate.item.url;
+    itemTemplate.item = {
+        ...itemTemplate.item,
+        id: templatizeTerm(id, id, ".itemId"),
+        url: _templatize(id, "url"),
+        typeKeywords: templatizeIds(itemTemplate.item.typeKeywords)
+    };
+    // special handeling if we are dealing with a tracker view
+    templatizeTracker(itemTemplate);
+    const jsonLayers = itemTemplate.properties.layers || [];
+    const jsonTables = itemTemplate.properties.tables || [];
+    const jsonItems = jsonLayers.concat(jsonTables);
+    const data = itemTemplate.data || {};
+    const layers = data.layers || [];
+    const tables = data.tables || [];
+    const _items = layers.concat(tables);
     // Set up symbols for the URL of the feature service and its layers and tables
     templateDictionary[fsUrl] = itemTemplate.item.url; // map FS URL to its templatized form
-    jsonItems.concat(_items).forEach(function (layer) {
+    jsonItems.concat(_items).forEach(layer => {
         templateDictionary[fsUrl + "/" + layer.id] = _templatize(id, "layer" + layer.id + ".url");
     });
     // templatize the service references serviceItemId
     itemTemplate.properties.service.serviceItemId = templatizeTerm(itemTemplate.properties.service.serviceItemId, itemTemplate.properties.service.serviceItemId, ".itemId");
-    var initialExtent = getProp(itemTemplate, "properties.service.initialExtent");
+    const initialExtent = getProp(itemTemplate, "properties.service.initialExtent");
     /* istanbul ignore else */
     if (initialExtent) {
         itemTemplate.properties.service.initialExtent = templatizeTerm(id, id, ".solutionExtent");
     }
-    var fullExtent = getProp(itemTemplate, "properties.service.fullExtent");
+    const fullExtent = getProp(itemTemplate, "properties.service.fullExtent");
     /* istanbul ignore else */
     if (fullExtent) {
         itemTemplate.properties.service.fullExtent = templatizeTerm(id, id, ".solutionExtent");
@@ -77,14 +84,14 @@ export function templatize(itemTemplate, dependencies, templatizeFieldReferences
     }
     // if any layer hasZ enabled then we need to set
     // enableZDefaults and zDefault to deploy to enterprise
-    var hasZ = false;
-    jsonItems.forEach(function (jsonItem) {
+    let hasZ = false;
+    jsonItems.forEach((jsonItem) => {
         // get the source service json for the given data item
-        var matchingItems = _items.filter(function (item) {
+        const matchingItems = _items.filter(item => {
             return jsonItem.id === item.id;
         });
         // templatize the source service json
-        var _item = matchingItems.length === 1 ? matchingItems[0] : undefined;
+        const _item = matchingItems.length === 1 ? matchingItems[0] : undefined;
         _templatizeLayer(_item, jsonItem, itemTemplate, dependencies, templatizeFieldReferences, templateDictionary);
         hasZ = jsonItem.hasZ || (_item && _item.hasZ) ? true : hasZ;
     });
@@ -100,8 +107,8 @@ export function templatize(itemTemplate, dependencies, templatizeFieldReferences
  * @param layer The data layer instance with field name references within
  */
 export function deleteViewProps(layer) {
-    var props = ["definitionQuery"];
-    props.forEach(function (prop) {
+    const props = ["definitionQuery"];
+    props.forEach(prop => {
         deleteProp(layer, prop);
     });
 }
@@ -129,7 +136,7 @@ export function cacheFieldInfos(layer, fieldInfos, isPortal) {
     // cache each of these properties as they each can contain field references
     // and will have associated updateDefinition calls when deploying to portal
     // as well as online for relationships...as relationships added with addToDef will cause failure
-    var props = {
+    const props = {
         editFieldsInfo: isPortal,
         types: isPortal,
         templates: isPortal,
@@ -138,7 +145,7 @@ export function cacheFieldInfos(layer, fieldInfos, isPortal) {
         timeInfo: isPortal,
         viewDefinitionQuery: isPortal
     };
-    Object.keys(props).forEach(function (k) {
+    Object.keys(props).forEach(k => {
         _cacheFieldInfo(layer, k, fieldInfos, props[k]);
     });
     return fieldInfos;
@@ -174,7 +181,7 @@ export function _cacheFieldInfo(layer, prop, fieldInfos, removeProp) {
  */
 export function cachePopupInfos(data) {
     // store any popupInfo so we can update after any potential name changes
-    var popupInfos = {
+    const popupInfos = {
         layers: {},
         tables: {}
     };
@@ -195,7 +202,7 @@ export function cachePopupInfos(data) {
  * @param _items list or either layers or tables
  */
 export function _cachePopupInfo(popupInfos, type, _items) {
-    _items.forEach(function (item) {
+    _items.forEach((item) => {
         if (item && item.hasOwnProperty("popupInfo")) {
             popupInfos[type][item.id] = item.popupInfo;
             item.popupInfo = {};
@@ -235,10 +242,10 @@ export function updateTemplate(itemTemplate, templateDictionary, createResponse)
  */
 export function _updateTypeKeywords(itemTemplate, createResponse) {
     // https://github.com/Esri/solution.js/issues/589
-    var iKwords = getProp(itemTemplate, "item.typeKeywords");
-    var cKwords = getProp(createResponse, "typeKeywords");
+    const iKwords = getProp(itemTemplate, "item.typeKeywords");
+    const cKwords = getProp(createResponse, "typeKeywords");
     if (iKwords && cKwords) {
-        setProp(itemTemplate, "item.typeKeywords", iKwords.concat(cKwords.filter(function (k) { return iKwords.indexOf(k) < 0; })));
+        setProp(itemTemplate, "item.typeKeywords", iKwords.concat(cKwords.filter(k => iKwords.indexOf(k) < 0)));
     }
     return itemTemplate;
 }
@@ -253,21 +260,21 @@ export function _updateTypeKeywords(itemTemplate, createResponse) {
  * @return The settings object that will be used to de-templatize the field references.
  */
 export function getLayerSettings(layerInfos, url, itemId, enterpriseIDMapping) {
-    var settings = {};
-    var ids = Object.keys(layerInfos);
-    ids.forEach(function (id) {
-        var _layerId = getProp(layerInfos[id], "item.id");
-        var isNum = parseInt(_layerId, 10) > -1;
-        var layerId = isNum && enterpriseIDMapping
+    const settings = {};
+    const ids = Object.keys(layerInfos);
+    ids.forEach((id) => {
+        const _layerId = getProp(layerInfos[id], "item.id");
+        const isNum = parseInt(_layerId, 10) > -1;
+        const layerId = isNum && enterpriseIDMapping
             ? enterpriseIDMapping[_layerId]
             : isNum
                 ? _layerId
                 : id;
-        settings["layer" + (isNum ? _layerId : id)] = {
+        settings[`layer${isNum ? _layerId : id}`] = {
             fields: _getNameMapping(layerInfos, id),
             url: checkUrlPathTermination(url) + layerId,
-            layerId: layerId,
-            itemId: itemId
+            layerId,
+            itemId
         };
         deleteProp(layerInfos[id], "newFields");
         deleteProp(layerInfos[id], "sourceFields");
@@ -285,24 +292,28 @@ export function getLayerSettings(layerInfos, url, itemId, enterpriseIDMapping) {
  * @return An updated collection of AGO templates with unique feature service names.
  */
 export function setNamesAndTitles(templates, solutionItemId) {
-    var names = [];
-    return templates.map(function (t) {
+    const names = [];
+    return templates.map(t => {
+        /* istanbul ignore else */
         if (t.item.type === "Feature Service") {
             // Retain the existing title but swap with name if it's missing
             t.item.title = t.item.title || t.item.name;
-            // Need to set the service name: name + "_" + newItemId
-            var baseName = t.item.name || t.item.title;
-            // If the name already contains a GUID remove it
-            baseName = baseName.replace(/_[0-9A-F]{32}/gi, "");
-            // The name length limit is 98
-            // Limit the baseName to 50 characters before the _<guid>
-            var name_1 = baseName.substring(0, 50) + "_" + solutionItemId;
-            // If the name + GUID already exists then append "_occurrenceCount"
-            t.item.name =
-                names.indexOf(name_1) === -1
-                    ? name_1
-                    : name_1 + "_" + names.filter(function (n) { return n === name_1; }).length;
-            names.push(name_1);
+            /* istanbul ignore else */
+            if (!isTrackingViewTemplate(t)) {
+                // Need to set the service name: name + "_" + newItemId
+                let baseName = t.item.name || t.item.title;
+                // If the name already contains a GUID remove it
+                baseName = baseName.replace(/_[0-9A-F]{32}/gi, "");
+                // The name length limit is 98
+                // Limit the baseName to 50 characters before the _<guid>
+                const name = baseName.substring(0, 50) + "_" + solutionItemId;
+                // If the name + GUID already exists then append "_occurrenceCount"
+                t.item.name =
+                    names.indexOf(name) === -1
+                        ? name
+                        : `${name}_${names.filter(n => n === name).length}`;
+                names.push(name);
+            }
         }
         return t;
     });
@@ -317,22 +328,23 @@ export function setNamesAndTitles(templates, solutionItemId) {
  * @param settings The settings object used to de-templatize the various templates within the item.
  */
 export function updateSettingsFieldInfos(itemTemplate, settings) {
-    var dependencies = itemTemplate.dependencies;
-    var id = itemTemplate.itemId;
-    var settingsKeys = Object.keys(settings);
-    settingsKeys.forEach(function (k) {
+    const dependencies = itemTemplate.dependencies;
+    const id = itemTemplate.itemId;
+    const settingsKeys = Object.keys(settings);
+    settingsKeys.forEach((k) => {
         if (id === settings[k].itemId) {
-            dependencies.forEach(function (d) {
-                settingsKeys.forEach(function (_k) {
+            dependencies.forEach((d) => {
+                settingsKeys.forEach((_k) => {
                     /* istanbul ignore else */
                     if (d === _k) {
                         // combine for multi-source views
-                        var fieldInfos = {};
+                        const fieldInfos = {};
                         fieldInfos[d] = getProp(settings[_k], "fieldInfos");
                         settings[k]["sourceServiceFields"] = settings[k]["sourceServiceFields"]
-                            ? __assign(__assign({}, settings[k]["sourceServiceFields"]), fieldInfos) : fieldInfos;
-                        var layerKeys = Object.keys(settings[_k]);
-                        layerKeys.forEach(function (layerKey) {
+                            ? { ...settings[k]["sourceServiceFields"], ...fieldInfos }
+                            : fieldInfos;
+                        const layerKeys = Object.keys(settings[_k]);
+                        layerKeys.forEach(layerKey => {
                             /* istanbul ignore else */
                             if (layerKey.startsWith("layer")) {
                                 settings[k][layerKey] = settings[_k][layerKey];
@@ -354,17 +366,17 @@ export function updateSettingsFieldInfos(itemTemplate, settings) {
  * @protected
  */
 export function updateTemplateForInvalidDesignations(template, authentication) {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         template.properties.hasInvalidDesignations = true;
         if (template.item.url) {
             // get the admin URL
-            var url_1 = template.item.url;
-            rest_request(url_1 + "?f=json", {
+            const url = template.item.url;
+            rest_request(url + "?f=json", {
                 authentication: authentication
-            }).then(function (serviceData) {
-                var layerInfos = {};
-                var layersAndTables = (serviceData.layers || []).concat(serviceData.tables || []);
-                layersAndTables.forEach(function (l) {
+            }).then(serviceData => {
+                const layerInfos = {};
+                const layersAndTables = (serviceData.layers || []).concat(serviceData.tables || []);
+                layersAndTables.forEach((l) => {
                     /* istanbul ignore else */
                     if (l && l.hasOwnProperty("id")) {
                         layerInfos[l.id] = l;
@@ -372,9 +384,9 @@ export function updateTemplateForInvalidDesignations(template, authentication) {
                 });
                 template.data[template.itemId] = Object.assign({
                     itemId: template.itemId
-                }, getLayerSettings(layerInfos, url_1, template.itemId));
+                }, getLayerSettings(layerInfos, url, template.itemId));
                 resolve(template);
-            }, function (e) { return reject(fail(e)); });
+            }, e => reject(fail(e)));
         }
         else {
             resolve(template);
@@ -391,8 +403,8 @@ export function updateTemplateForInvalidDesignations(template, authentication) {
  * @return An object that contains updated instances of popupInfos, fieldInfos, and adminLayerInfos
  */
 export function deTemplatizeFieldInfos(fieldInfos, popupInfos, adminLayerInfos, settings) {
-    var fieldInfoKeys = Object.keys(fieldInfos);
-    fieldInfoKeys.forEach(function (id) {
+    const fieldInfoKeys = Object.keys(fieldInfos);
+    fieldInfoKeys.forEach(id => {
         if (fieldInfos[id].hasOwnProperty("templates")) {
             fieldInfos[id].templates = JSON.parse(replaceInTemplate(JSON.stringify(fieldInfos[id].templates), settings));
         }
@@ -421,8 +433,8 @@ export function deTemplatizeFieldInfos(fieldInfos, popupInfos, adminLayerInfos,
  * @return array of layers and tables
  */
 export function getLayersAndTables(itemTemplate) {
-    var properties = itemTemplate.properties;
-    var layersAndTables = [];
+    const properties = itemTemplate.properties;
+    const layersAndTables = [];
     (properties.layers || []).forEach(function (layer) {
         layersAndTables.push({
             item: layer,
@@ -450,14 +462,14 @@ export function getLayersAndTables(itemTemplate) {
  */
 export function getExistingLayersAndTables(url, ids, authentication) {
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    return new Promise(function (resolve) {
-        var defs = ids.map(function (id) {
+    return new Promise(resolve => {
+        const defs = ids.map(id => {
             return rest_request(checkUrlPathTermination(url) + id, {
-                authentication: authentication
+                authentication
             });
         });
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        Promise.all(defs.map(function (p) { return p.catch(function (e) { return e; }); })).then(resolve);
+        Promise.all(defs.map(p => p.catch(e => e))).then(resolve);
     });
 }
 /**
@@ -472,44 +484,49 @@ export function getExistingLayersAndTables(url, ids, authentication) {
  * @protected
  */
 export function addFeatureServiceLayersAndTables(itemTemplate, templateDictionary, popupInfos, authentication) {
-    return new Promise(function (resolve, reject) {
-        // Create a hash of various properties that contain field references
-        var fieldInfos = {};
-        var adminLayerInfos = {};
-        // Add the service's layers and tables to it
-        var layersAndTables = getLayersAndTables(itemTemplate);
-        if (layersAndTables.length > 0) {
-            addFeatureServiceDefinition(itemTemplate.item.url || "", layersAndTables, templateDictionary, authentication, itemTemplate.key, adminLayerInfos, fieldInfos, itemTemplate).then(function () {
-                // Detemplatize field references and update the layer properties
-                // Only failure path is handled by addFeatureServiceDefinition
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary).then(function (r) {
-                    // Update relationships and layer definitions
-                    var updates = getLayerUpdates({
-                        message: "updated layer definition",
-                        objects: r.layerInfos.fieldInfos,
-                        itemTemplate: r.itemTemplate,
-                        authentication: authentication
-                    }, templateDictionary.isPortal);
-                    // Get any updates for the service that should be performed after updates to the layers
-                    if (templateDictionary.isPortal) {
-                        updates = getFinalServiceUpdates(r.itemTemplate, authentication, updates);
-                    }
-                    // Process the updates sequentially
-                    updates
-                        .reduce(function (prev, update) {
-                        return prev.then(function () {
-                            return getRequest(update);
-                        });
-                    }, Promise.resolve(null))
-                        .then(function () { return resolve(null); }, function (e) { return reject(fail(e)); } // getRequest
-                    );
-                });
-            }, function (e) { return reject(fail(e)); } // addFeatureServiceDefinition
-            );
+    return new Promise((resolve, reject) => {
+        if (isTrackingViewTemplate(itemTemplate)) {
+            resolve(null);
         }
         else {
-            resolve(null);
+            // Create a hash of various properties that contain field references
+            const fieldInfos = {};
+            const adminLayerInfos = {};
+            // Add the service's layers and tables to it
+            const layersAndTables = getLayersAndTables(itemTemplate);
+            if (layersAndTables.length > 0) {
+                addFeatureServiceDefinition(itemTemplate.item.url || "", layersAndTables, templateDictionary, authentication, itemTemplate.key, adminLayerInfos, fieldInfos, itemTemplate).then(() => {
+                    // Detemplatize field references and update the layer properties
+                    // Only failure path is handled by addFeatureServiceDefinition
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary).then(r => {
+                        // Update relationships and layer definitions
+                        let updates = getLayerUpdates({
+                            message: "updated layer definition",
+                            objects: r.layerInfos.fieldInfos,
+                            itemTemplate: r.itemTemplate,
+                            authentication
+                        }, templateDictionary.isPortal);
+                        // Get any updates for the service that should be performed after updates to the layers
+                        if (templateDictionary.isPortal) {
+                            updates = getFinalServiceUpdates(r.itemTemplate, authentication, updates);
+                        }
+                        // Process the updates sequentially
+                        updates
+                            .reduce((prev, update) => {
+                            return prev.then(() => {
+                                return getRequest(update);
+                            });
+                        }, Promise.resolve(null))
+                            .then(() => resolve(null), (e) => reject(fail(e)) // getRequest
+                        );
+                    });
+                }, e => reject(fail(e)) // addFeatureServiceDefinition
+                );
+            }
+            else {
+                resolve(null);
+            }
         }
     });
 }
@@ -529,83 +546,95 @@ export function addFeatureServiceLayersAndTables(itemTemplate, templateDictionar
  * @protected
  */
 export function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDictionary, authentication, key, adminLayerInfos, fieldInfos, itemTemplate) {
-    return new Promise(function (resolve, reject) {
-        var options = {
-            layers: [],
-            tables: [],
-            authentication: authentication
-        };
-        // if the service has veiws keep track of the fields so we can use them to
-        // compare with the view fields
-        /* istanbul ignore else */
-        if (getProp(itemTemplate, "properties.service.hasViews")) {
-            _updateTemplateDictionaryFields(itemTemplate, templateDictionary);
+    return new Promise((resolve, reject) => {
+        if (isTrackingViewTemplate(itemTemplate)) {
+            resolve(null);
         }
-        var layerChunks = [];
-        listToAdd.forEach(function (toAdd, i) {
-            var item = toAdd.item;
-            var originalId = item.id;
-            fieldInfos = cacheFieldInfos(item, fieldInfos, templateDictionary.isPortal);
+        else {
+            let options = {
+                layers: [],
+                tables: [],
+                authentication
+            };
+            // if the service has veiws keep track of the fields so we can use them to
+            // compare with the view fields
             /* istanbul ignore else */
-            if (item.isView) {
-                deleteViewProps(item);
+            if (getProp(itemTemplate, "properties.service.hasViews")) {
+                _updateTemplateDictionaryFields(itemTemplate, templateDictionary);
             }
-            // when the item is a view we need to grab the supporting fieldInfos
-            /* istanbul ignore else */
-            if (itemTemplate.properties.service.isView) {
-                _updateGeomFieldName(item.adminLayerInfo, templateDictionary);
-                adminLayerInfos[originalId] = item.adminLayerInfo;
-                // need to update adminLayerInfo before adding to the service def
-                // bring over the fieldInfos from the source layer
-                updateSettingsFieldInfos(itemTemplate, templateDictionary);
-                // update adminLayerInfo before add to definition with view source fieldInfo settings
-                item.adminLayerInfo = replaceInTemplate(item.adminLayerInfo, templateDictionary);
+            const chunkSize = _getLayerChunkSize();
+            const layerChunks = [];
+            listToAdd.forEach((toAdd, i) => {
+                let item = toAdd.item;
+                const originalId = item.id;
+                fieldInfos = cacheFieldInfos(item, fieldInfos, templateDictionary.isPortal);
                 /* istanbul ignore else */
-                if (!templateDictionary.isPortal &&
-                    fieldInfos &&
-                    fieldInfos.hasOwnProperty(item.id)) {
-                    Object.keys(templateDictionary).some(function (k) {
-                        if (templateDictionary[k].itemId === itemTemplate.itemId) {
-                            fieldInfos[item.id]["sourceServiceFields"] =
-                                templateDictionary[k].sourceServiceFields;
-                            return true;
-                        }
-                        else {
-                            return false;
-                        }
-                    });
-                    // view field domain and alias can contain different values than the source field
-                    // we need to set isViewOverride when added fields that differ from the source field
-                    _validateViewDomainsAndAlias(fieldInfos[item.id], item);
+                if (item.isView) {
+                    deleteViewProps(item);
                 }
-            }
-            /* istanbul ignore else */
-            if (templateDictionary.isPortal) {
-                item = _updateForPortal(item, itemTemplate, templateDictionary);
-            }
-            removeLayerOptimization(item);
-            options = _updateAddOptions(itemTemplate, item, options, layerChunks, authentication);
-            if (item.type === "Feature Layer") {
-                options.layers.push(item);
-            }
-            else {
-                options.tables.push(item);
-            }
-            /* istanbul ignore else */
-            if ((i + 1) % 20 === 0 || i + 1 === listToAdd.length) {
-                layerChunks.push(Object.assign({}, options));
-                options = {
-                    layers: [],
-                    tables: [],
-                    authentication: authentication
-                };
-            }
-        });
-        layerChunks
-            .reduce(function (prev, curr) {
-            return prev.then(function () { return addToServiceDefinition(serviceUrl, curr); });
-        }, Promise.resolve(null))
-            .then(function () { return resolve(null); }, function (e) { return reject(fail(e)); });
+                // when the item is a view we need to grab the supporting fieldInfos
+                /* istanbul ignore else */
+                if (itemTemplate.properties.service.isView) {
+                    _updateGeomFieldName(item.adminLayerInfo, templateDictionary);
+                    adminLayerInfos[originalId] = item.adminLayerInfo;
+                    // need to update adminLayerInfo before adding to the service def
+                    // bring over the fieldInfos from the source layer
+                    updateSettingsFieldInfos(itemTemplate, templateDictionary);
+                    // update adminLayerInfo before add to definition with view source fieldInfo settings
+                    item.adminLayerInfo = replaceInTemplate(item.adminLayerInfo, templateDictionary);
+                    /* istanbul ignore else */
+                    if (!templateDictionary.isPortal &&
+                        fieldInfos &&
+                        fieldInfos.hasOwnProperty(item.id)) {
+                        Object.keys(templateDictionary).some(k => {
+                            if (templateDictionary[k].itemId === itemTemplate.itemId) {
+                                fieldInfos[item.id]["sourceServiceFields"] =
+                                    templateDictionary[k].sourceServiceFields;
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        });
+                        // view field domain and alias can contain different values than the source field
+                        // we need to set isViewOverride when added fields that differ from the source field
+                        _validateViewDomainsAndAlias(fieldInfos[item.id], item);
+                    }
+                }
+                /* istanbul ignore else */
+                if (templateDictionary.isPortal) {
+                    item = _updateForPortal(item, itemTemplate, templateDictionary);
+                }
+                removeLayerOptimization(item);
+                // this can still chunk layers
+                options = _updateAddOptions(itemTemplate, item, options, layerChunks, authentication);
+                if (item.type === "Feature Layer") {
+                    options.layers.push(item);
+                }
+                else {
+                    options.tables.push(item);
+                }
+                // In general we are switching to not use chunking. Rather if we exceed the defined chunk size
+                // we will use an async request.
+                // Currently the only case that should chunk the requests is when we have a multisource view
+                //  handled in _updateAddOptions above
+                /* istanbul ignore else */
+                if (i + 1 === listToAdd.length) {
+                    layerChunks.push(Object.assign({}, options));
+                    options = {
+                        layers: [],
+                        tables: [],
+                        authentication
+                    };
+                }
+            });
+            // will use async by default rather than chunk the layer requests when we have more layers
+            // than the defined chunk size
+            const useAsync = listToAdd.length > chunkSize;
+            layerChunks
+                .reduce((prev, curr) => prev.then(() => addToServiceDefinition(serviceUrl, curr, false, useAsync)), Promise.resolve(null))
+                .then(() => resolve(null), (e) => reject(fail(e)));
+        }
     });
 }
 /**
@@ -622,17 +651,17 @@ export function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDicti
  * @protected
  */
 export function _updateAddOptions(itemTemplate, item, options, layerChunks, authentication) {
-    var isMsView = getProp(itemTemplate, "properties.service.isMultiServicesView") || false;
-    var serviceName = getProp(itemTemplate, "item.name");
+    const isMsView = getProp(itemTemplate, "properties.service.isMultiServicesView") || false;
+    const serviceName = getProp(itemTemplate, "item.name");
     /* istanbul ignore else */
     if (isMsView) {
-        var table = getProp(item, "adminLayerInfo.viewLayerDefinition.table");
+        const table = getProp(item, "adminLayerInfo.viewLayerDefinition.table");
         /* istanbul ignore else */
         if (table) {
-            var tableNames = (table.relatedTables || []).map(function (t) { return t.sourceServiceName; });
+            const tableNames = (table.relatedTables || []).map((t) => t.sourceServiceName);
             tableNames.push(table.sourceServiceName);
             /* istanbul ignore else */
-            if (tableNames.some(function (n) { return n === serviceName; })) {
+            if (tableNames.some(n => n === serviceName)) {
                 // if we already have some layers or tables add them first
                 /* istanbul ignore else */
                 if (options.layers.length > 0 || options.tables.length > 0) {
@@ -640,7 +669,7 @@ export function _updateAddOptions(itemTemplate, item, options, layerChunks, auth
                     options = {
                         layers: [],
                         tables: [],
-                        authentication: authentication
+                        authentication
                     };
                 }
             }
@@ -683,41 +712,41 @@ export function _updateForPortal(item, itemTemplate, templateDictionary) {
     // Portal will fail if the sourceFields in the viewLayerDef contain fields that are not in the source service
     /* istanbul ignore else */
     if (item.isView) {
-        var viewLayerDefTable = getProp(item, "adminLayerInfo.viewLayerDefinition.table");
-        var fieldNames_1 = [];
+        const viewLayerDefTable = getProp(item, "adminLayerInfo.viewLayerDefinition.table");
+        let fieldNames = [];
         if (viewLayerDefTable) {
-            var tableFieldNames = _getFieldNames(viewLayerDefTable, itemTemplate, templateDictionary);
-            fieldNames_1 = fieldNames_1.concat(tableFieldNames);
+            const tableFieldNames = _getFieldNames(viewLayerDefTable, itemTemplate, templateDictionary);
+            fieldNames = fieldNames.concat(tableFieldNames);
             setProp(item, "adminLayerInfo.viewLayerDefinition.table", _updateSourceLayerFields(viewLayerDefTable, tableFieldNames));
             // Handle related also
             /* istanbul ignore else */
             if (Array.isArray(viewLayerDefTable.relatedTables)) {
-                viewLayerDefTable.relatedTables.map(function (relatedTable) {
-                    var relatedTableFieldNames = _getFieldNames(relatedTable, itemTemplate, templateDictionary);
-                    fieldNames_1 = fieldNames_1.concat(relatedTableFieldNames);
+                viewLayerDefTable.relatedTables.map((relatedTable) => {
+                    const relatedTableFieldNames = _getFieldNames(relatedTable, itemTemplate, templateDictionary);
+                    fieldNames = fieldNames.concat(relatedTableFieldNames);
                     return _updateSourceLayerFields(relatedTable, relatedTableFieldNames);
                 });
             }
         }
         else {
-            Object.keys(templateDictionary).some(function (k) {
+            Object.keys(templateDictionary).some(k => {
                 /* istanbul ignore else */
                 if (templateDictionary[k].itemId === item.serviceItemId) {
-                    var layerInfo = templateDictionary[k]["layer" + item.id];
+                    const layerInfo = templateDictionary[k][`layer${item.id}`];
                     /* istanbul ignore else */
                     if (layerInfo && layerInfo.fields) {
                         if (Array.isArray(layerInfo.fields)) {
-                            fieldNames_1 = layerInfo.fields.map(function (f) { return f.name; });
+                            fieldNames = layerInfo.fields.map((f) => f.name);
                         }
                         else {
-                            fieldNames_1 = Object.keys(layerInfo.fields);
+                            fieldNames = Object.keys(layerInfo.fields);
                         }
                     }
                     return true;
                 }
             });
         }
-        item = _updateItemFields(item, fieldNames_1);
+        item = _updateItemFields(item, fieldNames);
     }
     // not allowed to set sourceSchemaChangesAllowed or isView for portal
     // these are set when you create the service
@@ -736,19 +765,19 @@ export function _updateForPortal(item, itemTemplate, templateDictionary) {
  * @protected
  */
 export function _getFieldNames(table, itemTemplate, templateDictionary) {
-    var sourceLayerFields = [];
-    var viewSourceLayerId = table.sourceLayerId;
+    let sourceLayerFields = [];
+    const viewSourceLayerId = table.sourceLayerId;
     /* istanbul ignore else */
     if (typeof viewSourceLayerId === "number") {
         // need to make sure these actually exist in the source..
-        itemTemplate.dependencies.forEach(function (d) {
-            var layerInfo = templateDictionary[d]["layer" + viewSourceLayerId];
+        itemTemplate.dependencies.forEach(d => {
+            const layerInfo = templateDictionary[d][`layer${viewSourceLayerId}`];
             /* istanbul ignore else */
             if (layerInfo &&
                 layerInfo.fields &&
                 templateDictionary[d].name === table.sourceServiceName) {
                 if (Array.isArray(layerInfo.fields)) {
-                    sourceLayerFields = sourceLayerFields.concat(layerInfo.fields.map(function (f) { return f.name; }));
+                    sourceLayerFields = sourceLayerFields.concat(layerInfo.fields.map((f) => f.name));
                 }
                 else {
                     sourceLayerFields = sourceLayerFields.concat(Object.keys(layerInfo.fields));
@@ -772,11 +801,11 @@ export function _updateItemFields(item, fieldNames) {
     if (fieldNames.length > 0) {
         /* istanbul ignore else */
         if (item.fields) {
-            item.fields = item.fields.filter(function (f) { return fieldNames.indexOf(f.name) > -1; });
+            item.fields = item.fields.filter((f) => fieldNames.indexOf(f.name) > -1);
         }
         /* istanbul ignore else */
         if (item.indexes) {
-            item.indexes = item.indexes.filter(function (f) { return fieldNames.indexOf(f.fields) > -1; });
+            item.indexes = item.indexes.filter((f) => fieldNames.indexOf(f.fields) > -1);
         }
     }
     return item;
@@ -796,7 +825,7 @@ export function _updateSourceLayerFields(table, sourceLayerFields) {
         // need to make sure these actually exist in the source..
         /* istanbul ignore else */
         if (sourceLayerFields.length > 0) {
-            setProp(table, "sourceLayerFields", table.sourceLayerFields.filter(function (f) { return sourceLayerFields.indexOf(f.source.toLowerCase()) > -1; }));
+            setProp(table, "sourceLayerFields", table.sourceLayerFields.filter((f) => sourceLayerFields.indexOf(f.source.toLowerCase()) > -1));
         }
     }
     return table;
@@ -811,13 +840,13 @@ export function _updateSourceLayerFields(table, sourceLayerFields) {
  */
 export function _updateGeomFieldName(adminLayerInfo, templateDictionary) {
     // issue #471
-    var tableName = getProp(adminLayerInfo, "viewLayerDefinition.table.name");
-    var fieldName = getProp(adminLayerInfo, "geometryField.name");
+    const tableName = getProp(adminLayerInfo, "viewLayerDefinition.table.name");
+    const fieldName = getProp(adminLayerInfo, "geometryField.name");
     /* istanbul ignore else */
     if (fieldName && tableName) {
-        var geomName = templateDictionary.isPortal
-            ? tableName + ".shape"
-            : tableName + ".Shape";
+        const geomName = templateDictionary.isPortal
+            ? `${tableName}.shape`
+            : `${tableName}.Shape`;
         setProp(adminLayerInfo, "geometryField.name", geomName);
     }
     else if (!fieldName && getProp(adminLayerInfo, "geometryField")) {
@@ -837,16 +866,15 @@ export function _updateGeomFieldName(adminLayerInfo, templateDictionary) {
  * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature service)
  * @protected
  */
-export function _updateTemplateDictionaryFields(itemTemplate, templateDictionary, compareItemId) {
-    if (compareItemId === void 0) { compareItemId = true; }
-    var layers = itemTemplate.properties.layers;
-    var tables = itemTemplate.properties.tables;
-    var layersAndTables = layers.concat(tables);
-    var fieldInfos = {};
-    layersAndTables.forEach(function (layerOrTable) {
+export function _updateTemplateDictionaryFields(itemTemplate, templateDictionary, compareItemId = true) {
+    const layers = itemTemplate.properties.layers;
+    const tables = itemTemplate.properties.tables;
+    const layersAndTables = layers.concat(tables);
+    const fieldInfos = {};
+    layersAndTables.forEach(layerOrTable => {
         fieldInfos[layerOrTable.id] = layerOrTable.fields;
     });
-    Object.keys(templateDictionary).some(function (k) {
+    Object.keys(templateDictionary).some(k => {
         if (compareItemId
             ? templateDictionary[k].itemId === itemTemplate.itemId
             : k === itemTemplate.itemId) {
@@ -871,7 +899,7 @@ export function _updateTemplateDictionaryFields(itemTemplate, templateDictionary
 export function setDefaultSpatialReference(templateDictionary, itemId, spatialReference) {
     /* istanbul ignore else */
     if (spatialReference) {
-        setCreateProp(templateDictionary, itemId + ".defaultSpatialReference", spatialReference);
+        setCreateProp(templateDictionary, `${itemId}.defaultSpatialReference`, spatialReference);
     }
 }
 /**
@@ -887,34 +915,34 @@ export function setDefaultSpatialReference(templateDictionary, itemId, spatialRe
 export function validateSpatialReferenceAndExtent(serviceInfo, itemTemplate, templateDictionary) {
     /* istanbul ignore else */
     if (getProp(serviceInfo, "service.isView")) {
-        var sourceSR_1;
-        var sourceExt_1;
-        itemTemplate.dependencies.some(function (id) {
-            var source = templateDictionary[id];
-            var sr = getProp(source, "defaultSpatialReference");
+        let sourceSR;
+        let sourceExt;
+        itemTemplate.dependencies.some(id => {
+            const source = templateDictionary[id];
+            const sr = getProp(source, "defaultSpatialReference");
             /* istanbul ignore else */
-            if (!sourceSR_1 && sr) {
-                sourceSR_1 = sr;
+            if (!sourceSR && sr) {
+                sourceSR = sr;
             }
-            var ext = getProp(source, "defaultExtent");
+            const ext = getProp(source, "defaultExtent");
             /* istanbul ignore else */
-            if (!sourceExt_1 && ext) {
-                sourceExt_1 = ext;
+            if (!sourceExt && ext) {
+                sourceExt = ext;
             }
-            return sourceSR_1 && sourceExt_1;
+            return sourceSR && sourceExt;
         });
-        var sourceWkid = getProp(sourceSR_1, "wkid");
-        var viewWkid = getProp(serviceInfo, "service.spatialReference.wkid");
+        const sourceWkid = getProp(sourceSR, "wkid");
+        const viewWkid = getProp(serviceInfo, "service.spatialReference.wkid");
         /* istanbul ignore else */
         if (sourceWkid && viewWkid && sourceWkid !== viewWkid) {
-            setCreateProp(serviceInfo, "service.spatialReference", sourceSR_1);
+            setCreateProp(serviceInfo, "service.spatialReference", sourceSR);
         }
-        var viewExt = getProp(serviceInfo, "service.fullExtent");
+        const viewExt = getProp(serviceInfo, "service.fullExtent");
         /* istanbul ignore else */
-        if (sourceExt_1 &&
+        if (sourceExt &&
             viewExt &&
-            JSON.stringify(sourceExt_1) !== JSON.stringify(viewExt)) {
-            setCreateProp(serviceInfo, "defaultExtent", sourceExt_1);
+            JSON.stringify(sourceExt) !== JSON.stringify(viewExt)) {
+            setCreateProp(serviceInfo, "defaultExtent", sourceExt);
         }
     }
 }
@@ -931,17 +959,17 @@ export function validateSpatialReferenceAndExtent(serviceInfo, itemTemplate, tem
  * @protected
  */
 export function updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary) {
-    return new Promise(function (resolveFn, rejectFn) {
+    return new Promise((resolveFn, rejectFn) => {
         // Will need to do some post processing for fields
         // to handle any potential field name changes when deploying to portal
-        postProcessFields(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary).then(function (layerInfos) {
+        postProcessFields(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary).then((layerInfos) => {
             // Update the items text with detemplatized popupInfo
             updatePopupInfo(itemTemplate, layerInfos.popupInfos);
             resolveFn({
-                itemTemplate: itemTemplate,
-                layerInfos: layerInfos
+                itemTemplate,
+                layerInfos
             });
-        }, function (e) { return rejectFn(fail(e)); });
+        }, e => rejectFn(fail(e)));
     });
 }
 /**
@@ -958,17 +986,17 @@ export function updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos,
  * @protected
  */
 export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLayerInfos, templateDictionary) {
-    return new Promise(function (resolveFn, rejectFn) {
+    return new Promise((resolveFn, rejectFn) => {
         if (!itemTemplate.item.url) {
             rejectFn(fail("Feature layer " + itemTemplate.itemId + " does not have a URL"));
         }
         else {
-            var id_1 = itemTemplate.itemId;
-            var settingsKeys = Object.keys(templateDictionary);
-            var templateInfo_1;
-            settingsKeys.some(function (k) {
-                if (templateDictionary[k].itemId === id_1) {
-                    templateInfo_1 = templateDictionary[k];
+            const id = itemTemplate.itemId;
+            const settingsKeys = Object.keys(templateDictionary);
+            let templateInfo;
+            settingsKeys.some(k => {
+                if (templateDictionary[k].itemId === id) {
+                    templateInfo = templateDictionary[k];
                     return true;
                 }
                 else {
@@ -976,19 +1004,19 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
                 }
             });
             // concat any layers and tables to process
-            var layers = itemTemplate.properties.layers;
-            var tables = itemTemplate.properties.tables;
-            var layersAndTables = layers.concat(tables);
+            const layers = itemTemplate.properties.layers;
+            const tables = itemTemplate.properties.tables;
+            const layersAndTables = layers.concat(tables);
             // Set the newFields property for the layerInfos...this will contain all fields
             // as they are after being added to the definition.
             // This allows us to handle any potential field name changes after deploy to portal
-            layersAndTables.forEach(function (item) {
+            layersAndTables.forEach((item) => {
                 // when deploying to portal "isView" is only set for create service and will fail when
                 // present on addToDef so this property is removed from item and we should check the templates service info
-                var isView = item.isView || itemTemplate.properties.service.isView;
+                const isView = item.isView || itemTemplate.properties.service.isView;
                 /* istanbul ignore else */
                 if (layerInfos && layerInfos.hasOwnProperty(item.id)) {
-                    var layerInfo = layerInfos[item.id];
+                    const layerInfo = layerInfos[item.id];
                     layerInfo["isView"] = item.isView;
                     layerInfo["newFields"] = item.fields;
                     layerInfo["sourceSchemaChangesAllowed"] =
@@ -1002,10 +1030,10 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
                     // visible true when added with the layer definition
                     // update the field visibility to match that of the source
                     /* istanbul ignore else */
-                    if (isView && templateInfo_1 && templateDictionary.isPortal) {
+                    if (isView && templateInfo && templateDictionary.isPortal) {
                         // when the item is a view bring over the source service fields so we can compare the domains
-                        layerInfo["sourceServiceFields"] = templateInfo_1.sourceServiceFields;
-                        var fieldUpdates = _getFieldVisibilityUpdates(layerInfo);
+                        layerInfo["sourceServiceFields"] = templateInfo.sourceServiceFields;
+                        let fieldUpdates = _getFieldVisibilityUpdates(layerInfo);
                         // view field domains can contain different values than the source field domains
                         // use the cached view domain when it differs from the source view domain
                         fieldUpdates = _validateDomains(layerInfo, fieldUpdates);
@@ -1014,16 +1042,16 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
                             layerInfo.fields = fieldUpdates;
                         }
                         layerInfo.typeIdField = _getTypeIdField(item);
-                        var fieldNames = layerInfo.newFields.map(function (f) { return f.name; });
+                        const fieldNames = layerInfo.newFields.map((f) => f.name);
                         _validateTemplatesFields(layerInfo, fieldNames);
                         _validateTypesTemplates(layerInfo, fieldNames);
                     }
                 }
             });
             // Add the layerInfos to the settings object to be used while detemplatizing
-            settingsKeys.forEach(function (k) {
-                if (id_1 === templateDictionary[k].itemId) {
-                    templateDictionary[k] = Object.assign(templateDictionary[k], getLayerSettings(layerInfos, templateDictionary[k].url, id_1));
+            settingsKeys.forEach((k) => {
+                if (id === templateDictionary[k].itemId) {
+                    templateDictionary[k] = Object.assign(templateDictionary[k], getLayerSettings(layerInfos, templateDictionary[k].url, id));
                 }
             });
             // update the layerInfos object with current field names
@@ -1040,7 +1068,7 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
  * @protected
  */
 export function _getTypeIdField(item) {
-    var typeIdFields = item.fields.filter(function (f) {
+    const typeIdFields = item.fields.filter((f) => {
         return (f.name &&
             item.typeIdField &&
             f.name.toLowerCase() === item.typeIdField.toLowerCase());
@@ -1059,19 +1087,19 @@ export function _getTypeIdField(item) {
  * @protected
  */
 export function _getFieldVisibilityUpdates(fieldInfo) {
-    var visibilityUpdates = [];
+    const visibilityUpdates = [];
     if (fieldInfo && fieldInfo["sourceFields"] && fieldInfo["newFields"]) {
-        var sourceFields_1 = fieldInfo["sourceFields"].reduce(function (hash, f) {
+        const sourceFields = fieldInfo["sourceFields"].reduce((hash, f) => {
             hash[String(f.name).toLocaleLowerCase()] = f.visible;
             return hash;
         }, {});
-        fieldInfo["newFields"].forEach(function (f) {
-            var name = String(f.name).toLocaleLowerCase();
+        fieldInfo["newFields"].forEach((f) => {
+            const name = String(f.name).toLocaleLowerCase();
             // only add fields that are not visible
-            if (sourceFields_1.hasOwnProperty(name) && !sourceFields_1[name]) {
+            if (sourceFields.hasOwnProperty(name) && !sourceFields[name]) {
                 visibilityUpdates.push({
                     name: f.name,
-                    visible: sourceFields_1[name]
+                    visible: sourceFields[name]
                 });
             }
         });
@@ -1088,14 +1116,14 @@ export function _getFieldVisibilityUpdates(fieldInfo) {
  * @protected
  */
 export function _validateDomains(fieldInfo, fieldUpdates) {
-    var domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
-    var domainFields = domainAliasInfos.domainFields;
-    var domainNames = domainAliasInfos.domainNames;
-    var aliasFields = domainAliasInfos.aliasFields;
-    var aliasNames = domainAliasInfos.aliasNames;
+    const domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
+    const domainFields = domainAliasInfos.domainFields;
+    const domainNames = domainAliasInfos.domainNames;
+    const aliasFields = domainAliasInfos.aliasFields;
+    const aliasNames = domainAliasInfos.aliasNames;
     // loop through the fields from the new view service
     // add an update when the domains don't match
-    fieldInfo.newFields.forEach(function (field) {
+    fieldInfo.newFields.forEach((field) => {
         _getPortalViewFieldUpdates(field, domainNames, domainFields, "domain", fieldUpdates);
         _getPortalViewFieldUpdates(field, aliasNames, aliasFields, "alias", fieldUpdates);
     });
@@ -1114,19 +1142,19 @@ export function _validateDomains(fieldInfo, fieldUpdates) {
  */
 export function _getPortalViewFieldUpdates(field, names, fields, key, fieldUpdates) {
     if (field.hasOwnProperty(key) && field[key]) {
-        var i = names.indexOf(String(field.name).toLocaleLowerCase());
+        const i = names.indexOf(String(field.name).toLocaleLowerCase());
         if (JSON.stringify(field[key]) !== (i > -1 ? JSON.stringify(fields[i]) : "")) {
             // should mixin the update if the field already has some other update
-            var hasUpdate_1 = false;
-            fieldUpdates.some(function (update) {
+            let hasUpdate = false;
+            fieldUpdates.some((update) => {
                 if (update.name === field.name) {
-                    hasUpdate_1 = true;
+                    hasUpdate = true;
                     update[key] = field[key];
                 }
-                return hasUpdate_1;
+                return hasUpdate;
             });
-            if (!hasUpdate_1) {
-                var update = { name: field.name };
+            if (!hasUpdate) {
+                const update = { name: field.name };
                 update[key] = field[key];
                 fieldUpdates.push(update);
             }
@@ -1143,14 +1171,14 @@ export function _getPortalViewFieldUpdates(field, names, fields, key, fieldUpdat
  * @protected
  */
 export function _validateViewDomainsAndAlias(fieldInfo, item) {
-    var domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
-    var domainFields = domainAliasInfos.domainFields;
-    var domainNames = domainAliasInfos.domainNames;
-    var aliasFields = domainAliasInfos.aliasFields;
-    var aliasNames = domainAliasInfos.aliasNames;
+    const domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
+    const domainFields = domainAliasInfos.domainFields;
+    const domainNames = domainAliasInfos.domainNames;
+    const aliasFields = domainAliasInfos.aliasFields;
+    const aliasNames = domainAliasInfos.aliasNames;
     // loop through the fields from the item
     // add isViewOverride when the domains or alias don't match
-    item.fields.map(function (field) {
+    item.fields.map((field) => {
         _isViewFieldOverride(field, domainNames, domainFields, "domain");
         _isViewFieldOverride(field, aliasNames, aliasFields, "alias");
         return field;
@@ -1163,17 +1191,17 @@ export function _validateViewDomainsAndAlias(fieldInfo, item) {
  *
  */
 export function _getDomainAndAliasInfos(fieldInfo) {
-    var domainFields = [];
-    var domainNames = [];
-    var aliasFields = [];
-    var aliasNames = [];
+    const domainFields = [];
+    const domainNames = [];
+    const aliasFields = [];
+    const aliasNames = [];
     /* istanbul ignore else */
     if (fieldInfo.sourceServiceFields) {
-        Object.keys(fieldInfo.sourceServiceFields).forEach(function (k) {
+        Object.keys(fieldInfo.sourceServiceFields).forEach(k => {
             /* istanbul ignore else */
             if (fieldInfo.sourceServiceFields[k]) {
-                Object.keys(fieldInfo.sourceServiceFields[k]).forEach(function (_k) {
-                    fieldInfo.sourceServiceFields[k][_k].forEach(function (field) {
+                Object.keys(fieldInfo.sourceServiceFields[k]).forEach(_k => {
+                    fieldInfo.sourceServiceFields[k][_k].forEach((field) => {
                         /* istanbul ignore else */
                         if (field.hasOwnProperty("domain") && field.domain) {
                             domainFields.push(field.domain);
@@ -1190,10 +1218,10 @@ export function _getDomainAndAliasInfos(fieldInfo) {
         });
     }
     return {
-        aliasFields: aliasFields,
-        aliasNames: aliasNames,
-        domainFields: domainFields,
-        domainNames: domainNames
+        aliasFields,
+        aliasNames,
+        domainFields,
+        domainNames
     };
 }
 /**
@@ -1208,7 +1236,7 @@ export function _getDomainAndAliasInfos(fieldInfo) {
 export function _isViewFieldOverride(field, names, fields, key) {
     /* istanbul ignore else */
     if (field.hasOwnProperty(key) && field[key]) {
-        var i = names.indexOf(String(field.name).toLocaleLowerCase());
+        const i = names.indexOf(String(field.name).toLocaleLowerCase());
         /* istanbul ignore else */
         if (JSON.stringify(field[key]) !== (i > -1 ? JSON.stringify(fields[i]) : "")) {
             field.isViewOverride = true;
@@ -1223,11 +1251,11 @@ export function _isViewFieldOverride(field, names, fields, key) {
  * @protected
  */
 export function updatePopupInfo(itemTemplate, popupInfos) {
-    ["layers", "tables"].forEach(function (type) {
-        var _items = getProp(itemTemplate, "data." + type);
+    ["layers", "tables"].forEach(type => {
+        const _items = getProp(itemTemplate, "data." + type);
         /* istanbul ignore else */
         if (_items && Array.isArray(_items)) {
-            _items.forEach(function (item) {
+            _items.forEach((item) => {
                 item.popupInfo = getProp(popupInfos, type + "." + item.id) || {};
             });
         }
@@ -1280,11 +1308,11 @@ export function _templatizeLayer(dataItem, adminItem, itemTemplate, dependencies
     if (templatizeFieldReferences) {
         _templatizeLayerFieldReferences(dataItem, itemTemplate.itemId, adminItem, dependencies);
     }
-    var updates = [adminItem];
+    const updates = [adminItem];
     if (dataItem) {
         updates.push(dataItem);
     }
-    updates.forEach(function (update) {
+    updates.forEach(update => {
         if (update.hasOwnProperty("name")) {
             // templatize the name but leave the current name as the optional default
             update.name = templatizeTerm(update["serviceItemId"] + ".layer" + update.id, update["serviceItemId"] + ".layer" + update.id, ".name||" + update.name);
@@ -1307,7 +1335,7 @@ export function _templatizeLayer(dataItem, adminItem, itemTemplate, dependencies
  * @param adminItem layer or table from the service
  */
 export function _validateFields(adminItem) {
-    var fieldNames = (adminItem.fields || []).map(function (f) { return f.name; });
+    const fieldNames = (adminItem.fields || []).map((f) => f.name);
     // Update primary display field if field isn't in the layer.
     _validateDisplayField(adminItem, fieldNames);
     // Remove indexes on fields that don't exist in the layer.
@@ -1327,9 +1355,9 @@ export function _validateFields(adminItem) {
  * @param fieldNames string list of fields names
  */
 export function _validateDisplayField(adminItem, fieldNames) {
-    var displayField = adminItem.displayField || "";
-    var i = -1;
-    if (fieldNames.some(function (name) {
+    const displayField = adminItem.displayField || "";
+    let i = -1;
+    if (fieldNames.some(name => {
         i += 1;
         return name === displayField || name === displayField.toLowerCase();
     })) {
@@ -1337,19 +1365,19 @@ export function _validateDisplayField(adminItem, fieldNames) {
     }
     else {
         // use the first non-OID non-globalId field we find
-        var skipFields_1 = [];
-        var oidField = getProp(adminItem, "uniqueIdField.name");
+        const skipFields = [];
+        const oidField = getProp(adminItem, "uniqueIdField.name");
         /* istanbul ignore else */
         if (oidField) {
-            skipFields_1.push(oidField);
+            skipFields.push(oidField);
         }
-        var globalIdField = getProp(adminItem, "globalIdField");
+        const globalIdField = getProp(adminItem, "globalIdField");
         /* istanbul ignore else */
         if (globalIdField) {
-            skipFields_1.push(globalIdField);
+            skipFields.push(globalIdField);
         }
-        fieldNames.some(function (name) {
-            if (skipFields_1.indexOf(name) === -1) {
+        fieldNames.some(name => {
+            if (skipFields.indexOf(name) === -1) {
                 adminItem.displayField = name;
                 return true;
             }
@@ -1367,17 +1395,17 @@ export function _validateDisplayField(adminItem, fieldNames) {
  * @param fieldNames string list of fields names
  */
 export function _validateIndexes(adminItem, fieldNames) {
-    var indexes = adminItem.indexes;
+    const indexes = adminItem.indexes;
     /* istanbul ignore else */
     if (indexes) {
-        var indexedFields_1 = [];
-        adminItem.indexes = indexes.reduce(function (filtered, index) {
-            var indexFields = index.fields.split(",");
-            var verifiedFields = [];
-            indexFields.forEach(function (indexField) {
+        const indexedFields = [];
+        adminItem.indexes = indexes.reduce((filtered, index) => {
+            const indexFields = index.fields.split(",");
+            const verifiedFields = [];
+            indexFields.forEach(indexField => {
                 /* istanbul ignore else */
-                if (indexedFields_1.indexOf(indexField) === -1) {
-                    indexedFields_1.push(indexField);
+                if (indexedFields.indexOf(indexField) === -1) {
+                    indexedFields.push(indexField);
                     // this is the first index with this field and it should be added if the field exists
                     /* istanbul ignore else */
                     if (fieldNames.indexOf(indexField) > -1) {
@@ -1402,14 +1430,14 @@ export function _validateIndexes(adminItem, fieldNames) {
  * @param fieldNames string list of fields names
  */
 export function _validateTemplatesFields(adminItem, fieldNames) {
-    var templates = adminItem.templates;
+    const templates = adminItem.templates;
     /* istanbul ignore else */
     if (templates) {
-        adminItem.templates = templates.map(function (template) {
-            var attributes = getProp(template, "prototype.attributes");
+        adminItem.templates = templates.map(template => {
+            const attributes = getProp(template, "prototype.attributes");
             /* istanbul ignore else */
             if (attributes) {
-                Object.keys(attributes).forEach(function (k) {
+                Object.keys(attributes).forEach(k => {
                     /* istanbul ignore else */
                     if (fieldNames.indexOf(k) === -1) {
                         delete attributes[k];
@@ -1428,10 +1456,10 @@ export function _validateTemplatesFields(adminItem, fieldNames) {
  * @param fieldNames string list of fields names
  */
 export function _validateTypesTemplates(adminItem, fieldNames) {
-    var types = adminItem.types;
+    const types = adminItem.types;
     /* istanbul ignore else */
     if (types) {
-        adminItem.types = types.map(function (t) {
+        adminItem.types = types.map(t => {
             _validateTemplatesFields(t, fieldNames);
             return t;
         });
@@ -1444,15 +1472,15 @@ export function _validateTypesTemplates(adminItem, fieldNames) {
  * @param fieldNames string list of fields names
  */
 export function _validateEditFieldsInfo(adminItem, fieldNames) {
-    var editFieldsInfo = adminItem.editFieldsInfo;
+    const editFieldsInfo = adminItem.editFieldsInfo;
     /* istanbul ignore else */
     if (editFieldsInfo) {
-        var editFieldsInfoKeys = Object.keys(editFieldsInfo);
-        editFieldsInfoKeys.forEach(function (k) {
-            var editFieldName = editFieldsInfo[k];
+        const editFieldsInfoKeys = Object.keys(editFieldsInfo);
+        editFieldsInfoKeys.forEach(k => {
+            const editFieldName = editFieldsInfo[k];
             /* istanbul ignore else */
             if (editFieldName) {
-                fieldNames.some(function (name) {
+                fieldNames.some(name => {
                     if (name === editFieldName) {
                         return true;
                     }
@@ -1482,9 +1510,9 @@ export function _validateEditFieldsInfo(adminItem, fieldNames) {
  */
 export function _templatizeLayerFieldReferences(dataItem, itemID, layer, dependencies) {
     // This is the value that will be used as the template for adlib replacement
-    var path = itemID + ".layer" + layer.id + ".fields";
+    const path = itemID + ".layer" + layer.id + ".fields";
     // Get the field names for various tests
-    var fieldNames = layer.fields.map(function (f) { return f.name; });
+    const fieldNames = layer.fields.map((f) => f.name);
     // Update the layer from the items data property
     if (dataItem) {
         _templatizeAdminLayerInfoFields(dataItem, dependencies);
@@ -1512,14 +1540,14 @@ export function _templatizeLayerFieldReferences(dataItem, itemID, layer, depende
  */
 export function _templatizeAdminLayerInfo(layer, dependencies, templateDictionary) {
     // Create new instance of adminLayerInfo to update for clone
-    var adminLayerInfo = Object.assign({}, layer.adminLayerInfo);
+    const adminLayerInfo = Object.assign({}, layer.adminLayerInfo);
     _updateGeomFieldName(adminLayerInfo, templateDictionary);
     deleteProp(adminLayerInfo, "xssTrustedFields");
     deleteProp(adminLayerInfo, "tableName");
     // Remove unnecessary properties and templatize key properties from viewLayerDefinition
     /* istanbul ignore else */
     if (adminLayerInfo.viewLayerDefinition) {
-        var viewDef = Object.assign({}, adminLayerInfo.viewLayerDefinition);
+        const viewDef = Object.assign({}, adminLayerInfo.viewLayerDefinition);
         _processAdminObject(viewDef, dependencies);
         // Remove unnecessary properties and templatize key properties from viewLayerDefinition.table
         /* istanbul ignore else */
@@ -1527,7 +1555,7 @@ export function _templatizeAdminLayerInfo(layer, dependencies, templateDictionar
             _processAdminObject(viewDef.table, dependencies);
             /* istanbul ignore else */
             if (viewDef.table.relatedTables) {
-                viewDef.table.relatedTables.forEach(function (table) {
+                viewDef.table.relatedTables.forEach((table) => {
                     _processAdminObject(table, dependencies);
                 });
             }
@@ -1558,7 +1586,7 @@ export function _processAdminObject(object, dependencies) {
  * @protected
  */
 export function _templatizeSourceServiceName(lookupName, dependencies) {
-    var deps = dependencies.filter(function (dependency) { return dependency.name === lookupName; });
+    const deps = dependencies.filter(dependency => dependency.name === lookupName);
     return deps.length === 1 ? _templatize(deps[0].id, "name") : undefined;
 }
 /**
@@ -1570,25 +1598,25 @@ export function _templatizeSourceServiceName(lookupName, dependencies) {
  */
 export function _templatizeAdminLayerInfoFields(layer, dependencies) {
     // templatize the source layer fields
-    var table = getProp(layer, "adminLayerInfo.viewLayerDefinition.table");
+    const table = getProp(layer, "adminLayerInfo.viewLayerDefinition.table");
     if (table) {
-        var id_2 = _getDependantItemId(table.sourceServiceName, dependencies);
-        var path_1 = id_2 + ".layer" + table.sourceLayerId + ".fields";
-        _templatizeAdminSourceLayerFields(table.sourceLayerFields || [], path_1);
+        let id = _getDependantItemId(table.sourceServiceName, dependencies);
+        const path = id + ".layer" + table.sourceLayerId + ".fields";
+        _templatizeAdminSourceLayerFields(table.sourceLayerFields || [], path);
         // templatize the releated table fields
-        var relatedTables = getProp(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables") || [];
+        const relatedTables = getProp(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables") || [];
         if (relatedTables.length > 0) {
-            relatedTables.forEach(function (t) {
-                id_2 = _getDependantItemId(t.sourceServiceName, dependencies);
-                var relatedPath = id_2 + ".layer" + t.sourceLayerId + ".fields";
+            relatedTables.forEach((t) => {
+                id = _getDependantItemId(t.sourceServiceName, dependencies);
+                const relatedPath = id + ".layer" + t.sourceLayerId + ".fields";
                 _templatizeTopFilter(t.topFilter || {}, relatedPath);
                 _templatizeAdminSourceLayerFields(t.sourceLayerFields || [], relatedPath);
-                var parentKeyFields = t.parentKeyFields || [];
-                t.parentKeyFields = parentKeyFields.map(function (f) {
-                    return _templatize(path_1, f, "name");
+                const parentKeyFields = t.parentKeyFields || [];
+                t.parentKeyFields = parentKeyFields.map((f) => {
+                    return _templatize(path, f, "name");
                 });
-                var keyFields = t.keyFields || [];
-                t.keyFields = keyFields.map(function (f) {
+                const keyFields = t.keyFields || [];
+                t.keyFields = keyFields.map((f) => {
                     return _templatize(relatedPath, f, "name");
                 });
             });
@@ -1602,7 +1630,7 @@ export function _templatizeAdminLayerInfoFields(layer, dependencies) {
  * @param dependencies array of item dependencies
  */
 export function _getDependantItemId(lookupName, dependencies) {
-    var deps = dependencies.filter(function (dependency) { return dependency.name === lookupName; });
+    const deps = dependencies.filter(dependency => dependency.name === lookupName);
     return deps.length === 1 ? deps[0].id : "";
 }
 /**
@@ -1612,7 +1640,7 @@ export function _getDependantItemId(lookupName, dependencies) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizeAdminSourceLayerFields(fields, basePath) {
-    fields.forEach(function (f) { return _templatizeProperty(f, "source", basePath, "name"); });
+    fields.forEach(f => _templatizeProperty(f, "source", basePath, "name"));
 }
 /**
  * templatize the topFilter property from adminLayerInfo related tables
@@ -1624,19 +1652,19 @@ export function _templatizeTopFilter(topFilter, basePath) {
     /* istanbul ignore else */
     if (topFilter) {
         // templatize the orderByFields prop
-        var orderByFields = topFilter["orderByFields"] || "";
+        const orderByFields = topFilter["orderByFields"] || "";
         /* istanbul ignore else */
         if (orderByFields !== "") {
-            var orderByField = orderByFields.split(" ")[0];
+            const orderByField = orderByFields.split(" ")[0];
             topFilter.orderByFields = topFilter.orderByFields.replace(orderByField, _templatize(basePath, orderByField, "name"));
         }
-        var groupByFields = topFilter["groupByFields"] || "";
+        const groupByFields = topFilter["groupByFields"] || "";
         /* istanbul ignore else */
         if (groupByFields !== "") {
-            var _groupByFields = groupByFields.split(",");
+            const _groupByFields = groupByFields.split(",");
             /* istanbul ignore else */
             if (_groupByFields.length > 0) {
-                var mappedFields = _groupByFields.map(function (f) {
+                const mappedFields = _groupByFields.map((f) => {
                     return _templatize(basePath, f, "name");
                 });
                 topFilter.groupByFields = mappedFields.join(",");
@@ -1652,11 +1680,11 @@ export function _templatizeTopFilter(topFilter, basePath) {
  */
 export function _templatizeRelationshipFields(layer, itemID) {
     if (layer && layer.relationships) {
-        var relationships = layer.relationships;
-        relationships.forEach(function (r) {
+        const relationships = layer.relationships;
+        relationships.forEach(r => {
             /* istanbul ignore else */
             if (r.keyField) {
-                var basePath = itemID + ".layer" + layer.id + ".fields";
+                const basePath = itemID + ".layer" + layer.id + ".fields";
                 _templatizeProperty(r, "keyField", basePath, "name");
             }
         });
@@ -1675,16 +1703,16 @@ export function _templatizePopupInfo(layerDefinition, layer, basePath, itemID, f
     // the data layer does not have the fields...will need to get those
     // from the associated layer json
     if (fieldNames && layerDefinition.popupInfo) {
-        var popupInfo = layerDefinition.popupInfo;
+        const popupInfo = layerDefinition.popupInfo;
         _templatizeName(popupInfo, "title", fieldNames, basePath);
         _templatizeName(popupInfo, "description", fieldNames, basePath);
-        var fieldInfos = popupInfo.fieldInfos || [];
+        const fieldInfos = popupInfo.fieldInfos || [];
         _templatizePopupInfoFieldInfos(fieldInfos, layer, itemID, basePath);
-        var expressionInfos = popupInfo.expressionInfos || [];
+        const expressionInfos = popupInfo.expressionInfos || [];
         _templatizeExpressionInfos(expressionInfos, fieldNames, basePath);
-        var popupElements = popupInfo.popupElements || [];
+        const popupElements = popupInfo.popupElements || [];
         _templatizePopupElements(popupElements, basePath, layer, itemID, fieldNames);
-        var mediaInfos = popupInfo.mediaInfos || [];
+        const mediaInfos = popupInfo.mediaInfos || [];
         _templatizeMediaInfos(mediaInfos, fieldNames, basePath, layer, itemID);
     }
 }
@@ -1699,10 +1727,10 @@ export function _templatizePopupInfo(layerDefinition, layer, basePath, itemID, f
  */
 export function _templatizeName(object, property, fieldNames, basePath) {
     if (object.hasOwnProperty(property)) {
-        fieldNames.forEach(function (name) {
+        fieldNames.forEach(name => {
             // Only test and replace instance of the name so any enclosing characters
             // will be retained
-            var regEx = new RegExp("(\\b" + name + "\\b(?![}]{2}))", "gm");
+            const regEx = new RegExp("(\\b" + name + "\\b(?![}]{2}))", "gm");
             if (regEx.test(object[property])) {
                 object[property] = object[property].replace(regEx, _templatize(basePath, name, "name"));
             }
@@ -1719,7 +1747,7 @@ export function _templatizeName(object, property, fieldNames, basePath) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizePopupInfoFieldInfos(fieldInfos, layer, itemID, basePath) {
-    fieldInfos.forEach(function (f) {
+    fieldInfos.forEach((f) => {
         f.fieldName = _templatizeFieldName(f.fieldName, layer, itemID, basePath);
     });
 }
@@ -1734,19 +1762,19 @@ export function _templatizePopupInfoFieldInfos(fieldInfos, layer, itemID, basePa
  */
 export function _templatizeFieldName(name, layer, itemID, basePath) {
     if (name.indexOf("relationships/") > -1) {
-        var rels = name.split("/");
-        var relationshipId = rels[1];
-        var adminRelatedTables = getProp(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables");
-        var relatedTables = layer.relationships || adminRelatedTables;
+        const rels = name.split("/");
+        const relationshipId = rels[1];
+        const adminRelatedTables = getProp(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables");
+        const relatedTables = layer.relationships || adminRelatedTables;
         /* istanbul ignore else */
         if (relatedTables && relatedTables.length > parseInt(relationshipId, 10)) {
-            var relatedTable = relatedTables[relationshipId];
+            const relatedTable = relatedTables[relationshipId];
             // the layers relationships stores the property as relatedTableId
             // the layers adminLayerInfo relatedTables stores the property as sourceLayerId
-            var prop = getProp(relatedTable, "relatedTableId")
+            const prop = getProp(relatedTable, "relatedTableId")
                 ? "relatedTableId"
                 : "sourceLayerId";
-            var _basePath = itemID + ".layer" + relatedTable[prop] + ".fields";
+            const _basePath = itemID + ".layer" + relatedTable[prop] + ".fields";
             rels[2] = _templatize(_basePath, rels[2], "name");
             name = rels.join("/");
         }
@@ -1768,8 +1796,8 @@ export function _templatizeFieldName(name, layer, itemID, basePath) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizeExpressionInfos(expressionInfos, fieldNames, basePath) {
-    return expressionInfos.map(function (i) {
-        fieldNames.forEach(function (name) {
+    return expressionInfos.map((i) => {
+        fieldNames.forEach(name => {
             i.expression = _templatizeArcadeExpressions(i.expression, name, basePath);
         });
         return i;
@@ -1785,7 +1813,7 @@ export function _templatizeExpressionInfos(expressionInfos, fieldNames, basePath
  * @param fieldNames array of field names
  */
 export function _templatizePopupElements(popupElelments, basePath, layer, itemID, fieldNames) {
-    popupElelments.forEach(function (pe) {
+    popupElelments.forEach((pe) => {
         if (pe.hasOwnProperty("fieldInfos")) {
             _templatizePopupInfoFieldInfos(pe.fieldInfos, layer, itemID, basePath);
         }
@@ -1805,16 +1833,14 @@ export function _templatizePopupElements(popupElelments, basePath, layer, itemID
  */
 export function _templatizeMediaInfos(mediaInfos, fieldNames, basePath, layer, itemId) {
     // templatize various properties of mediaInfos
-    var props = ["title", "caption"];
-    props.forEach(function (p) { return _templatizeName(mediaInfos, p, fieldNames, basePath); });
-    mediaInfos.forEach(function (mi) {
+    const props = ["title", "caption"];
+    props.forEach(p => _templatizeName(mediaInfos, p, fieldNames, basePath));
+    mediaInfos.forEach((mi) => {
         /* istanbul ignore else */
         if (mi.hasOwnProperty("value")) {
-            var v = mi.value;
-            var vfields = v.fields || [];
-            v.fields = vfields.map(function (f) {
-                return _templatizeFieldName(f, layer, itemId, basePath);
-            });
+            const v = mi.value;
+            const vfields = v.fields || [];
+            v.fields = vfields.map(f => _templatizeFieldName(f, layer, itemId, basePath));
             if (v.hasOwnProperty("normalizeField")) {
                 _templatizeProperty(v, "normalizeField", basePath, "name");
             }
@@ -1834,15 +1860,15 @@ export function _templatizeMediaInfos(mediaInfos, fieldNames, basePath, layer, i
  */
 export function _templatizeDefinitionEditor(layer, basePath, fieldNames) {
     if (layer) {
-        var defEditor = layer.definitionEditor || {};
+        const defEditor = layer.definitionEditor || {};
         /* istanbul ignore else */
         if (defEditor) {
-            var inputs = defEditor.inputs;
+            const inputs = defEditor.inputs;
             if (inputs) {
-                inputs.forEach(function (i) {
+                inputs.forEach(i => {
                     /* istanbul ignore else */
                     if (i.parameters) {
-                        i.parameters.forEach(function (p) {
+                        i.parameters.forEach((p) => {
                             _templatizeProperty(p, "fieldName", basePath, "name");
                         });
                     }
@@ -1874,9 +1900,9 @@ export function _templatizeDefinitionExpression(layer, basePath, fieldNames) {
  * @param fieldNames array of the layers field names
  */
 export function _templatizeSimpleName(expression, basePath, fieldNames, suffix) {
-    fieldNames.forEach(function (name) {
+    fieldNames.forEach(name => {
         // look for the name but not if its followed by }}
-        var regEx = new RegExp("\\b" + name + "\\b(?![}]{2})", "gm");
+        const regEx = new RegExp("\\b" + name + "\\b(?![}]{2})", "gm");
         if (expression && regEx.test(expression)) {
             expression = expression.replace(regEx, _templatize(basePath, name, suffix));
         }
@@ -1892,13 +1918,13 @@ export function _templatizeSimpleName(expression, basePath, fieldNames, suffix)
  */
 export function _templatizeDrawingInfo(layer, basePath, fieldNames) {
     if (layer) {
-        var drawingInfo = layer.drawingInfo;
+        const drawingInfo = layer.drawingInfo;
         if (drawingInfo) {
             // templatize the renderer fields
-            var renderer = drawingInfo.renderer || {};
+            const renderer = drawingInfo.renderer || {};
             _templatizeRenderer(renderer, basePath, fieldNames);
             // templatize the labelingInfo
-            var labelingInfo = drawingInfo.labelingInfo || [];
+            const labelingInfo = drawingInfo.labelingInfo || [];
             _templatizeLabelingInfo(labelingInfo, basePath, fieldNames);
         }
     }
@@ -1937,39 +1963,37 @@ export function _templatizeGenRenderer(renderer, basePath, fieldNames) {
     /* istanbul ignore else */
     if (renderer) {
         // update authoringInfo
-        var authoringInfo = renderer.authoringInfo;
+        const authoringInfo = renderer.authoringInfo;
         if (authoringInfo) {
             _templatizeAuthoringInfo(authoringInfo, basePath, fieldNames);
         }
-        var props_1 = ["field", "normalizationField"];
-        props_1.forEach(function (p) { return _templatizeProperty(renderer, p, basePath, "name"); });
-        var fieldNameProps = ["field1", "field2", "field3"];
-        fieldNameProps.forEach(function (fnP) {
-            return _templatizeProperty(renderer, fnP, basePath, "name");
-        });
+        const props = ["field", "normalizationField"];
+        props.forEach(p => _templatizeProperty(renderer, p, basePath, "name"));
+        const fieldNameProps = ["field1", "field2", "field3"];
+        fieldNameProps.forEach(fnP => _templatizeProperty(renderer, fnP, basePath, "name"));
         // When an attribute name is specified, it's enclosed in square brackets
-        var rExp_1 = renderer.rotationExpression;
-        if (rExp_1) {
-            fieldNames.forEach(function (name) {
-                var regEx = new RegExp("(\\[" + name + "\\])", "gm");
-                if (regEx.test(rExp_1)) {
-                    renderer.rotationExpression = rExp_1.replace(regEx, "[" + _templatize(basePath, name, "name") + "]");
+        const rExp = renderer.rotationExpression;
+        if (rExp) {
+            fieldNames.forEach(name => {
+                const regEx = new RegExp("(\\[" + name + "\\])", "gm");
+                if (regEx.test(rExp)) {
+                    renderer.rotationExpression = rExp.replace(regEx, "[" + _templatize(basePath, name, "name") + "]");
                 }
             });
         }
         // update valueExpression
         if (renderer.valueExpression) {
-            fieldNames.forEach(function (name) {
+            fieldNames.forEach(name => {
                 renderer.valueExpression = _templatizeArcadeExpressions(renderer.valueExpression, name, basePath);
             });
         }
         // update visualVariables
-        var visualVariables = renderer.visualVariables;
+        const visualVariables = renderer.visualVariables;
         if (visualVariables) {
-            visualVariables.forEach(function (v) {
-                props_1.forEach(function (p) { return _templatizeProperty(v, p, basePath, "name"); });
+            visualVariables.forEach(v => {
+                props.forEach(p => _templatizeProperty(v, p, basePath, "name"));
                 if (v.valueExpression) {
-                    fieldNames.forEach(function (name) {
+                    fieldNames.forEach(name => {
                         v.valueExpression = _templatizeArcadeExpressions(v.valueExpression, name, basePath);
                     });
                 }
@@ -1985,12 +2009,12 @@ export function _templatizeGenRenderer(renderer, basePath, fieldNames) {
  * @param fieldNames array of field names that will be used to search expressions
  */
 export function _templatizeTemporalRenderer(renderer, basePath, fieldNames) {
-    var renderers = [
+    const renderers = [
         renderer.latestObservationRenderer,
         renderer.observationRenderer,
         renderer.trackRenderer
     ];
-    renderers.forEach(function (r) {
+    renderers.forEach(r => {
         _templatizeRenderer(r, basePath, fieldNames);
     });
 }
@@ -2004,22 +2028,22 @@ export function _templatizeTemporalRenderer(renderer, basePath, fieldNames) {
 export function _templatizeAuthoringInfo(authoringInfo, basePath, fieldNames) {
     /* istanbul ignore else */
     if (authoringInfo) {
-        var props = ["field", "normalizationField"];
-        var field1_1 = authoringInfo.field1;
-        props.forEach(function (p) { return _templatizeProperty(field1_1, p, basePath, "name"); });
-        var field2_1 = authoringInfo.field2;
-        props.forEach(function (p) { return _templatizeProperty(field2_1, p, basePath, "name"); });
-        var fields = authoringInfo.fields;
+        const props = ["field", "normalizationField"];
+        const field1 = authoringInfo.field1;
+        props.forEach(p => _templatizeProperty(field1, p, basePath, "name"));
+        const field2 = authoringInfo.field2;
+        props.forEach(p => _templatizeProperty(field2, p, basePath, "name"));
+        const fields = authoringInfo.fields;
         if (fields) {
-            authoringInfo.fields = fields.map(function (f) { return _templatize(basePath, f, "name"); });
+            authoringInfo.fields = fields.map(f => _templatize(basePath, f, "name"));
         }
-        var vProps = ["endTime", "field", "startTime"];
-        var vVars_1 = authoringInfo.visualVariables;
-        if (vVars_1) {
-            vProps.forEach(function (p) {
+        const vProps = ["endTime", "field", "startTime"];
+        const vVars = authoringInfo.visualVariables;
+        if (vVars) {
+            vProps.forEach(p => {
                 // endTime and startTime may or may not be a field name
-                if (fieldNames.indexOf(vVars_1[p]) > -1) {
-                    _templatizeProperty(vVars_1, p, basePath, "name");
+                if (fieldNames.indexOf(vVars[p]) > -1) {
+                    _templatizeProperty(vVars, p, basePath, "name");
                 }
             });
         }
@@ -2033,12 +2057,12 @@ export function _templatizeAuthoringInfo(authoringInfo, basePath, fieldNames) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizeArcadeExpressions(text, fieldName, basePath) {
-    var t = _templatize(basePath, fieldName, "name");
+    const t = _templatize(basePath, fieldName, "name");
     if (text) {
         // test for $feature. notation
         // captures VOTED_DEM_2012 from $feature.VOTED_DEM_2012
-        var exp = "(?:\\$feature\\.)(" + fieldName + ")\\b";
-        var regEx = new RegExp(exp, "gm");
+        let exp = "(?:\\$feature\\.)(" + fieldName + ")\\b";
+        let regEx = new RegExp(exp, "gm");
         text = regEx.test(text) ? text.replace(regEx, "$feature." + t) : text;
         // test for $feature[] notation
         // captures VOTED_DEM_2012 from $feature["VOTED_DEM_2012"]
@@ -2046,7 +2070,7 @@ export function _templatizeArcadeExpressions(text, fieldName, basePath) {
         // captures VOTED_DEM_2012 from $feature[VOTED_DEM_2012]
         exp = "(?:[$]feature)(\\[\\\"?\\'?)" + fieldName + "(\\\"?\\'?\\])";
         regEx = new RegExp(exp, "gm");
-        var result = regEx.exec(text);
+        let result = regEx.exec(text);
         if (result) {
             text = text.replace(regEx, "$feature" + result[1] + t + result[2]);
         }
@@ -2080,29 +2104,27 @@ export function _templatizeArcadeExpressions(text, fieldName, basePath) {
  * @param fieldNames array of the layers field names
  */
 export function _templatizeLabelingInfo(labelingInfo, basePath, fieldNames) {
-    labelingInfo.forEach(function (li) {
+    labelingInfo.forEach((li) => {
         /* istanbul ignore else */
         if (li.hasOwnProperty("fieldInfos")) {
-            var fieldInfos = li.fieldInfos || [];
-            fieldInfos.forEach(function (fi) {
-                return _templatizeProperty(fi, "fieldName", basePath, "name");
-            });
+            const fieldInfos = li.fieldInfos || [];
+            fieldInfos.forEach(fi => _templatizeProperty(fi, "fieldName", basePath, "name"));
         }
-        var labelExp = li.labelExpression || "";
-        var labelExpInfo = li.labelExpressionInfo || {};
-        fieldNames.forEach(function (n) {
-            var t = _templatize(basePath, n, "name");
+        const labelExp = li.labelExpression || "";
+        const labelExpInfo = li.labelExpressionInfo || {};
+        fieldNames.forEach(n => {
+            const t = _templatize(basePath, n, "name");
             // check for [fieldName] or ["fieldName"]
-            var regExBracket = new RegExp('(\\[\\"*)+(' + n + ')(\\"*\\])+', "gm");
-            var result = regExBracket.exec(labelExp);
+            const regExBracket = new RegExp('(\\[\\"*)+(' + n + ')(\\"*\\])+', "gm");
+            let result = regExBracket.exec(labelExp);
             if (result) {
                 li.labelExpression = labelExp.replace(regExBracket, result[1] + t + result[3]);
             }
             /* istanbul ignore else */
             if (labelExpInfo.value) {
-                var v = labelExpInfo.value;
+                let v = labelExpInfo.value;
                 // check for {fieldName}
-                var regExCurly = new RegExp("(\\{" + n + "\\})", "gm");
+                const regExCurly = new RegExp("(\\{" + n + "\\})", "gm");
                 v = regExCurly.test(v) ? v.replace(regExCurly, "{" + t + "}") : v;
                 // check for [fieldName] or ["fieldName"]
                 result = regExBracket.exec(v);
@@ -2123,10 +2145,10 @@ export function _templatizeLabelingInfo(labelingInfo, basePath, fieldNames) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizeTemplates(layer, basePath) {
-    var templates = layer.templates || [];
-    templates.forEach(function (t) {
-        var attributes = getProp(t, "prototype.attributes");
-        var _attributes = _templatizeKeys(attributes, basePath, "name");
+    const templates = layer.templates || [];
+    templates.forEach(t => {
+        const attributes = getProp(t, "prototype.attributes");
+        const _attributes = _templatizeKeys(attributes, basePath, "name");
         /* istanbul ignore else */
         if (_attributes) {
             t.prototype.attributes = _attributes;
@@ -2140,20 +2162,20 @@ export function _templatizeTemplates(layer, basePath) {
  * @param basePath path used to de-templatize while deploying
  */
 export function _templatizeTypeTemplates(layer, basePath) {
-    var types = layer.types;
+    const types = layer.types;
     if (types && Array.isArray(types) && types.length > 0) {
-        types.forEach(function (type) {
-            var domains = _templatizeKeys(type.domains, basePath, "name");
+        types.forEach((type) => {
+            const domains = _templatizeKeys(type.domains, basePath, "name");
             /* istanbul ignore else */
             if (domains) {
                 type.domains = domains;
             }
-            var templates = type.templates;
+            const templates = type.templates;
             /* istanbul ignore else */
             if (templates && templates.length > 0) {
-                templates.forEach(function (t) {
-                    var attributes = getProp(t, "prototype.attributes");
-                    var _attributes = _templatizeKeys(attributes, basePath, "name");
+                templates.forEach((t) => {
+                    const attributes = getProp(t, "prototype.attributes");
+                    const _attributes = _templatizeKeys(attributes, basePath, "name");
                     /* istanbul ignore else */
                     if (_attributes) {
                         t.prototype.attributes = _attributes;
@@ -2171,14 +2193,14 @@ export function _templatizeTypeTemplates(layer, basePath) {
  * @param suffix expected suffix for template variable
  */
 export function _templatizeKeys(obj, basePath, suffix) {
-    var _obj;
+    let _obj;
     /* istanbul ignore else */
     if (obj) {
         _obj = {};
-        var objKeys = Object.keys(obj);
+        const objKeys = Object.keys(obj);
         /* istanbul ignore else */
         if (objKeys && objKeys.length > 0) {
-            objKeys.forEach(function (k) {
+            objKeys.forEach(k => {
                 _obj[_templatize(basePath, k, suffix)] = obj[k];
             });
         }
@@ -2193,18 +2215,18 @@ export function _templatizeKeys(obj, basePath, suffix) {
  */
 export function _templatizeTimeInfo(layer, basePath) {
     if (layer.timeInfo) {
-        var timeInfo_1 = layer.timeInfo;
-        var timeProps = [
+        const timeInfo = layer.timeInfo;
+        const timeProps = [
             "endTimeField",
             "startTimeField",
             "trackIdField"
         ];
-        timeProps.forEach(function (t) {
-            if (timeInfo_1[t] !== "") {
-                _templatizeProperty(timeInfo_1, t, basePath, "name");
+        timeProps.forEach(t => {
+            if (timeInfo[t] !== "") {
+                _templatizeProperty(timeInfo, t, basePath, "name");
             }
             else {
-                timeInfo_1[t] = null;
+                timeInfo[t] = null;
             }
         });
     }
@@ -2234,16 +2256,16 @@ export function _templatizeDefinitionQuery(layer, basePath, fieldNames) {
  */
 export function _getNameMapping(fieldInfos, id) {
     // create name mapping
-    var fInfo = fieldInfos[id];
-    var nameMapping = {};
-    var newFields = fInfo.newFields;
-    var newFieldNames = newFields
-        ? newFields.map(function (f) { return f.name; })
+    const fInfo = fieldInfos[id];
+    const nameMapping = {};
+    const newFields = fInfo.newFields;
+    const newFieldNames = newFields
+        ? newFields.map((f) => f.name)
         : [];
-    var sourceFields = fInfo.sourceFields || [];
-    sourceFields.forEach(function (field) {
-        var lName = String(field.name).toLowerCase();
-        newFields.forEach(function (f) {
+    const sourceFields = fInfo.sourceFields || [];
+    sourceFields.forEach((field) => {
+        const lName = String(field.name).toLowerCase();
+        newFields.forEach((f) => {
             // Names can change more than case
             if (newFieldNames.indexOf(field.name) === -1 &&
                 newFieldNames.indexOf(lName) === -1) {
@@ -2267,13 +2289,13 @@ export function _getNameMapping(fieldInfos, id) {
     });
     // update for editFieldsInfo
     if (fInfo.editFieldsInfo && fInfo.newEditFieldsInfo) {
-        var efi_1 = JSON.parse(JSON.stringify(fInfo.editFieldsInfo));
-        var newEfi_1 = JSON.parse(JSON.stringify(fInfo.newEditFieldsInfo));
-        var nameMappingKeys_1 = Object.keys(nameMapping);
-        Object.keys(efi_1).forEach(function (k) {
-            var lowerEfi = String(efi_1[k]).toLowerCase();
-            if ((nameMappingKeys_1.indexOf(lowerEfi) === -1 ||
-                nameMapping[lowerEfi].name !== newEfi_1[k]) &&
+        const efi = JSON.parse(JSON.stringify(fInfo.editFieldsInfo));
+        const newEfi = JSON.parse(JSON.stringify(fInfo.newEditFieldsInfo));
+        const nameMappingKeys = Object.keys(nameMapping);
+        Object.keys(efi).forEach(k => {
+            const lowerEfi = String(efi[k]).toLowerCase();
+            if ((nameMappingKeys.indexOf(lowerEfi) === -1 ||
+                nameMapping[lowerEfi].name !== newEfi[k]) &&
                 newFieldNames.indexOf(lowerEfi) > -1) {
                 // Only add delete fields if source schema changes allowed
                 /* istanbul ignore else */
@@ -2287,17 +2309,17 @@ export function _getNameMapping(fieldInfos, id) {
                     fInfo.deleteFields.push(lowerEfi);
                 }
                 // editFieldsInfo only has the name and not the alias and type
-                var sourceEfiField_1;
-                fInfo.sourceFields.some(function (sf) {
-                    if (sf.name === efi_1[k]) {
-                        sourceEfiField_1 = sf;
+                let sourceEfiField;
+                fInfo.sourceFields.some((sf) => {
+                    if (sf.name === efi[k]) {
+                        sourceEfiField = sf;
                     }
-                    return sf.name === efi_1[k];
+                    return sf.name === efi[k];
                 });
                 nameMapping[lowerEfi] = {
-                    name: newEfi_1[k],
-                    alias: sourceEfiField_1 && sourceEfiField_1.alias ? sourceEfiField_1.alias : "",
-                    type: sourceEfiField_1 && sourceEfiField_1.type ? sourceEfiField_1.type : ""
+                    name: newEfi[k],
+                    alias: sourceEfiField && sourceEfiField.alias ? sourceEfiField.alias : "",
+                    type: sourceEfiField && sourceEfiField.type ? sourceEfiField.type : ""
                 };
             }
         });
@@ -2308,4 +2330,12 @@ export function _getNameMapping(fieldInfos, id) {
     }
     return nameMapping;
 }
+/**
+ * Helper function to ensure same chunk size value is used in multiple locations
+ *
+ * @return a number that represents how many layers should be included per addToDef call
+ */
+export function _getLayerChunkSize() {
+    return 20;
+}
 //# sourceMappingURL=featureServiceHelpers.js.map