@esri/solution-common 5.2.3 → 5.2.5

package/dist/cjs/featureServiceHelpers.js

@@ -0,0 +1,2438 @@
+"use strict";
+/** @license
+ * Copyright 2019 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._templatizeAdminLayerInfo = exports._templatizeLayerFieldReferences = exports._validateEditFieldsInfo = exports._validateTypesTemplates = exports._validateTemplatesFields = exports._validateIndexes = exports._validateDisplayField = exports._validateFields = exports._templatizeLayer = exports._templatizeProperty = exports._templatize = exports.updatePopupInfo = exports.postProcessFields = exports.updateLayerFieldReferences = exports.validateSpatialReferenceAndExtent = exports.setDefaultSpatialReference = exports._updateTemplateDictionaryFields = exports._updateGeomFieldName = exports._updateSourceLayerFields = exports._updateItemFields = exports._getDynamicFieldNames = exports._getFieldNames = exports._updateForPortal = exports.removeLayerOptimization = exports._isSelfReferential = exports._updateAddOptions = exports._updateOrder = exports.addFeatureServiceDefinition = exports.addFeatureServiceLayersAndTables = exports.getExistingLayersAndTables = exports.getLayersAndTables = exports.deTemplatizeFieldInfos = exports.processContingentValues = exports.updateTemplateForInvalidDesignations = exports.updateSettingsFieldInfos = exports.setNamesAndTitles = exports.getLayerSettings = exports._updateTypeKeywords = exports.updateTemplate = exports.cacheLayerInfo = exports._cachePopupInfo = exports.cachePopupInfos = exports._cacheFieldInfo = exports.cacheContingentValues = exports.cacheFieldInfos = exports.deleteViewProps = exports.templatize = exports.getFeatureServiceRelatedRecords = exports.rest_addFeatures = exports.rest_queryFeatures = void 0;
+exports._getLayerChunkSize = exports._getNameMapping = exports._templatizeDefinitionQuery = exports._templatizeTimeInfo = exports._templatizeKeys = exports._templatizeTypeTemplates = exports._templatizeTemplates = exports._templatizeLabelingInfo = exports._templatizeArcadeExpressions = exports._templatizeAuthoringInfo = exports._templatizeTemporalRenderer = exports._templatizeGenRenderer = exports._templatizeRenderer = exports._templatizeDrawingInfo = exports._templatizeSimpleName = exports._templatizeDefinitionExpression = exports._templatizeDefinitionEditor = exports._templatizeMediaInfos = exports._templatizePopupElements = exports._templatizeExpressionInfos = exports._templatizeFieldName = exports._templatizePopupInfoFieldInfos = exports._templatizeName = exports._templatizePopupInfo = exports._templatizeRelationshipFields = exports._templatizeTopFilter = exports._templatizeAdminSourceLayerFields = exports._getDependantItemId = exports._templatizeAdminLayerInfoFields = exports._templatizeSourceServiceName = exports._processAdminObject = void 0;
+/**
+ * Provides general helper functions.
+ *
+ * @module featureServiceHelpers
+ */
+// ------------------------------------------------------------------------------------------------------------------ //
+var arcgis_rest_feature_layer_1 = require("@esri/arcgis-rest-feature-layer");
+Object.defineProperty(exports, "rest_queryFeatures", { enumerable: true, get: function () { return arcgis_rest_feature_layer_1.queryFeatures; } });
+Object.defineProperty(exports, "rest_addFeatures", { enumerable: true, get: function () { return arcgis_rest_feature_layer_1.addFeatures; } });
+//#region Imports -------------------------------------------------------------------------------------------------------//
+const interfaces_1 = require("./interfaces");
+const generalHelpers_1 = require("./generalHelpers");
+const templatization_1 = require("./templatization");
+const restHelpers_1 = require("./restHelpers");
+const trackingHelpers_1 = require("./trackingHelpers");
+const arcgis_rest_feature_layer_2 = require("@esri/arcgis-rest-feature-layer");
+//#endregion ------------------------------------------------------------------------------------------------------------//
+//#region Public functions ----------------------------------------------------------------------------------------------//
+/**
+ * Get the related records for a feature service.
+ *
+ * @param url Feature service's URL, e.g., layer.url
+ * @param relationshipId Id of relationship
+ * @param objectIds Objects in the feature service whose related records are sought
+ */
+function getFeatureServiceRelatedRecords(url, relationshipId, objectIds) {
+    const options = {
+        url: url + `/${relationshipId}`,
+        relationshipId,
+        objectIds
+    };
+    return (0, arcgis_rest_feature_layer_2.queryRelated)(options);
+}
+exports.getFeatureServiceRelatedRecords = getFeatureServiceRelatedRecords;
+/**
+ * Templatize the ID, url, field references ect
+ *
+ * @param itemTemplate Template for feature service item
+ * @param dependencies Array of IDependency for name mapping
+ * @param templatizeFieldReferences Templatize all field references within a layer
+ * @param templateDictionary Hash mapping property names to replacement values
+ * @returns A promise that will resolve when template has been updated
+ * @private
+ */
+function templatize(itemTemplate, dependencies, templatizeFieldReferences, templateDictionary) {
+    templateDictionary = templateDictionary || {};
+    // Common templatizations
+    const id = itemTemplate.item.id;
+    const fsUrl = itemTemplate.item.url;
+    itemTemplate.item = {
+        ...itemTemplate.item,
+        id: (0, templatization_1.templatizeTerm)(id, id, ".itemId"),
+        url: _templatize(id, "url"),
+        typeKeywords: (0, templatization_1.templatizeIds)(itemTemplate.item.typeKeywords)
+    };
+    // special handeling if we are dealing with a tracker view
+    (0, trackingHelpers_1.templatizeTracker)(itemTemplate);
+    // added for issue #928
+    (0, generalHelpers_1.deleteProp)(itemTemplate, "properties.service.size");
+    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(layer => {
+        templateDictionary[fsUrl + "/" + layer.id] = _templatize(id, "layer" + layer.id + ".url");
+    });
+    // templatize the service references serviceItemId
+    itemTemplate.properties.service.serviceItemId = (0, templatization_1.templatizeTerm)(itemTemplate.properties.service.serviceItemId, itemTemplate.properties.service.serviceItemId, ".itemId");
+    const initialExtent = (0, generalHelpers_1.getProp)(itemTemplate, "properties.service.initialExtent");
+    /* istanbul ignore else */
+    if (initialExtent) {
+        itemTemplate.properties.service.initialExtent = (0, templatization_1.templatizeTerm)(id, id, ".solutionExtent");
+    }
+    const fullExtent = (0, generalHelpers_1.getProp)(itemTemplate, "properties.service.fullExtent");
+    /* istanbul ignore else */
+    if (fullExtent) {
+        itemTemplate.properties.service.fullExtent = (0, templatization_1.templatizeTerm)(id, id, ".solutionExtent");
+    }
+    // this default extent will be used in cases where it does not make sense to apply the orgs
+    // extent to a service with a local spatial reference
+    itemTemplate.properties.defaultExtent = initialExtent || fullExtent;
+    // in some cases a service does not have a spatial reference defined
+    // added for issue #699
+    if (!(0, generalHelpers_1.getProp)(itemTemplate, "properties.service.spatialReference") &&
+        (0, generalHelpers_1.getProp)(itemTemplate, "properties.defaultExtent.spatialReference")) {
+        (0, generalHelpers_1.setCreateProp)(itemTemplate, "properties.service.spatialReference", itemTemplate.properties.defaultExtent.spatialReference);
+    }
+    // if any layer hasZ enabled then we need to set
+    // enableZDefaults and zDefault to deploy to enterprise
+    let hasZ = false;
+    jsonItems.forEach((jsonItem) => {
+        // get the source service json for the given data item
+        const matchingItems = _items.filter(item => {
+            return jsonItem.id === item.id;
+        });
+        // templatize the source service json
+        const _item = matchingItems.length === 1 ? matchingItems[0] : undefined;
+        _templatizeLayer(_item, jsonItem, itemTemplate, dependencies, templatizeFieldReferences, templateDictionary);
+        hasZ = jsonItem.hasZ || (_item && _item.hasZ) ? true : hasZ;
+    });
+    if (hasZ) {
+        itemTemplate.properties.service.enableZDefaults = true;
+        itemTemplate.properties.service.zDefault = 0;
+    }
+    return itemTemplate;
+}
+exports.templatize = templatize;
+/**
+ * Delete key properties that are system managed
+ *
+ * @param layer The data layer instance with field name references within
+ */
+function deleteViewProps(layer) {
+    const props = ["definitionQuery"];
+    props.forEach(prop => {
+        (0, generalHelpers_1.deleteProp)(layer, prop);
+    });
+}
+exports.deleteViewProps = deleteViewProps;
+/**
+ * Cache properties that contain field references
+ *
+ * removeProp added for issue #644
+ * setting all props on add for online now
+ * investigating if we can also just allow them to be set during add for portal
+ *
+ * @param layer The data layer instance with field name references within
+ * @param fieldInfos the object that stores the cached field infos
+ * @returns An updated instance of the fieldInfos
+ */
+function cacheFieldInfos(layer, fieldInfos) {
+    // cache the source fields as they are in the original source
+    if (layer && layer.fields) {
+        fieldInfos[layer.id] = {
+            sourceFields: JSON.parse(JSON.stringify(layer.fields)),
+            type: layer.type,
+            id: layer.id
+        };
+    }
+    // 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
+    const props = {
+        editFieldsInfo: false,
+        types: false,
+        templates: false,
+        relationships: true,
+        drawingInfo: false,
+        timeInfo: false,
+        viewDefinitionQuery: false
+    };
+    Object.keys(props).forEach(k => {
+        _cacheFieldInfo(layer, k, fieldInfos, props[k]);
+    });
+    return fieldInfos;
+}
+exports.cacheFieldInfos = cacheFieldInfos;
+/**
+ * Cache the stored contingent values so we can add them in subsequent addToDef calls
+ *
+ * @param id The layer id for the associated values to be stored with
+ * @param fieldInfos The object that stores the cached field infos
+ * @param itemTemplate The current itemTemplate being processed
+ * @returns An updated instance of the fieldInfos
+ */
+function cacheContingentValues(id, fieldInfos, itemTemplate) {
+    const contingentValues = (0, generalHelpers_1.getProp)(itemTemplate, 'properties.contingentValues');
+    if (contingentValues && contingentValues[id]) {
+        fieldInfos[id]['contingentValues'] = contingentValues[id];
+    }
+    return fieldInfos;
+}
+exports.cacheContingentValues = cacheContingentValues;
+/**
+ * Helper function to cache a single property into the fieldInfos object
+ * This property will be removed from the layer instance.
+ *
+ * @param layer the data layer being cloned
+ * @param prop the property name used to cache
+ * @param fieldInfos the object that will store the cached property
+ * @private
+ */
+function _cacheFieldInfo(layer, prop, fieldInfos, removeProp) {
+    /* istanbul ignore else */
+    if (layer &&
+        layer.hasOwnProperty(prop) &&
+        fieldInfos &&
+        fieldInfos.hasOwnProperty(layer.id)) {
+        fieldInfos[layer.id][prop] = layer[prop];
+        // editFieldsInfo does not come through unless its with the layer
+        // when it's being added
+        /* istanbul ignore else */
+        if (removeProp) {
+            layer[prop] = null;
+        }
+    }
+}
+exports._cacheFieldInfo = _cacheFieldInfo;
+/**
+ * Cache popup info that can contain field references
+ *
+ * @param data The items data property
+ * @returns An updated instance of the popupInfos
+ */
+function cachePopupInfos(data) {
+    // store any popupInfo so we can update after any potential name changes
+    const popupInfos = {
+        layers: {},
+        tables: {}
+    };
+    if (data && data.layers && data.layers.length > 0) {
+        _cachePopupInfo(popupInfos, "layers", data.layers);
+    }
+    if (data && data.tables && data.tables.length > 0) {
+        _cachePopupInfo(popupInfos, "tables", data.tables);
+    }
+    return popupInfos;
+}
+exports.cachePopupInfos = cachePopupInfos;
+/**
+ * Helper function to cache a single popupInfo
+ * This property will be reset on the layer
+ *
+ * @param popupInfos object to store the cahced popupInfo
+ * @param type is it a layer or table
+ * @param _items list or either layers or tables
+ * @private
+ */
+function _cachePopupInfo(popupInfos, type, _items) {
+    _items.forEach((item) => {
+        if (item && item.hasOwnProperty("popupInfo")) {
+            popupInfos[type][item.id] = item.popupInfo;
+            item.popupInfo = {};
+        }
+    });
+}
+exports._cachePopupInfo = _cachePopupInfo;
+/**
+ * Store basic layer information for potential replacement if we are unable to access a given service
+ * added for issue #859
+ *
+ * @param layerId the id for the layer
+ * @param itemId the id for the item
+ * @param url the url for the layer
+ * @param templateDictionary Hash of key details used for variable replacement
+ * @returns templatized itemTemplate
+ */
+function cacheLayerInfo(layerId, itemId, url, templateDictionary) {
+    if (layerId) {
+        const layerIdVar = `layer${layerId}`;
+        // need to structure these differently so they are not used for standard replacement calls
+        // this now adds additional vars that are not needing replacement unless we fail to fetch the service
+        const newVars = (0, generalHelpers_1.getProp)(templateDictionary, `${interfaces_1.UNREACHABLE}.${itemId}`) || {
+            itemId
+        };
+        newVars[layerIdVar] = (0, generalHelpers_1.getProp)(newVars, layerIdVar) || {
+            layerId,
+            itemId
+        };
+        if (url !== "") {
+            newVars[layerIdVar]["url"] = url;
+        }
+        const unreachableVars = {};
+        unreachableVars[itemId] = newVars;
+        templateDictionary[interfaces_1.UNREACHABLE] = {
+            ...templateDictionary[interfaces_1.UNREACHABLE],
+            ...unreachableVars
+        };
+    }
+}
+exports.cacheLayerInfo = cacheLayerInfo;
+/**
+ * Creates an item in a specified folder (except for Group item type).
+ *
+ * @param itemTemplate Item to be created; n.b.: this item is modified
+ * @param templateDictionary Hash mapping property names to replacement values
+ * @param createResponse Response from create service
+ * @returns An updated instance of the template
+ * @private
+ */
+function updateTemplate(itemTemplate, templateDictionary, createResponse) {
+    // Update the item with any typeKeywords that were added on create
+    _updateTypeKeywords(itemTemplate, createResponse);
+    // Add the new item to the template dictionary
+    templateDictionary[itemTemplate.itemId] = Object.assign(templateDictionary[itemTemplate.itemId] || {}, {
+        itemId: createResponse.serviceItemId,
+        url: (0, generalHelpers_1.checkUrlPathTermination)(createResponse.serviceurl),
+        name: createResponse.name
+    });
+    // Update the item template now that the new service has been created
+    itemTemplate.itemId = createResponse.serviceItemId;
+    return (0, templatization_1.replaceInTemplate)(itemTemplate, templateDictionary);
+}
+exports.updateTemplate = updateTemplate;
+/**
+ * Updates the items typeKeywords to include any typeKeywords that
+ * were added by the create service request
+ *
+ * @param itemTemplate Item to be created; n.b.: this item is modified
+ * @param createResponse Response from create service
+ * @returns An updated instance of the template
+ * @private
+ */
+function _updateTypeKeywords(itemTemplate, createResponse) {
+    // https://github.com/Esri/solution.js/issues/589
+    const iKwords = (0, generalHelpers_1.getProp)(itemTemplate, "item.typeKeywords");
+    const cKwords = (0, generalHelpers_1.getProp)(createResponse, "typeKeywords");
+    if (iKwords && cKwords) {
+        (0, generalHelpers_1.setProp)(itemTemplate, "item.typeKeywords", iKwords.concat(cKwords.filter(k => iKwords.indexOf(k) < 0)));
+    }
+    return itemTemplate;
+}
+exports._updateTypeKeywords = _updateTypeKeywords;
+/**
+ * Create the name mapping object that will allow for all templatized field
+ * references to be de-templatized.
+ * This also removes the stored sourceFields and newFields arrays from fieldInfos.
+ *
+ * @example
+ * \{ layer0: \{ fields: \{ lowerCaseSourceFieldName: newFieldNameAfterDeployment \} \} \}
+ *
+ * @param layerInfos The object that stores the cached layer properties and name mapping
+ * @returns The settings object that will be used to de-templatize the field references.
+ */
+function getLayerSettings(layerInfos, url, itemId, enterpriseIDMapping) {
+    const settings = {};
+    const ids = Object.keys(layerInfos);
+    ids.forEach((id) => {
+        const _layerId = (0, generalHelpers_1.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}`] = {
+            fields: _getNameMapping(layerInfos, id),
+            url: (0, generalHelpers_1.checkUrlPathTermination)(url) + layerId,
+            layerId,
+            itemId
+        };
+        (0, generalHelpers_1.deleteProp)(layerInfos[id], "newFields");
+        (0, generalHelpers_1.deleteProp)(layerInfos[id], "sourceFields");
+    });
+    return settings;
+}
+exports.getLayerSettings = getLayerSettings;
+/**
+ * Set the names and titles for all feature services.
+ *
+ * This function will ensure that we have unique feature service names.
+ * The feature service name will have the solution item id appended.
+ *
+ * @param templates A collection of AGO item templates.
+ * @param solutionItemId The item id for the deployed solution item.
+ * @returns An updated collection of AGO templates with unique feature service names.
+ */
+function setNamesAndTitles(templates, solutionItemId) {
+    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;
+            /* istanbul ignore else */
+            if (!(0, trackingHelpers_1.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;
+    });
+}
+exports.setNamesAndTitles = setNamesAndTitles;
+/**
+ * This is used when deploying views.
+ * We need to update fields referenced in adminLayerInfo for relationships prior to deploying the view.
+ * This moves the fieldInfos for the views source layers from the item settings for the source layer
+ * to the item settings for the view.
+ *
+ * @param itemTemplate The current itemTemplate being processed.
+ * @param settings The settings object used to de-templatize the various templates within the item.
+ */
+function updateSettingsFieldInfos(itemTemplate, settings) {
+    const dependencies = itemTemplate.dependencies;
+    const id = itemTemplate.itemId;
+    const settingsKeys = Object.keys(settings);
+    settingsKeys.forEach((k) => {
+        if (id === settings[k].itemId) {
+            dependencies.forEach((d) => {
+                settingsKeys.forEach((_k) => {
+                    /* istanbul ignore else */
+                    if (d === _k) {
+                        // combine for multi-source views
+                        const fieldInfos = {};
+                        fieldInfos[d] = (0, generalHelpers_1.getProp)(settings[_k], "fieldInfos");
+                        settings[k]["sourceServiceFields"] = settings[k]["sourceServiceFields"]
+                            ? { ...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];
+                            }
+                        });
+                    }
+                });
+            });
+        }
+    });
+}
+exports.updateSettingsFieldInfos = updateSettingsFieldInfos;
+/**
+ * Add flag to indicate item should be ignored.
+ * Construct template dictionary to detemplatize any references to this item by other items.
+ *
+ * @param template Template for feature service item
+ * @param authentication Credentials for the request
+ * @returns A promise that will resolve when template has been updated
+ * @private
+ */
+function updateTemplateForInvalidDesignations(template, authentication) {
+    return new Promise((resolve, reject) => {
+        template.properties.hasInvalidDesignations = true;
+        if (template.item.url) {
+            // get the admin URL
+            const url = template.item.url;
+            (0, restHelpers_1.rest_request)(url + "?f=json", {
+                authentication: authentication
+            }).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;
+                    }
+                });
+                template.data[template.itemId] = Object.assign({
+                    itemId: template.itemId
+                }, getLayerSettings(layerInfos, url, template.itemId));
+                resolve(template);
+            }, e => reject((0, generalHelpers_1.fail)(e)));
+        }
+        else {
+            resolve(template);
+        }
+    });
+}
+exports.updateTemplateForInvalidDesignations = updateTemplateForInvalidDesignations;
+/**
+ * Get the contingent values for each layer in the service.
+ * Remove key props that cannot be included with the addToDef call on deploy.
+ * Store the values alongside other key feature service properties in the template
+ *
+ * @param properties the current feature services properties
+ * @param adminUrl the current feature service url
+ * @param authentication Credentials for the request to AGOL
+ * @returns A promise that will resolve when the contingent values have been fetched.
+ * This function will update the provided properties argument when contingent values are found.
+ */
+function processContingentValues(properties, adminUrl, authentication) {
+    return new Promise((resolve, reject) => {
+        if ((0, generalHelpers_1.getProp)(properties, 'service.isView')) {
+            // views will inherit from the source service
+            resolve();
+        }
+        else {
+            const layersAndTables = (properties.layers || []).concat(properties.tables || []);
+            const layerIds = [];
+            const contingentValuePromises = layersAndTables.reduce((prev, cur) => {
+                /* istanbul ignore else */
+                if (cur.hasContingentValuesDefinition) {
+                    prev.push((0, restHelpers_1.rest_request)(`${adminUrl}/${cur['id']}/contingentValues?f=json`, { authentication }));
+                    layerIds.push(cur['id']);
+                }
+                return prev;
+            }, []);
+            if (contingentValuePromises.length > 0) {
+                Promise.all(contingentValuePromises).then((results) => {
+                    const contingentValues = {};
+                    results.forEach((r, i) => {
+                        (0, generalHelpers_1.deleteProp)(r, 'typeCodes');
+                        /* istanbul ignore else */
+                        if ((0, generalHelpers_1.getProp)(r, 'stringDicts') && (0, generalHelpers_1.getProp)(r, 'contingentValuesDefinition')) {
+                            r.contingentValuesDefinition['stringDicts'] = r.stringDicts;
+                            (0, generalHelpers_1.deleteProp)(r, 'stringDicts');
+                        }
+                        (0, generalHelpers_1.deleteProps)((0, generalHelpers_1.getProp)(r, 'contingentValuesDefinition'), ['layerID', 'layerName', 'geometryType', 'hasSubType']);
+                        contingentValues[layerIds[i]] = r;
+                    });
+                    properties.contingentValues = contingentValues;
+                    resolve();
+                }, reject);
+            }
+            else {
+                resolve();
+            }
+        }
+    });
+}
+exports.processContingentValues = processContingentValues;
+/**
+ * Replace the field name reference templates with the new field names after deployment.
+ *
+ * @param fieldInfos The object that stores the cached layer properties and name mapping
+ * @param popupInfos The object from the popupInfo property for the layer
+ * @param adminLayerInfos The object from the adminLayerInfo property for the layer
+ * @param settings The settings object that has all of the mappings for de-templatizing.
+ * @returns An object that contains updated instances of popupInfos, fieldInfos, and adminLayerInfos
+ */
+function deTemplatizeFieldInfos(fieldInfos, popupInfos, adminLayerInfos, settings) {
+    const fieldInfoKeys = Object.keys(fieldInfos);
+    fieldInfoKeys.forEach(id => {
+        if (fieldInfos[id].hasOwnProperty("templates")) {
+            fieldInfos[id].templates = JSON.parse((0, templatization_1.replaceInTemplate)(JSON.stringify(fieldInfos[id].templates), settings));
+        }
+        if (fieldInfos[id].hasOwnProperty("adminLayerInfo")) {
+            adminLayerInfos[id].viewLayerDefinition.table.relatedTables =
+                fieldInfos[id].adminLayerInfo;
+            (0, generalHelpers_1.deleteProp)(fieldInfos[id], "adminLayerInfo");
+        }
+        if (fieldInfos[id].hasOwnProperty("types")) {
+            fieldInfos[id].types = JSON.parse((0, templatization_1.replaceInTemplate)(JSON.stringify(fieldInfos[id].types), settings));
+        }
+    });
+    return {
+        popupInfos: (0, templatization_1.replaceInTemplate)(popupInfos, settings),
+        fieldInfos: (0, templatization_1.replaceInTemplate)(fieldInfos, settings),
+        adminLayerInfos: (0, templatization_1.replaceInTemplate)(adminLayerInfos, settings)
+    };
+}
+exports.deTemplatizeFieldInfos = deTemplatizeFieldInfos;
+/**
+ * This is used when deploying views.
+ * We need to update fields referenced in adminLayerInfo for relationships prior to deploying the view.
+ * This moves the fieldInfos for the views source layers from the item settings for the source layer
+ * to the item settings for the view.
+ *
+ * @param itemTemplate The current itemTemplate being processed.
+ * @returns array of layers and tables
+ */
+function getLayersAndTables(itemTemplate) {
+    const properties = itemTemplate.properties;
+    const layersAndTables = [];
+    (properties.layers || []).forEach(function (layer) {
+        layersAndTables.push({
+            item: layer,
+            type: "layer"
+        });
+    });
+    (properties.tables || []).forEach(function (table) {
+        layersAndTables.push({
+            item: table,
+            type: "table"
+        });
+    });
+    return layersAndTables;
+}
+exports.getLayersAndTables = getLayersAndTables;
+/**
+ * Fetch each layer and table from service so we can determine what fields they have.
+ * This is leveraged when we are using existing services so we can determine if we need to
+ * remove any fields from views that depend on these layers and tables.
+ *
+ * @param url Feature service endpoint
+ * @param ids layer and table ids
+ * @param authentication Credentials for the request
+ * @returns A promise that will resolve an array of promises with either a failure or the data
+ * @private
+ */
+function getExistingLayersAndTables(url, ids, authentication) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    return new Promise(resolve => {
+        const defs = ids.map(id => {
+            return (0, restHelpers_1.rest_request)((0, generalHelpers_1.checkUrlPathTermination)(url) + id, {
+                authentication
+            });
+        });
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        Promise.all(defs.map(p => p.catch(e => e))).then(resolve);
+    });
+}
+exports.getExistingLayersAndTables = getExistingLayersAndTables;
+/**
+ * Adds the layers and tables of a feature service to it and restores their relationships.
+ *
+ * @param itemTemplate Feature service
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature
+ *            service)
+ * @param popupInfos the cached popup info from the layers
+ * @param authentication Credentials for the request
+ * @returns A promise that will resolve when all layers and tables have been added
+ * @private
+ */
+function addFeatureServiceLayersAndTables(itemTemplate, templateDictionary, popupInfos, authentication) {
+    return new Promise((resolve, reject) => {
+        if ((0, trackingHelpers_1.isTrackingViewTemplate)(itemTemplate)) {
+            resolve(null);
+        }
+        else {
+            // 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
+                        const updates = (0, restHelpers_1.getLayerUpdates)({
+                            message: "updated layer definition",
+                            objects: r.layerInfos.fieldInfos,
+                            itemTemplate: r.itemTemplate,
+                            authentication
+                        }, templateDictionary.isPortal);
+                        // Process the updates sequentially
+                        updates
+                            .reduce((prev, update) => {
+                            return prev.then(() => {
+                                return (0, restHelpers_1.getRequest)(update);
+                            });
+                        }, Promise.resolve(null))
+                            .then(() => resolve(null), (e) => reject((0, generalHelpers_1.fail)(e)) // getRequest
+                        );
+                    });
+                }, e => reject((0, generalHelpers_1.fail)(e)) // addFeatureServiceDefinition
+                );
+            }
+            else {
+                resolve(null);
+            }
+        }
+    });
+}
+exports.addFeatureServiceLayersAndTables = addFeatureServiceLayersAndTables;
+/**
+ * Updates a feature service with a list of layers and/or tables.
+ *
+ * @param serviceUrl URL of feature service
+ * @param listToAdd List of layers and/or tables to add
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature
+ *            service)
+ * @param authentication Credentials for the request
+ * @param key
+ * @param adminLayerInfos Hash map of a layers adminLayerInfo
+ * @param fieldInfos Hash map of properties that contain field references
+ * @param itemTemplate
+ * @returns A promise that will resolve when the feature service has been updated
+ * @private
+ */
+function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDictionary, authentication, key, adminLayerInfos, fieldInfos, itemTemplate) {
+    return new Promise((resolve, reject) => {
+        if ((0, trackingHelpers_1.isTrackingViewTemplate)(itemTemplate)) {
+            resolve(null);
+        }
+        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 ((0, generalHelpers_1.getProp)(itemTemplate, "properties.service.hasViews")) {
+                _updateTemplateDictionaryFields(itemTemplate, templateDictionary);
+            }
+            const isSelfReferential = _isSelfReferential(listToAdd);
+            listToAdd = _updateOrder(listToAdd, isSelfReferential);
+            const chunkSize = _getLayerChunkSize();
+            const layerChunks = [];
+            listToAdd.forEach((toAdd, i) => {
+                let item = toAdd.item;
+                const originalId = item.id;
+                fieldInfos = cacheFieldInfos(item, fieldInfos);
+                // cache the values to be added in seperate addToDef calls
+                fieldInfos = cacheContingentValues(item.id, fieldInfos, itemTemplate);
+                /* istanbul ignore else */
+                if (item.isView) {
+                    deleteViewProps(item);
+                }
+                // 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 = (0, templatization_1.replaceInTemplate)(item.adminLayerInfo, templateDictionary);
+                    /* istanbul ignore else */
+                    if (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;
+                            }
+                        });
+                    }
+                }
+                /* istanbul ignore else */
+                if (templateDictionary.isPortal) {
+                    item = _updateForPortal(item, itemTemplate, templateDictionary);
+                }
+                removeLayerOptimization(item);
+                // this can still chunk layers
+                options = _updateAddOptions(itemTemplate, options, layerChunks, isSelfReferential, 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(() => (0, restHelpers_1.addToServiceDefinition)(serviceUrl, curr, false, useAsync)), Promise.resolve(null))
+                .then(() => resolve(null), (e) => reject((0, generalHelpers_1.fail)(e)));
+        }
+    });
+}
+exports.addFeatureServiceDefinition = addFeatureServiceDefinition;
+/**
+ * When a view is a multi service view sort based on the id
+ * https://github.com/Esri/solution.js/issues/1048
+ *
+ * @param layersAndTables The list of layers and tables for the current template
+ * @param isSelfReferential Indicates if any layers or tables have relationships with other layers or tables in the same service
+ *
+ * @returns Sorted list of layers and tables when using a multi-service view
+ * @private
+ */
+function _updateOrder(layersAndTables, isSelfReferential) {
+    return isSelfReferential ? layersAndTables.sort((a, b) => a.item.id - b.item.id) : layersAndTables;
+}
+exports._updateOrder = _updateOrder;
+/**
+ * When a view is a multi service view add each layer separately
+ * https://github.com/Esri/solution.js/issues/871
+ *
+ * @param itemTemplate The current itemTemplate being processed
+ * @param options Add to service definition options
+ * @param layerChunks Groups of layers or tables to add to the service
+ * @param isSelfReferential Indicates if any layers or tables have relationships with other layers or tables in the same service
+ * @param authentication Credentials for the request
+ *
+ * @returns Add to service definition options
+ * @private
+ */
+function _updateAddOptions(itemTemplate, options, layerChunks, isSelfReferential, authentication) {
+    const isMsView = (0, generalHelpers_1.getProp)(itemTemplate, "properties.service.isMultiServicesView") || false;
+    /* istanbul ignore else */
+    if (isMsView || isSelfReferential) {
+        // if we already have some layers or tables add them first
+        /* istanbul ignore else */
+        if (options.layers.length > 0 || options.tables.length > 0) {
+            layerChunks.push(Object.assign({}, options));
+            options = {
+                layers: [],
+                tables: [],
+                authentication
+            };
+        }
+    }
+    return options;
+}
+exports._updateAddOptions = _updateAddOptions;
+/**
+ * Determine if any layer or table within the service references
+ * other layers or tables within the same service
+ *
+ * @param layersAndTables the list of layers and tables from the service
+ *
+ * @returns true when valid internal references are found
+ * @private
+ */
+function _isSelfReferential(layersAndTables) {
+    const names = layersAndTables.map(l => l.item.name);
+    const srcTables = {};
+    return layersAndTables.some(l => {
+        const table = l.item.adminLayerInfo?.viewLayerDefinition?.table;
+        if (table) {
+            const name = table.sourceServiceName;
+            const id = table.sourceLayerId;
+            if (name && id > -1) {
+                if (Object.keys(srcTables).indexOf(name) > -1) {
+                    if (srcTables[name].indexOf(id) > -1) {
+                        return true;
+                    }
+                    else {
+                        srcTables[name].push(id);
+                    }
+                }
+                else {
+                    srcTables[name] = [id];
+                }
+            }
+            return (table.relatedTables || []).some(r => names.indexOf(r.name) > -1);
+        }
+    });
+}
+exports._isSelfReferential = _isSelfReferential;
+/**
+ * Remove "multiScaleGeometryInfo" for issue #526 to prevent invalid enablement of layer optimization
+ *
+ * @param layer the layer to evaluate
+ * @private
+ */
+function removeLayerOptimization(layer) {
+    /* istanbul ignore else */
+    if (layer.multiScaleGeometryInfo) {
+        (0, generalHelpers_1.deleteProp)(layer, "multiScaleGeometryInfo");
+    }
+}
+exports.removeLayerOptimization = removeLayerOptimization;
+/**
+ * Handle portal specific updates to the item
+ *
+ * @param item the item to update
+ * @param itemTemplate the item template
+ * @param templateDictionary Hash mapping Solution source id to id of its clone
+ *
+ * @returns the updated item
+ * @private
+ */
+function _updateForPortal(item, itemTemplate, templateDictionary) {
+    // When deploying to portal we need to adjust the uniquie ID field up front
+    /* istanbul ignore else */
+    if (item.uniqueIdField && item.uniqueIdField.name) {
+        item.uniqueIdField.name = String(item.uniqueIdField.name).toLocaleLowerCase();
+    }
+    // Portal will fail if the geometryField is null
+    if (item.type === "Table" && item.adminLayerInfo) {
+        (0, generalHelpers_1.deleteProp)(item.adminLayerInfo, "geometryField");
+    }
+    // Portal will fail if the sourceFields in the viewLayerDef contain fields that are not in the source service
+    /* istanbul ignore else */
+    if (item.isView) {
+        const viewLayerDefTable = (0, generalHelpers_1.getProp)(item, "adminLayerInfo.viewLayerDefinition.table");
+        let fieldNames = [];
+        if (viewLayerDefTable) {
+            const tableFieldNames = _getFieldNames(viewLayerDefTable, itemTemplate, templateDictionary);
+            fieldNames = fieldNames.concat(tableFieldNames);
+            const dynamicFieldNames = _getDynamicFieldNames(viewLayerDefTable);
+            fieldNames = fieldNames.concat(dynamicFieldNames);
+            (0, generalHelpers_1.setProp)(item, "adminLayerInfo.viewLayerDefinition.table", _updateSourceLayerFields(viewLayerDefTable, fieldNames));
+            // Handle related also
+            /* istanbul ignore else */
+            if (Array.isArray(viewLayerDefTable.relatedTables)) {
+                viewLayerDefTable.relatedTables.map((relatedTable) => {
+                    const relatedTableFieldNames = _getFieldNames(relatedTable, itemTemplate, templateDictionary);
+                    fieldNames = fieldNames.concat(relatedTableFieldNames);
+                    const dynamicRelatedFieldNames = _getDynamicFieldNames(relatedTable);
+                    fieldNames = fieldNames.concat(dynamicRelatedFieldNames);
+                    return _updateSourceLayerFields(relatedTable, [...relatedTableFieldNames, ...dynamicRelatedFieldNames]);
+                });
+            }
+        }
+        else {
+            Object.keys(templateDictionary).some(k => {
+                /* istanbul ignore else */
+                if (templateDictionary[k].itemId === item.serviceItemId) {
+                    const layerInfo = templateDictionary[k][`layer${item.id}`];
+                    /* istanbul ignore else */
+                    if (layerInfo && layerInfo.fields) {
+                        if (Array.isArray(layerInfo.fields)) {
+                            fieldNames = layerInfo.fields.map((f) => f.name);
+                        }
+                        else {
+                            fieldNames = Object.keys(layerInfo.fields);
+                        }
+                    }
+                    return true;
+                }
+            });
+        }
+        item = _updateItemFields(item, fieldNames);
+    }
+    // not allowed to set sourceSchemaChangesAllowed or isView for portal
+    // these are set when you create the service
+    (0, generalHelpers_1.deleteProp)(item, "isView");
+    return item;
+}
+exports._updateForPortal = _updateForPortal;
+/**
+ * Get a list of the source layer field names
+ *
+ * @param table the table instance to compare
+ * @param itemTemplate the item template
+ * @param templateDictionary Hash mapping Solution source id to id of its clone
+ *
+ * @returns an array of the source layers fields
+ * @private
+ */
+function _getFieldNames(table, itemTemplate, templateDictionary) {
+    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(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((f) => f.name));
+                }
+                else {
+                    sourceLayerFields = sourceLayerFields.concat(Object.keys(layerInfo.fields));
+                }
+            }
+        });
+        return sourceLayerFields;
+    }
+}
+exports._getFieldNames = _getFieldNames;
+/**
+ * Get a list of any dynamically calculated fields
+ * These fields are still valid but will not exist in the source service
+ *
+ * @param table the table instance to compare
+ *
+ * @returns an array of field names
+ * @private
+ */
+function _getDynamicFieldNames(table) {
+    const fieldNames = table.sourceLayerFields.reduce((prev, cur) => {
+        if (cur.statisticType) {
+            prev.push(cur.name);
+        }
+        return prev;
+    }, []);
+    return [...new Set(fieldNames)];
+}
+exports._getDynamicFieldNames = _getDynamicFieldNames;
+/**
+ * Remove fields references from fields and indexes that do not exist in the source service
+ *
+ * @param item Layer or table
+ * @param templateDictionary Hash mapping Solution source id to id of its clone
+ *
+ * @returns updated layer or table
+ * @private
+ */
+function _updateItemFields(item, fieldNames) {
+    /* istanbul ignore else */
+    if (fieldNames.length > 0) {
+        /* istanbul ignore else */
+        if (item.fields) {
+            item.fields = item.fields.filter((f) => fieldNames.indexOf(f.name) > -1);
+        }
+        /* istanbul ignore else */
+        if (item.indexes) {
+            item.indexes = item.indexes.filter((f) => fieldNames.indexOf(f.fields) > -1);
+        }
+    }
+    return item;
+}
+exports._updateItemFields = _updateItemFields;
+/**
+ *  Filter the sourceLayerFields for the table
+ *
+ * @param table the table instance to evaluate
+ * @param sourceLayerFields array of fields from the source service
+ * @returns Updated instance of the table
+ * @private
+ */
+function _updateSourceLayerFields(table, sourceLayerFields) {
+    /* istanbul ignore else */
+    if (Array.isArray(table.sourceLayerFields) &&
+        table.sourceLayerFields.length > 0) {
+        // need to make sure these actually exist in the source..
+        /* istanbul ignore else */
+        if (sourceLayerFields.length > 0) {
+            (0, generalHelpers_1.setProp)(table, "sourceLayerFields", table.sourceLayerFields.filter((f) => sourceLayerFields.indexOf(f.source.toLowerCase()) > -1));
+        }
+    }
+    return table;
+}
+exports._updateSourceLayerFields = _updateSourceLayerFields;
+/**
+ * When the itemm is a view with a geometry field update the value to
+ * use the table name from the view layer def
+ *
+ * @param item the item details from the current template
+ * @param templateDictionary Hash mapping property names to replacement values
+ * @private
+ */
+function _updateGeomFieldName(adminLayerInfo, templateDictionary) {
+    // issue #471
+    const tableName = (0, generalHelpers_1.getProp)(adminLayerInfo, "viewLayerDefinition.table.name");
+    const fieldName = (0, generalHelpers_1.getProp)(adminLayerInfo, "geometryField.name");
+    /* istanbul ignore else */
+    if (fieldName && tableName) {
+        const geomName = templateDictionary.isPortal
+            ? `${tableName}.shape`
+            : `${tableName}.Shape`;
+        (0, generalHelpers_1.setProp)(adminLayerInfo, "geometryField.name", geomName);
+    }
+    else if (!fieldName && (0, generalHelpers_1.getProp)(adminLayerInfo, "geometryField")) {
+        // null geom field will cause failure to deploy in portal
+        // this is also checked and removed on deploy for older solutions
+        (0, generalHelpers_1.deleteProp)(adminLayerInfo, "geometryField");
+    }
+}
+exports._updateGeomFieldName = _updateGeomFieldName;
+/**
+ * Add the fields to the templateDictionary when a service has views
+ * these are used to compare with fields from the view when domains are involved
+ * when a view field has a domain that differs from that of the source service
+ * the definition needs to be modified in an update call rather than when it is first added.
+ * This should only happen when the domain differs.
+ *
+ * @param itemTemplate
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature service)
+ * @private
+ */
+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(k => {
+        if (compareItemId
+            ? templateDictionary[k].itemId === itemTemplate.itemId
+            : k === itemTemplate.itemId) {
+            templateDictionary[k].fieldInfos = fieldInfos;
+            return true;
+        }
+        else {
+            return false;
+        }
+    });
+}
+exports._updateTemplateDictionaryFields = _updateTemplateDictionaryFields;
+/**
+ * Set the defaultSpatialReference variable with the services spatial reference.
+ * If this item is a Feature Service that has child views then we will use this value
+ * if one or more of the child views spatial reference differs from that of its parent.
+ *
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature service)
+ * @param itemId The source id for the item
+ * @param spatialReference \{ wkid: 102100 \} for example
+ * @private
+ */
+function setDefaultSpatialReference(templateDictionary, itemId, spatialReference) {
+    /* istanbul ignore else */
+    if (spatialReference) {
+        (0, generalHelpers_1.setCreateProp)(templateDictionary, `${itemId}.defaultSpatialReference`, spatialReference);
+    }
+}
+exports.setDefaultSpatialReference = setDefaultSpatialReference;
+/**
+ * Compare the spatial reference of the current item against its dependencies.
+ * The spatial reference of a view cannot differ from its source service.
+ * If the view has a different spatial reference from its source use the source spatial reference.
+ *
+ * @param serviceInfo Basic service information
+ * @param itemTemplate The current template to process
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature service)
+ * @private
+ */
+function validateSpatialReferenceAndExtent(serviceInfo, itemTemplate, templateDictionary) {
+    /* istanbul ignore else */
+    if ((0, generalHelpers_1.getProp)(serviceInfo, "service.isView")) {
+        let sourceSR;
+        let sourceExt;
+        itemTemplate.dependencies.some(id => {
+            const source = templateDictionary[id];
+            const sr = (0, generalHelpers_1.getProp)(source, "defaultSpatialReference");
+            /* istanbul ignore else */
+            if (!sourceSR && sr) {
+                sourceSR = sr;
+            }
+            const ext = (0, generalHelpers_1.getProp)(source, "defaultExtent");
+            /* istanbul ignore else */
+            if (!sourceExt && ext) {
+                sourceExt = ext;
+            }
+            return sourceSR && sourceExt;
+        });
+        const sourceWkid = (0, generalHelpers_1.getProp)(sourceSR, "wkid");
+        const viewWkid = (0, generalHelpers_1.getProp)(serviceInfo, "service.spatialReference.wkid");
+        /* istanbul ignore else */
+        if (sourceWkid && viewWkid && sourceWkid !== viewWkid) {
+            (0, generalHelpers_1.setCreateProp)(serviceInfo, "service.spatialReference", sourceSR);
+        }
+        const viewExt = (0, generalHelpers_1.getProp)(serviceInfo, "service.fullExtent");
+        /* istanbul ignore else */
+        if (sourceExt &&
+            viewExt &&
+            JSON.stringify(sourceExt) !== JSON.stringify(viewExt)) {
+            (0, generalHelpers_1.setCreateProp)(serviceInfo, "defaultExtent", sourceExt);
+        }
+    }
+}
+exports.validateSpatialReferenceAndExtent = validateSpatialReferenceAndExtent;
+/**
+ * Updates a feature service with a list of layers and/or tables.
+ *
+ * @param itemTemplate
+ * @param fieldInfos Hash map of properties that contain field references
+ * @param popupInfos Hash map of a layers popupInfo
+ * @param adminLayerInfos Hash map of a layers adminLayerInfo
+ * @param templateDictionary Hash mapping Solution source id to id of its clone (and name & URL for feature service)
+ * @param authentication Credentials for the request
+ * @returns A promise that will resolve when the feature service has been updated
+ * @private
+ */
+function updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary) {
+    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((layerInfos) => {
+            // Update the items text with detemplatized popupInfo
+            updatePopupInfo(itemTemplate, layerInfos.popupInfos);
+            resolveFn({
+                itemTemplate,
+                layerInfos
+            });
+        }, e => rejectFn((0, generalHelpers_1.fail)(e)));
+    });
+}
+exports.updateLayerFieldReferences = updateLayerFieldReferences;
+/**
+ * Update the names of fields for each layer or table after it has been
+ * added to the definition
+ *
+ * @param itemTemplate Item to be created
+ * @param layerInfos Hash map of properties that contain field references and various layer info
+ * @param popupInfos Hash map of a layers popupInfo
+ * @param adminLayerInfos Hash map of a layers adminLayerInfo
+ * @param templateDictionary
+ * @param authentication Credentials for the request
+ * @returns An object with detemplatized field references
+ * @private
+ */
+function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLayerInfos, templateDictionary) {
+    return new Promise((resolveFn, rejectFn) => {
+        if (!itemTemplate.item.url) {
+            rejectFn((0, generalHelpers_1.fail)("Feature layer " + itemTemplate.itemId + " does not have a URL"));
+        }
+        else {
+            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 {
+                    return false;
+                }
+            });
+            // concat any layers and tables to process
+            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((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
+                const isView = item.isView || itemTemplate.properties.service.isView;
+                /* istanbul ignore else */
+                if (layerInfos && layerInfos.hasOwnProperty(item.id)) {
+                    const layerInfo = layerInfos[item.id];
+                    layerInfo["isView"] = item.isView;
+                    layerInfo["newFields"] = item.fields;
+                    layerInfo["sourceSchemaChangesAllowed"] =
+                        item.sourceSchemaChangesAllowed;
+                    /* istanbul ignore else */
+                    if (item.editFieldsInfo) {
+                        // more than case change when deployed to protal so keep track of the new names
+                        layerInfo["newEditFieldsInfo"] = JSON.parse(JSON.stringify(item.editFieldsInfo));
+                    }
+                    /* istanbul ignore else */
+                    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.sourceServiceFields;
+                    }
+                }
+            });
+            // Add the layerInfos to the settings object to be used while detemplatizing
+            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
+            resolveFn(deTemplatizeFieldInfos(layerInfos, popupInfos, adminLayerInfos, templateDictionary));
+        }
+    });
+}
+exports.postProcessFields = postProcessFields;
+/**
+ * Add popup info back to the layer item
+ *
+ * @param itemTemplate
+ * @param popupInfos popup info to be added back to the layer
+ * @private
+ */
+function updatePopupInfo(itemTemplate, popupInfos) {
+    ["layers", "tables"].forEach(type => {
+        const _items = (0, generalHelpers_1.getProp)(itemTemplate, "data." + type);
+        /* istanbul ignore else */
+        if (_items && Array.isArray(_items)) {
+            _items.forEach((item) => {
+                item.popupInfo = (0, generalHelpers_1.getProp)(popupInfos, type + "." + item.id) || {};
+            });
+        }
+    });
+}
+exports.updatePopupInfo = updatePopupInfo;
+//#endregion
+//#region Private helper functions --------------------------------------------------//
+/**
+ * Helper function to templatize value and make sure its converted to lowercase
+ *
+ * @param basePath path used to de-templatize while deploying
+ * @param value to be converted to lower case for lookup while deploying
+ * @private
+ */
+function _templatize(basePath, value, suffix) {
+    if (value.startsWith("{{")) {
+        return value;
+    }
+    else {
+        return String((0, templatization_1.templatizeTerm)(basePath, basePath, "." + String(value).toLowerCase() + (suffix ? "." + suffix : "")));
+    }
+}
+exports._templatize = _templatize;
+/**
+ * templatize an objects property
+ *
+ * @param object the object with the property to templatize
+ * @param property the property of the object to templatize
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeProperty(object, property, basePath, suffix) {
+    if (object && object.hasOwnProperty(property) && object[property]) {
+        object[property] = _templatize(basePath, object[property], suffix);
+    }
+}
+exports._templatizeProperty = _templatizeProperty;
+/**
+ * Templatize field references, serviceItemId, and adminLayerInfo for a layer
+ *
+ * @param dataItem from the items data property
+ * @param adminItem from the services admin api
+ * @param itemTemplate Template for feature service item
+ * @param dependencies Array of IDependency for name mapping
+ * @param templatizeFieldReferences Templatize all field references within a layer
+ * @returns A promise that will resolve when template has been updated
+ * @private
+ */
+function _templatizeLayer(dataItem, adminItem, itemTemplate, dependencies, templatizeFieldReferences, templateDictionary) {
+    // check for and repair common field issues
+    _validateFields(adminItem);
+    // Templatize all properties that contain field references
+    /* istanbul ignore else */
+    if (templatizeFieldReferences) {
+        _templatizeLayerFieldReferences(dataItem, itemTemplate.itemId, adminItem, dependencies);
+    }
+    const updates = [adminItem];
+    if (dataItem) {
+        updates.push(dataItem);
+    }
+    updates.forEach(update => {
+        if (update.hasOwnProperty("name")) {
+            // templatize the name but leave the current name as the optional default
+            update.name = (0, templatization_1.templatizeTerm)(update["serviceItemId"] + ".layer" + update.id, update["serviceItemId"] + ".layer" + update.id, ".name||" + update.name);
+        }
+        if (update.hasOwnProperty("extent")) {
+            update.extent = (0, templatization_1.templatizeTerm)(update["serviceItemId"], update["serviceItemId"], ".solutionExtent");
+        }
+        if (update.hasOwnProperty("serviceItemId")) {
+            update["serviceItemId"] = (0, templatization_1.templatizeTerm)(update["serviceItemId"], update["serviceItemId"], ".itemId");
+        }
+        if (update.hasOwnProperty("adminLayerInfo")) {
+            update.adminLayerInfo = _templatizeAdminLayerInfo(update, dependencies, templateDictionary);
+        }
+    });
+}
+exports._templatizeLayer = _templatizeLayer;
+/**
+ * Repair common issues that can occur with feature service field references.
+ * This function will mutate the input item if any of the common issues have occured.
+ *
+ * @param adminItem layer or table from the service
+ */
+function _validateFields(adminItem) {
+    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.
+    // Remove duplicate indexes on the same field.
+    _validateIndexes(adminItem, fieldNames);
+    // Remove field references in templates when field doesn't exist in the layer.
+    _validateTemplatesFields(adminItem, fieldNames);
+    _validateTypesTemplates(adminItem, fieldNames);
+    // Repair editFieldsInfo if field referenced doesn't exist in the layer
+    _validateEditFieldsInfo(adminItem, fieldNames);
+}
+exports._validateFields = _validateFields;
+/**
+ * Update primary display field if casing doesn't match.
+ * Update primary display field to the first non OID or GlobalId if the field isn't in the layer.
+ *
+ * @param adminItem layer or table from the service
+ * @param fieldNames string list of fields names
+ * @private
+ */
+function _validateDisplayField(adminItem, fieldNames) {
+    const displayField = adminItem.displayField || "";
+    let i = -1;
+    if (fieldNames.some(name => {
+        i += 1;
+        return name === displayField || name === displayField.toLowerCase();
+    })) {
+        adminItem.displayField = fieldNames[i];
+    }
+    else {
+        // use the first non-OID non-globalId field we find
+        const skipFields = [];
+        const oidField = (0, generalHelpers_1.getProp)(adminItem, "uniqueIdField.name");
+        /* istanbul ignore else */
+        if (oidField) {
+            skipFields.push(oidField);
+        }
+        const globalIdField = (0, generalHelpers_1.getProp)(adminItem, "globalIdField");
+        /* istanbul ignore else */
+        if (globalIdField) {
+            skipFields.push(globalIdField);
+        }
+        fieldNames.some(name => {
+            if (skipFields.indexOf(name) === -1) {
+                adminItem.displayField = name;
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+}
+exports._validateDisplayField = _validateDisplayField;
+/**
+ * Remove indexes on fields that don't exist in the layer.
+ * Remove duplicate indexes on the same field.
+ *
+ * @param adminItem layer or table from the service
+ * @param fieldNames string list of fields names
+ * @private
+ */
+function _validateIndexes(adminItem, fieldNames) {
+    const indexes = adminItem.indexes;
+    /* istanbul ignore else */
+    if (indexes) {
+        const indexedFields = [];
+        adminItem.indexes = indexes.reduce((filtered, index) => {
+            const indexFields = index.fields.split(",");
+            const verifiedFields = [];
+            indexFields.forEach(indexField => {
+                /* istanbul ignore else */
+                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) {
+                        verifiedFields.push(indexField);
+                    }
+                }
+                // else the field has more than one index associated and should not be returned
+            });
+            /* istanbul ignore else */
+            if (verifiedFields.length > 0) {
+                index.fields = verifiedFields.join(",");
+                filtered.push(index);
+            }
+            return filtered;
+        }, []);
+    }
+}
+exports._validateIndexes = _validateIndexes;
+/**
+ * Remove field references from templates that no longer exist.
+ *
+ * @param adminItem layer or table from the service
+ * @param fieldNames string list of fields names
+ * @private
+ */
+function _validateTemplatesFields(adminItem, fieldNames) {
+    const templates = adminItem.templates;
+    /* istanbul ignore else */
+    if (templates) {
+        adminItem.templates = templates.map(template => {
+            const attributes = (0, generalHelpers_1.getProp)(template, "prototype.attributes");
+            /* istanbul ignore else */
+            if (attributes) {
+                Object.keys(attributes).forEach(k => {
+                    /* istanbul ignore else */
+                    if (fieldNames.indexOf(k) === -1) {
+                        delete attributes[k];
+                    }
+                });
+                (0, generalHelpers_1.setProp)(template, "prototype.attributes", attributes);
+            }
+            return template;
+        });
+    }
+}
+exports._validateTemplatesFields = _validateTemplatesFields;
+/**
+ * Remove field references from templates that no longer exist.
+ *
+ * @param adminItem layer or table from the service
+ * @param fieldNames string list of fields names
+ * @private
+ */
+function _validateTypesTemplates(adminItem, fieldNames) {
+    const types = adminItem.types;
+    /* istanbul ignore else */
+    if (types) {
+        adminItem.types = types.map(t => {
+            _validateTemplatesFields(t, fieldNames);
+            return t;
+        });
+    }
+}
+exports._validateTypesTemplates = _validateTypesTemplates;
+/**
+ *  Check if edit feilds exist but with lower case
+ *
+ * @param adminItem layer or table from the service
+ * @param fieldNames string list of fields names
+ * @private
+ */
+function _validateEditFieldsInfo(adminItem, fieldNames) {
+    const editFieldsInfo = adminItem.editFieldsInfo;
+    /* istanbul ignore else */
+    if (editFieldsInfo) {
+        const editFieldsInfoKeys = Object.keys(editFieldsInfo);
+        editFieldsInfoKeys.forEach(k => {
+            const editFieldName = editFieldsInfo[k];
+            /* istanbul ignore else */
+            if (editFieldName) {
+                fieldNames.some(name => {
+                    if (name === editFieldName) {
+                        return true;
+                    }
+                    else if (name === editFieldName.toLowerCase()) {
+                        editFieldsInfo[k] = name;
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                });
+            }
+        });
+    }
+}
+exports._validateEditFieldsInfo = _validateEditFieldsInfo;
+/**
+ *
+ * Templatize all field references within a layer
+ * This is necessary to support potential field name changes when deploying to portal
+ * Portal will force all field names to be lower case
+ *
+ * @param dataItem The data layer instance with field name references within
+ * @param itemID The id for the item that contains this layer.
+ * @param layer JSON return from the layer being templatized.
+ * @param dependencies
+ * @returns An updated instance of the layer
+ * @private
+ */
+function _templatizeLayerFieldReferences(dataItem, itemID, layer, dependencies) {
+    // This is the value that will be used as the template for adlib replacement
+    const path = itemID + ".layer" + layer.id + ".fields";
+    // Get the field names for various tests
+    const fieldNames = layer.fields.map((f) => f.name);
+    // Update the layer from the items data property
+    if (dataItem) {
+        _templatizeAdminLayerInfoFields(dataItem, dependencies);
+        _templatizePopupInfo(dataItem, layer, path, itemID, fieldNames);
+    }
+    // Update the layer
+    _templatizeAdminLayerInfoFields(layer, dependencies);
+    _templatizeRelationshipFields(layer, itemID);
+    _templatizeDefinitionEditor(layer, path, fieldNames);
+    _templatizeDefinitionExpression(layer, path, fieldNames);
+    _templatizeDrawingInfo(layer, path, fieldNames);
+    _templatizeTemplates(layer, path);
+    _templatizeTypeTemplates(layer, path);
+    _templatizeTimeInfo(layer, path);
+    _templatizeDefinitionQuery(layer, path, fieldNames);
+}
+exports._templatizeLayerFieldReferences = _templatizeLayerFieldReferences;
+/**
+ * Templatize a layers adminLayerInfo by removing properties that will case issues with clone.
+ * Also templatizes the source service name when we are dealing with a view.
+ *
+ * @param layer The layer to be modified
+ * @param dependencies Array of service dependencies
+ * @returns A new copy of the modified adminLayerInfo for the given layer
+ * @private
+ */
+function _templatizeAdminLayerInfo(layer, dependencies, templateDictionary) {
+    // Create new instance of adminLayerInfo to update for clone
+    const adminLayerInfo = Object.assign({}, layer.adminLayerInfo);
+    _updateGeomFieldName(adminLayerInfo, templateDictionary);
+    (0, generalHelpers_1.deleteProp)(adminLayerInfo, "xssTrustedFields");
+    (0, generalHelpers_1.deleteProp)(adminLayerInfo, "tableName");
+    // Remove unnecessary properties and templatize key properties from viewLayerDefinition
+    /* istanbul ignore else */
+    if (adminLayerInfo.viewLayerDefinition) {
+        const viewDef = Object.assign({}, adminLayerInfo.viewLayerDefinition);
+        _processAdminObject(viewDef, dependencies);
+        // Remove unnecessary properties and templatize key properties from viewLayerDefinition.table
+        /* istanbul ignore else */
+        if (viewDef.table) {
+            _processAdminObject(viewDef.table, dependencies);
+            /* istanbul ignore else */
+            if (viewDef.table.relatedTables) {
+                viewDef.table.relatedTables.forEach((table) => {
+                    _processAdminObject(table, dependencies);
+                });
+            }
+        }
+        adminLayerInfo.viewLayerDefinition = viewDef;
+    }
+    return adminLayerInfo;
+}
+exports._templatizeAdminLayerInfo = _templatizeAdminLayerInfo;
+/**
+ * Remove sourceId and templatize the sourceServiceName
+ *
+ * @param object The layer to be modified
+ * @param dependencies Array of service dependencies
+ * @private
+ */
+function _processAdminObject(object, dependencies) {
+    (0, generalHelpers_1.deleteProp)(object, "sourceId");
+    if (object.hasOwnProperty("sourceServiceName")) {
+        object.sourceServiceName = _templatizeSourceServiceName(object.sourceServiceName, dependencies);
+    }
+}
+exports._processAdminObject = _processAdminObject;
+/**
+ * Templatize the name based on the given dependencies
+ *
+ * @param lookupName The current name from the source service
+ * @param dependencies Array of IDependency for name mapping
+ * @returns The templatized name || undefined when no matching dependency is found
+ * @private
+ */
+function _templatizeSourceServiceName(lookupName, dependencies) {
+    const deps = dependencies.filter(dependency => dependency.name === lookupName);
+    return deps.length === 1 ? _templatize(deps[0].id, "name") : undefined;
+}
+exports._templatizeSourceServiceName = _templatizeSourceServiceName;
+/**
+ * templatize the fields referenced in adminLayerInfo
+ *
+ * @param layer the layer object with the adminLayerInfo property to templatize
+ * @param basePath path used to de-templatize while deploying
+ * @param itemID the id for the item that contains this layer
+ * @private
+ */
+function _templatizeAdminLayerInfoFields(layer, dependencies) {
+    // templatize the source layer fields
+    const table = (0, generalHelpers_1.getProp)(layer, "adminLayerInfo.viewLayerDefinition.table");
+    if (table) {
+        let id = _getDependantItemId(table.sourceServiceName, dependencies);
+        const path = id + ".layer" + table.sourceLayerId + ".fields";
+        _templatizeAdminSourceLayerFields(table.sourceLayerFields || [], path);
+        // templatize the releated table fields
+        const relatedTables = (0, generalHelpers_1.getProp)(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables") || [];
+        if (relatedTables.length > 0) {
+            relatedTables.forEach((t) => {
+                id = _getDependantItemId(t.sourceServiceName, dependencies);
+                const relatedPath = id + ".layer" + t.sourceLayerId + ".fields";
+                _templatizeTopFilter(t.topFilter || {}, relatedPath);
+                _templatizeAdminSourceLayerFields(t.sourceLayerFields || [], relatedPath);
+                const parentKeyFields = t.parentKeyFields || [];
+                t.parentKeyFields = parentKeyFields.map((f) => {
+                    return _templatize(path, f, "name");
+                });
+                const keyFields = t.keyFields || [];
+                t.keyFields = keyFields.map((f) => {
+                    return _templatize(relatedPath, f, "name");
+                });
+            });
+        }
+    }
+}
+exports._templatizeAdminLayerInfoFields = _templatizeAdminLayerInfoFields;
+/**
+ * find id based on dependency name
+ *
+ * @param lookupName name of dependency we want to find the id of
+ * @param dependencies array of item dependencies
+ * @private
+ */
+function _getDependantItemId(lookupName, dependencies) {
+    const deps = dependencies.filter(dependency => dependency.name === lookupName);
+    return deps.length === 1 ? deps[0].id : "";
+}
+exports._getDependantItemId = _getDependantItemId;
+/**
+ * templatize the sourceLayerFields referenced in adminLayerInfo
+ *
+ * @param fields array of sourceLayerFields to templatize
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeAdminSourceLayerFields(fields, basePath) {
+    fields.forEach(f => _templatizeProperty(f, "source", basePath, "name"));
+}
+exports._templatizeAdminSourceLayerFields = _templatizeAdminSourceLayerFields;
+/**
+ * templatize the topFilter property from adminLayerInfo related tables
+ *
+ * @param topFilter the topFilter object to templatize
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeTopFilter(topFilter, basePath) {
+    /* istanbul ignore else */
+    if (topFilter) {
+        // templatize the orderByFields prop
+        const orderByFields = topFilter["orderByFields"] || "";
+        /* istanbul ignore else */
+        if (orderByFields !== "") {
+            const orderByField = orderByFields.split(" ")[0];
+            topFilter.orderByFields = topFilter.orderByFields.replace(orderByField, _templatize(basePath, orderByField, "name"));
+        }
+        const groupByFields = topFilter["groupByFields"] || "";
+        /* istanbul ignore else */
+        if (groupByFields !== "") {
+            const _groupByFields = groupByFields.split(",");
+            /* istanbul ignore else */
+            if (_groupByFields.length > 0) {
+                const mappedFields = _groupByFields.map((f) => {
+                    return _templatize(basePath, f, "name");
+                });
+                topFilter.groupByFields = mappedFields.join(",");
+            }
+        }
+    }
+}
+exports._templatizeTopFilter = _templatizeTopFilter;
+/**
+ * templatize the relationships key fields using the related table id in the basePath
+ *
+ * @param layer the layer that has the relationships to templatize
+ * @param itemID the id of the item that contains the related table
+ * @private
+ */
+function _templatizeRelationshipFields(layer, itemID) {
+    if (layer && layer.relationships) {
+        const relationships = layer.relationships;
+        relationships.forEach(r => {
+            /* istanbul ignore else */
+            if (r.keyField) {
+                const basePath = itemID + ".layer" + layer.id + ".fields";
+                _templatizeProperty(r, "keyField", basePath, "name");
+            }
+        });
+    }
+}
+exports._templatizeRelationshipFields = _templatizeRelationshipFields;
+/**
+ * templatize the popupInfo
+ *
+ * @param layerDefinition the layerDefinition that has the popupInfo to templatize
+ * @param layer the JSON for the layer being templatized
+ * @param basePath path used to de-templatize while deploying
+ * @param itemID the id for the item that contains this layer
+ * @param fieldNames array of fieldNames
+ * @private
+ */
+function _templatizePopupInfo(layerDefinition, layer, basePath, itemID, fieldNames) {
+    // the data layer does not have the fields...will need to get those
+    // from the associated layer json
+    if (fieldNames && layerDefinition.popupInfo) {
+        const popupInfo = layerDefinition.popupInfo;
+        _templatizeName(popupInfo, "title", fieldNames, basePath);
+        _templatizeName(popupInfo, "description", fieldNames, basePath);
+        const fieldInfos = popupInfo.fieldInfos || [];
+        _templatizePopupInfoFieldInfos(fieldInfos, layer, itemID, basePath);
+        const expressionInfos = popupInfo.expressionInfos || [];
+        _templatizeExpressionInfos(expressionInfos, fieldNames, basePath);
+        const popupElements = popupInfo.popupElements || [];
+        _templatizePopupElements(popupElements, basePath, layer, itemID, fieldNames);
+        const mediaInfos = popupInfo.mediaInfos || [];
+        _templatizeMediaInfos(mediaInfos, fieldNames, basePath, layer, itemID);
+    }
+}
+exports._templatizePopupInfo = _templatizePopupInfo;
+/**
+ * templatize field name when referenced like this: \{\{fieldName\}\}
+ * checks each field name from the layer
+ *
+ * @param object with the property to test for a field name
+ * @param property that could have a field name referenced
+ * @param fieldNames array for field names for the layer
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeName(object, property, fieldNames, basePath) {
+    if (object.hasOwnProperty(property)) {
+        fieldNames.forEach(name => {
+            // Only test and replace instance of the name so any enclosing characters
+            // will be retained
+            const regEx = new RegExp("(\\b" + name + "\\b(?![}]{2}))", "gm");
+            if (regEx.test(object[property])) {
+                object[property] = object[property].replace(regEx, _templatize(basePath, name, "name"));
+            }
+        });
+    }
+}
+exports._templatizeName = _templatizeName;
+/**
+ * templatize field name when referenced like this: \{\{fieldName\}\}
+ * checks each field name from the layer
+ *
+ * @param fieldInfos object that contains the popups fieldInfos
+ * @param layer json of layer being cloned
+ * @param itemID id of the item that contains the current layer
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizePopupInfoFieldInfos(fieldInfos, layer, itemID, basePath) {
+    fieldInfos.forEach((f) => {
+        f.fieldName = _templatizeFieldName(f.fieldName, layer, itemID, basePath);
+    });
+}
+exports._templatizePopupInfoFieldInfos = _templatizePopupInfoFieldInfos;
+/**
+ * templatize field name when referenced like this: \{\{fieldName\}\}
+ * checks each field name from the layer
+ *
+ * @param name the field name to templatize
+ * @param layer json of layer being cloned
+ * @param itemID id of the item that contains the current layer
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeFieldName(name, layer, itemID, basePath) {
+    if (name.indexOf("relationships/") > -1) {
+        const rels = name.split("/");
+        const relationshipId = rels[1];
+        const adminRelatedTables = (0, generalHelpers_1.getProp)(layer, "adminLayerInfo.viewLayerDefinition.table.relatedTables");
+        const relatedTables = layer.relationships || adminRelatedTables;
+        /* istanbul ignore else */
+        if (relatedTables && relatedTables.length > parseInt(relationshipId, 10)) {
+            const relatedTable = relatedTables[relationshipId];
+            // the layers relationships stores the property as relatedTableId
+            // the layers adminLayerInfo relatedTables stores the property as sourceLayerId
+            const prop = (0, generalHelpers_1.getProp)(relatedTable, "relatedTableId")
+                ? "relatedTableId"
+                : "sourceLayerId";
+            const _basePath = itemID + ".layer" + relatedTable[prop] + ".fields";
+            rels[2] = _templatize(_basePath, rels[2], "name");
+            name = rels.join("/");
+        }
+    }
+    else {
+        // do not need to templatize expression references as the expression
+        // itself will be templatized
+        if (name.indexOf("expression/") === -1) {
+            name = _templatize(basePath, name, "name");
+        }
+    }
+    return name;
+}
+exports._templatizeFieldName = _templatizeFieldName;
+/**
+ * templatize field name when referenced in expressionInfos
+ *
+ * @param expressionInfos the popups expressionInfos to check
+ * @param fieldNames array of the layers field names
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeExpressionInfos(expressionInfos, fieldNames, basePath) {
+    return expressionInfos.map((i) => {
+        fieldNames.forEach(name => {
+            i.expression = _templatizeArcadeExpressions(i.expression, name, basePath);
+        });
+        return i;
+    });
+}
+exports._templatizeExpressionInfos = _templatizeExpressionInfos;
+/**
+ * templatize field name when referenced in popupElelments
+ *
+ * @param popupElelments the popups popupElelments to check
+ * @param basePath path used to de-templatize while deploying
+ * @param layer json of layer being cloned
+ * @param itemID id of the item that contains the current layer
+ * @param fieldNames array of field names
+ * @private
+ */
+function _templatizePopupElements(popupElelments, basePath, layer, itemID, fieldNames) {
+    popupElelments.forEach((pe) => {
+        if (pe.hasOwnProperty("fieldInfos")) {
+            _templatizePopupInfoFieldInfos(pe.fieldInfos, layer, itemID, basePath);
+        }
+        if (pe.hasOwnProperty("mediaInfos")) {
+            _templatizeMediaInfos(pe.mediaInfos, fieldNames, basePath, layer, itemID);
+        }
+    });
+}
+exports._templatizePopupElements = _templatizePopupElements;
+/**
+ * templatize field name when referenced in mediaInfos
+ *
+ * @param mediaInfos the popups mediaInfos to check
+ * @param fieldNames array of the layers field names
+ * @param basePath path used to de-templatize while deploying
+ * @param layer json of layer being cloned
+ * @param itemID id of the item that contains the current layer
+ * @private
+ */
+function _templatizeMediaInfos(mediaInfos, fieldNames, basePath, layer, itemId) {
+    // templatize various properties of mediaInfos
+    const props = ["title", "caption"];
+    props.forEach(p => _templatizeName(mediaInfos, p, fieldNames, basePath));
+    mediaInfos.forEach((mi) => {
+        /* istanbul ignore else */
+        if (mi.hasOwnProperty("value")) {
+            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");
+            }
+            /* istanbul ignore else */
+            if (v.hasOwnProperty("tooltipField")) {
+                v.tooltipField = _templatizeFieldName(v.tooltipField, layer, itemId, basePath);
+            }
+        }
+    });
+}
+exports._templatizeMediaInfos = _templatizeMediaInfos;
+/**
+ * templatize field names when referenced in definitionEditor
+ *
+ * @param layer the layer with the definition editor
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames json of layer being cloned
+ * @private
+ */
+function _templatizeDefinitionEditor(layer, basePath, fieldNames) {
+    if (layer) {
+        const defEditor = layer.definitionEditor || {};
+        /* istanbul ignore else */
+        if (defEditor) {
+            const inputs = defEditor.inputs;
+            if (inputs) {
+                inputs.forEach(i => {
+                    /* istanbul ignore else */
+                    if (i.parameters) {
+                        i.parameters.forEach((p) => {
+                            _templatizeProperty(p, "fieldName", basePath, "name");
+                        });
+                    }
+                });
+            }
+            if (defEditor.hasOwnProperty("parameterizedExpression")) {
+                defEditor.parameterizedExpression = _templatizeSimpleName(defEditor.parameterizedExpression || "", basePath, fieldNames, "name");
+            }
+        }
+    }
+}
+exports._templatizeDefinitionEditor = _templatizeDefinitionEditor;
+/**
+ * templatize field names when referenced in definitionExpression
+ *
+ * @param layer the layer with the definition editor
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of field names
+ * @private
+ */
+function _templatizeDefinitionExpression(layer, basePath, fieldNames) {
+    if (layer && layer.hasOwnProperty("definitionExpression")) {
+        layer.definitionExpression = _templatizeSimpleName(layer.definitionExpression || "", basePath, fieldNames, "name");
+    }
+}
+exports._templatizeDefinitionExpression = _templatizeDefinitionExpression;
+/**
+ * Case sensitive test for field names that appear anywhere within a string
+ *
+ * @param expression the expression to test for field name references
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of the layers field names
+ * @private
+ */
+function _templatizeSimpleName(expression, basePath, fieldNames, suffix) {
+    fieldNames.forEach(name => {
+        // look for the name but not if its followed by }}
+        const regEx = new RegExp("\\b" + name + "\\b(?![}]{2})", "gm");
+        if (expression && regEx.test(expression)) {
+            expression = expression.replace(regEx, _templatize(basePath, name, suffix));
+        }
+    });
+    return expression;
+}
+exports._templatizeSimpleName = _templatizeSimpleName;
+/**
+ * Templatize field references within a layers drawingInfo
+ *
+ * @param layer the data layer
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of the layers field names
+ * @private
+ */
+function _templatizeDrawingInfo(layer, basePath, fieldNames) {
+    if (layer) {
+        const drawingInfo = layer.drawingInfo;
+        if (drawingInfo) {
+            // templatize the renderer fields
+            const renderer = drawingInfo.renderer || {};
+            _templatizeRenderer(renderer, basePath, fieldNames);
+            // templatize the labelingInfo
+            const labelingInfo = drawingInfo.labelingInfo || [];
+            _templatizeLabelingInfo(labelingInfo, basePath, fieldNames);
+        }
+    }
+}
+exports._templatizeDrawingInfo = _templatizeDrawingInfo;
+/**
+ * Templatize field references within a layers drawingInfo
+ *
+ * @param renderer the layers renderer
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of the layers field names
+ * @private
+ */
+function _templatizeRenderer(renderer, basePath, fieldNames) {
+    switch (renderer.type) {
+        case "classBreaks":
+        case "uniqueValue":
+        case "predominance":
+        case "simple":
+        case "heatmap":
+            _templatizeGenRenderer(renderer, basePath, fieldNames);
+            break;
+        case "temporal":
+            _templatizeTemporalRenderer(renderer, basePath, fieldNames);
+            break;
+        default:
+            break;
+    }
+}
+exports._templatizeRenderer = _templatizeRenderer;
+/**
+ * Templatize field references within a layers renderer
+ *
+ * @param renderer the renderer object to check for field references
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of field names that will be used to search expressions
+ * @private
+ */
+function _templatizeGenRenderer(renderer, basePath, fieldNames) {
+    /* istanbul ignore else */
+    if (renderer) {
+        // update authoringInfo
+        const authoringInfo = renderer.authoringInfo;
+        if (authoringInfo) {
+            _templatizeAuthoringInfo(authoringInfo, basePath, fieldNames);
+        }
+        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
+        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(name => {
+                renderer.valueExpression = _templatizeArcadeExpressions(renderer.valueExpression, name, basePath);
+            });
+        }
+        // update visualVariables
+        const visualVariables = renderer.visualVariables;
+        if (visualVariables) {
+            visualVariables.forEach(v => {
+                props.forEach(p => _templatizeProperty(v, p, basePath, "name"));
+                if (v.valueExpression) {
+                    fieldNames.forEach(name => {
+                        v.valueExpression = _templatizeArcadeExpressions(v.valueExpression, name, basePath);
+                    });
+                }
+            });
+        }
+    }
+}
+exports._templatizeGenRenderer = _templatizeGenRenderer;
+/**
+ * Templatize field references within a layers renderer
+ *
+ * @param renderer the renderer object to check for field references
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of field names that will be used to search expressions
+ * @private
+ */
+function _templatizeTemporalRenderer(renderer, basePath, fieldNames) {
+    const renderers = [
+        renderer.latestObservationRenderer,
+        renderer.observationRenderer,
+        renderer.trackRenderer
+    ];
+    renderers.forEach(r => {
+        _templatizeRenderer(r, basePath, fieldNames);
+    });
+}
+exports._templatizeTemporalRenderer = _templatizeTemporalRenderer;
+/**
+ * Templatize renderers authoringInfo
+ *
+ * @param authoringInfo  object containing metadata about the authoring process
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames the name of fields from the layer
+ * @private
+ */
+function _templatizeAuthoringInfo(authoringInfo, basePath, fieldNames) {
+    /* istanbul ignore else */
+    if (authoringInfo) {
+        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(f => _templatize(basePath, f, "name"));
+        }
+        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[p]) > -1) {
+                    _templatizeProperty(vVars, p, basePath, "name");
+                }
+            });
+        }
+    }
+}
+exports._templatizeAuthoringInfo = _templatizeAuthoringInfo;
+/**
+ * Templatize field references within an arcade expression
+ *
+ * @param text the text that contains the expression
+ * @param fieldName name of the field to test for
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeArcadeExpressions(text, fieldName, basePath) {
+    const t = _templatize(basePath, fieldName, "name");
+    if (text) {
+        // test for $feature. notation
+        // captures VOTED_DEM_2012 from $feature.VOTED_DEM_2012
+        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"]
+        // captures VOTED_DEM_2012 from $feature['VOTED_DEM_2012']
+        // captures VOTED_DEM_2012 from $feature[VOTED_DEM_2012]
+        exp = "(?:[$]feature)(\\[\\\"?\\'?)" + fieldName + "(\\\"?\\'?\\])";
+        regEx = new RegExp(exp, "gm");
+        let result = regEx.exec(text);
+        if (result) {
+            text = text.replace(regEx, "$feature" + result[1] + t + result[2]);
+        }
+        // test for $feature[] with join case
+        // captures VOTED_DEM_2016 from $feature["COUNTY_ID.VOTED_DEM_2016"]
+        exp =
+            "(?:[$]feature)(\\[\\\"?\\'?)(\\w+)[.]" + fieldName + "(\\\"?\\'?\\])";
+        regEx = new RegExp(exp, "gm");
+        result = regEx.exec(text);
+        if (result && result.length > 3) {
+            // TODO result[2] is the table name...this needs to be templatized as well
+            text = text.replace(regEx, "$feature" + result[1] + result[2] + "." + t + result[3]);
+        }
+        // test for "fieldName"
+        // captures fieldName from "var names = ["fieldName", "fieldName2"]..."
+        // captures fieldName from "var names = ['fieldName', 'fieldName2']..."
+        exp = "(\\\"|\\')+" + fieldName + "(\\\"|\\')+";
+        regEx = new RegExp(exp, "gm");
+        result = regEx.exec(text);
+        if (result) {
+            text = text.replace(regEx, result[1] + t + result[2]);
+        }
+    }
+    return text;
+}
+exports._templatizeArcadeExpressions = _templatizeArcadeExpressions;
+/**
+ * templatize field names when referenced in the layers labelingInfo
+ *
+ * @param labelingInfo the object that contains the labelingInfo
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of the layers field names
+ * @private
+ */
+function _templatizeLabelingInfo(labelingInfo, basePath, fieldNames) {
+    labelingInfo.forEach((li) => {
+        /* istanbul ignore else */
+        if (li.hasOwnProperty("fieldInfos")) {
+            const fieldInfos = li.fieldInfos || [];
+            fieldInfos.forEach(fi => _templatizeProperty(fi, "fieldName", basePath, "name"));
+        }
+        const labelExp = li.labelExpression || "";
+        const labelExpInfo = li.labelExpressionInfo || {};
+        fieldNames.forEach(n => {
+            const t = _templatize(basePath, n, "name");
+            // check for [fieldName] or ["fieldName"]
+            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) {
+                let v = labelExpInfo.value;
+                // check for {fieldName}
+                const regExCurly = new RegExp("(\\{" + n + "\\})", "gm");
+                v = regExCurly.test(v) ? v.replace(regExCurly, "{" + t + "}") : v;
+                // check for [fieldName] or ["fieldName"]
+                result = regExBracket.exec(v);
+                v = result ? v.replace(regExBracket, result[1] + t + result[3]) : v;
+                li.labelExpressionInfo.value = v;
+            }
+            /* istanbul ignore else */
+            if (labelExpInfo.expression) {
+                li.labelExpressionInfo.expression = _templatizeArcadeExpressions(labelExpInfo.expression, n, basePath);
+            }
+        });
+    });
+}
+exports._templatizeLabelingInfo = _templatizeLabelingInfo;
+/**
+ * templatize the layers editing templates
+ *
+ * @param layer the data layer being cloned
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeTemplates(layer, basePath) {
+    const templates = layer.templates || [];
+    templates.forEach(t => {
+        const attributes = (0, generalHelpers_1.getProp)(t, "prototype.attributes");
+        const _attributes = _templatizeKeys(attributes, basePath, "name");
+        /* istanbul ignore else */
+        if (_attributes) {
+            t.prototype.attributes = _attributes;
+        }
+    });
+}
+exports._templatizeTemplates = _templatizeTemplates;
+/**
+ * templatize the layer types and templates
+ *
+ * @param layer the data layer being cloned
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeTypeTemplates(layer, basePath) {
+    const types = layer.types;
+    if (types && Array.isArray(types) && types.length > 0) {
+        types.forEach((type) => {
+            const domains = _templatizeKeys(type.domains, basePath, "name");
+            /* istanbul ignore else */
+            if (domains) {
+                type.domains = domains;
+            }
+            const templates = type.templates;
+            /* istanbul ignore else */
+            if (templates && templates.length > 0) {
+                templates.forEach((t) => {
+                    const attributes = (0, generalHelpers_1.getProp)(t, "prototype.attributes");
+                    const _attributes = _templatizeKeys(attributes, basePath, "name");
+                    /* istanbul ignore else */
+                    if (_attributes) {
+                        t.prototype.attributes = _attributes;
+                    }
+                });
+            }
+        });
+    }
+}
+exports._templatizeTypeTemplates = _templatizeTypeTemplates;
+/**
+ * templatize object keys
+ *
+ * @param obj the object to templatize
+ * @param basePath path used to de-templatize while deploying
+ * @param suffix expected suffix for template variable
+ * @private
+ */
+function _templatizeKeys(obj, basePath, suffix) {
+    let _obj;
+    /* istanbul ignore else */
+    if (obj) {
+        _obj = {};
+        const objKeys = Object.keys(obj);
+        /* istanbul ignore else */
+        if (objKeys && objKeys.length > 0) {
+            objKeys.forEach(k => {
+                _obj[_templatize(basePath, k, suffix)] = obj[k];
+            });
+        }
+    }
+    return _obj;
+}
+exports._templatizeKeys = _templatizeKeys;
+/**
+ * templatize fields referenced in the layers time info
+ *
+ * @param layer the data layer being cloned
+ * @param basePath path used to de-templatize while deploying
+ * @private
+ */
+function _templatizeTimeInfo(layer, basePath) {
+    if (layer.timeInfo) {
+        const timeInfo = layer.timeInfo;
+        const timeProps = [
+            "endTimeField",
+            "startTimeField",
+            "trackIdField"
+        ];
+        timeProps.forEach(t => {
+            if (timeInfo[t] !== "") {
+                _templatizeProperty(timeInfo, t, basePath, "name");
+            }
+            else {
+                timeInfo[t] = null;
+            }
+        });
+    }
+}
+exports._templatizeTimeInfo = _templatizeTimeInfo;
+/**
+ * templatize the layers definition query
+ *
+ * @param layer the data layer being cloned
+ * @param basePath path used to de-templatize while deploying
+ * @param fieldNames array of the layers field names
+ * @private
+ */
+function _templatizeDefinitionQuery(layer, basePath, fieldNames) {
+    // templatize view definition query
+    if (layer && layer.hasOwnProperty("viewDefinitionQuery")) {
+        layer.viewDefinitionQuery = _templatizeSimpleName(layer.viewDefinitionQuery || "", basePath, fieldNames, "name");
+    }
+    if (layer && layer.hasOwnProperty("definitionQuery")) {
+        layer.definitionQuery = _templatizeSimpleName(layer.definitionQuery || "", basePath, fieldNames, "name");
+    }
+}
+exports._templatizeDefinitionQuery = _templatizeDefinitionQuery;
+/**
+ * Helper function to create the name mapping used to
+ * de-templatize the field reference
+ *
+ * @param fieldInfos the object that stores the cached information
+ * @param id the id for the current layer being processed
+ * @private
+ */
+function _getNameMapping(fieldInfos, id) {
+    // create name mapping
+    const fInfo = fieldInfos[id];
+    const nameMapping = {};
+    const newFields = fInfo.newFields;
+    const newFieldNames = newFields
+        ? newFields.map((f) => f.name)
+        : [];
+    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) {
+                // If both new (f) and source (field) aliases are defined and are equal, map the source name to the new name
+                if (f.alias && f.alias === field.alias) {
+                    nameMapping[lName] = {
+                        name: f.name,
+                        alias: f.alias,
+                        type: f.type ? f.type : ""
+                    };
+                }
+            }
+            if (String(f.name).toLowerCase() === lName) {
+                nameMapping[lName] = {
+                    name: f.name,
+                    alias: f.alias ? f.alias : "",
+                    type: f.type ? f.type : ""
+                };
+            }
+        });
+    });
+    // update for editFieldsInfo
+    if (fInfo.editFieldsInfo && fInfo.newEditFieldsInfo) {
+        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 */
+                if (fInfo.sourceSchemaChangesAllowed && !fInfo.isView) {
+                    /* istanbul ignore else */
+                    if (!fInfo.hasOwnProperty("deleteFields")) {
+                        fInfo.deleteFields = [];
+                    }
+                    // This issue only occurs on portal so we
+                    // need to delete the lcase version of the field
+                    fInfo.deleteFields.push(lowerEfi);
+                }
+                // editFieldsInfo only has the name and not the alias and type
+                let sourceEfiField;
+                fInfo.sourceFields.some((sf) => {
+                    if (sf.name === efi[k]) {
+                        sourceEfiField = sf;
+                    }
+                    return sf.name === efi[k];
+                });
+                nameMapping[lowerEfi] = {
+                    name: newEfi[k],
+                    alias: sourceEfiField && sourceEfiField.alias ? sourceEfiField.alias : "",
+                    type: sourceEfiField && sourceEfiField.type ? sourceEfiField.type : ""
+                };
+            }
+        });
+        (0, generalHelpers_1.deleteProp)(fInfo, "sourceSchemaChangesAllowed");
+        (0, generalHelpers_1.deleteProp)(fInfo, "editFieldsInfo");
+        (0, generalHelpers_1.deleteProp)(fInfo, "newEditFieldsInfo");
+        (0, generalHelpers_1.deleteProp)(fInfo, "isView");
+    }
+    return nameMapping;
+}
+exports._getNameMapping = _getNameMapping;
+/**
+ * Helper function to ensure same chunk size value is used in multiple locations
+ *
+ * @returns a number that represents how many layers should be included per addToDef call
+ * @private
+ */
+function _getLayerChunkSize() {
+    return 20;
+}
+exports._getLayerChunkSize = _getLayerChunkSize;
+//# sourceMappingURL=featureServiceHelpers.js.map