@esri/solution-simple-types 3.0.1 → 3.1.0

package/dist/umd/simple-types.umd.js

@@ -1,2296 +0,0 @@
-/* @preserve
-* @esri/solution-simple-types - v1.7.0 - Apache-2.0
-* Copyright (c) 2018-2023 Esri, Inc.
-* Fri Apr 28 2023 11:22:29 GMT-0700 (Pacific Daylight Time)
-*
-* 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.
-*/
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@esri/solution-common')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@esri/solution-common'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.arcgisSolution = global.arcgisSolution || {}, global.arcgisSolution));
-})(this, (function (exports, common) { 'use strict';
-
-  function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-      Object.keys(e).forEach(function (k) {
-        if (k !== 'default') {
-          var d = Object.getOwnPropertyDescriptor(e, k);
-          Object.defineProperty(n, k, d.get ? d : {
-            enumerable: true,
-            get: function () { return e[k]; }
-          });
-        }
-      });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-  }
-
-  var common__namespace = /*#__PURE__*/_interopNamespace(common);
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  /**
-   * Converts a dashboard item to a template.
-   *
-   * @param itemTemplate Template for the dashboard item
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns templatized itemTemplate
-   */
-  function convertItemToTemplate$8(itemTemplate, templateDictionary) {
-      return _extractDependencies$3(itemTemplate, templateDictionary);
-  }
-  /**
-   * Templatizes all itemIds and updates the dependency array
-   *
-   * @param itemTemplate Template for the dashboard item
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns The updated itemTemplate
-   * @private
-   */
-  function _extractDependencies$3(itemTemplate, templateDictionary) {
-      // get dependencies from any
-      const updatePaths = [
-          "data.desktopView.header",
-          "data.desktopView.headerPanel.selectors",
-          "data.desktopView.leftPanel.selectors",
-          "data.desktopView.sidebar",
-          "data.desktopView.urlParameters",
-          "data.desktopView.widgets",
-          "data.header",
-          "data.headerPanel.selectors",
-          "data.leftPanel.selectors",
-          "data.mobileView.header",
-          "data.mobileView.headerPanel.selectors",
-          "data.mobileView.leftPanel.selectors",
-          "data.mobileView.sidebar",
-          "data.mobileView.urlParameters",
-          "data.mobileView.widgets",
-          "data.sidebar",
-          "data.urlParameters",
-          "data.widgets"
-      ];
-      updatePaths.forEach(path => {
-          const objs = common__namespace.getProp(itemTemplate, path);
-          if (Array.isArray(objs)) {
-              objs.forEach(obj => {
-                  /* istanbul ignore else */
-                  if (obj.type === "mapWidget") {
-                      /* istanbul ignore else */
-                      if (itemTemplate.dependencies.indexOf(obj.itemId) < 0) {
-                          itemTemplate.dependencies.push(obj.itemId);
-                      }
-                      obj.itemId = common__namespace.templatizeTerm(obj.itemId, obj.itemId, ".itemId");
-                  }
-                  /* istanbul ignore else */
-                  if (Array.isArray(obj.datasets)) {
-                      _getDatasourceDependencies(obj, itemTemplate, templateDictionary);
-                  }
-              });
-          }
-      });
-      return itemTemplate;
-  }
-  /**
-   * Templatize datasource itemIds and update the dependency array
-   *
-   * @param obj A widget, selector, or urlParameter that contains a datasets collection
-   * @param itemTemplate Template for the dashboard item
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @private
-   */
-  function _getDatasourceDependencies(obj, itemTemplate, templateDictionary) {
-      obj.datasets.forEach((dataset) => {
-          // when the datasource has an itemId is an external datasource
-          const itemId = common__namespace.getProp(dataset, "dataSource.itemId");
-          if (itemId) {
-              if (itemTemplate.dependencies.indexOf(itemId) < 0) {
-                  itemTemplate.dependencies.push(itemId);
-              }
-              const layerId = common__namespace.getProp(dataset, "dataSource.layerId");
-              common__namespace.cacheLayerInfo(layerId?.toString(), itemId, "", templateDictionary);
-              dataset.dataSource.itemId = common__namespace.templatizeTerm(itemId, itemId, layerId !== undefined ? ".layer" + layerId + ".itemId" : ".itemId");
-              /* istanbul ignore else */
-              if (layerId !== undefined) {
-                  dataset.dataSource.layerId = common__namespace.templatizeTerm(itemId, itemId, ".layer" + layerId + ".layerId");
-              }
-          }
-      });
-  }
-  /**
-   * Templatize field references for datasources and widgets.
-   *
-   * @param solutionTemplate The solution item template
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns The solutionTemplate with templatized field references
-   */
-  function postProcessFieldReferences$3(solutionTemplate, datasourceInfos) {
-      const updatePaths = [
-          "data.desktopView.header",
-          "data.desktopView.headerPanel.selectors",
-          "data.desktopView.leftPanel.selectors",
-          "data.desktopView.sidebar",
-          "data.desktopView.urlParameters",
-          "data.desktopView.widgets",
-          "data.header",
-          "data.headerPanel.selectors",
-          "data.leftPanel.selectors",
-          "data.mobileView.header",
-          "data.mobileView.headerPanel.selectors",
-          "data.mobileView.leftPanel.selectors",
-          "data.mobileView.sidebar",
-          "data.mobileView.urlParameters",
-          "data.mobileView.widgets",
-          "data.sidebar",
-          "data.urlParameters",
-          "data.widgets"
-      ];
-      // dashboards reference datasets from other widgets
-      // add reference IDs to the appropriate datasourceInfos
-      updatePaths.forEach(path => {
-          const objs = common__namespace.getProp(solutionTemplate, path);
-          _updateDatasourceReferences(objs, datasourceInfos);
-      });
-      // after we know the potential references go ahead and templatize
-      updatePaths.forEach(path => {
-          _templatize$1(solutionTemplate, path, datasourceInfos);
-      });
-      return solutionTemplate;
-  }
-  /**
-   * Add all dataset ids to the appropriate datasource info object so we can navigate any relative references
-   *
-   * @param objs Thes can be widgets, selectors, or urlParameters
-   * @param datasourceInfos A list of objects that contain key details about the datasources from the application
-   * @private
-   */
-  function _updateDatasourceReferences(objs, datasourceInfos) {
-      // objects can be events or widgets
-      /* istanbul ignore else */
-      if (objs && Array.isArray(objs)) {
-          objs.forEach(obj => {
-              if (Array.isArray(obj.datasets)) {
-                  obj.datasets.forEach((dataset) => {
-                      // when the datasource has an itemId it's an external datasource
-                      const itemId = common__namespace.cleanLayerBasedItemId(common__namespace.getProp(dataset, "dataSource.itemId"));
-                      if (itemId) {
-                          const layerId = common__namespace.cleanLayerId(common__namespace.getProp(dataset, "dataSource.layerId"));
-                          datasourceInfos.some(ds => {
-                              if (ds.itemId === itemId && ds.layerId === layerId) {
-                                  _updateReferences(ds, obj.id);
-                                  return true;
-                              }
-                              else {
-                                  return false;
-                              }
-                          });
-                      }
-                      else {
-                          // add placeholder for map layer datasource info so we can know the items that reference them
-                          // needed when item field reference are derived from another widgets datasource eg. <dashboardWidgetId>#datasetname
-                          const id = common__namespace.getProp(dataset, "dataSource.id");
-                          if (id) {
-                              const dashboardLayerId = id.split("#")[1];
-                              datasourceInfos.some(ds => {
-                                  if (ds.ids.indexOf(dashboardLayerId) > -1) {
-                                      _updateReferences(ds, obj.id);
-                                      return true;
-                                  }
-                                  else {
-                                      return false;
-                                  }
-                              });
-                          }
-                      }
-                  });
-              }
-          });
-      }
-  }
-  /**
-   * Templatize all datasets and/or events for the objects at the given path
-   *
-   * @param itemTemplate Template for the dashboard item
-   * @param path A property path to an array of objects that could contain datasets or events
-   * @param datasourceInfos A list of objects that contain key details about the datasources from the application
-   * @private
-   */
-  function _templatize$1(itemTemplate, path, datasourceInfos) {
-      const obj = common__namespace.getProp(itemTemplate, path);
-      /* istanbul ignore else */
-      if (obj) {
-          common__namespace.setProp(itemTemplate, path, _templatizeByDatasource(obj, datasourceInfos));
-      }
-  }
-  /**
-   * For any service dataset datasource templatize all field references
-   *
-   * @param objs A list of objects that can contain field references
-   * @param datasourceInfos A list of objects that contain key details about the datasources from the application
-   * @returns An updated list of objects with templatized field references
-   * @private
-   */
-  function _templatizeByDatasource(objs, datasourceInfos) {
-      if (Array.isArray(objs)) {
-          return objs.map(obj => {
-              let _obj = obj;
-              if (Array.isArray(_obj.events)) {
-                  // Events can be associated with datasets but they can also be associated with a target
-                  // In some cases an event will have a source and a target.
-                  // Handle these specifically first to ensure that it has the correct layer reference
-                  _obj.events = _obj.events.map((event) => {
-                      const _event = event;
-                      /* istanbul ignore else */
-                      if (Array.isArray(_event.actions)) {
-                          _event.actions = _event.actions.map((action) => {
-                              const _action = action;
-                              if (_action.fieldMap &&
-                                  _action.targetId &&
-                                  _action.targetId.indexOf("#") > -1) {
-                                  const datasourceInfo = _getDatasourceInfo$1(_action, datasourceInfos);
-                                  /* istanbul ignore else */
-                                  if (datasourceInfo) {
-                                      const fields = common__namespace.getProp(datasourceInfo, "fields");
-                                      const basePath = common__namespace.getProp(datasourceInfo, "basePath");
-                                      /* istanbul ignore else */
-                                      if (Array.isArray(fields) && basePath) {
-                                          _action.fieldMap = _action.fieldMap.map((m) => {
-                                              const _m = m;
-                                              _m.targetName = common__namespace.templatizeFieldReferences(_m.targetName, fields, basePath);
-                                              return _m;
-                                          });
-                                      }
-                                  }
-                              }
-                              return _action;
-                          });
-                      }
-                      return _event;
-                  });
-              }
-              if (Array.isArray(_obj.datasets)) {
-                  _obj.datasets = _obj.datasets.map((dataset) => {
-                      let _dataset = dataset;
-                      if (_dataset.type === "serviceDataset") {
-                          const datasourceInfo = _getDatasourceInfo$1(dataset, datasourceInfos);
-                          /* istanbul ignore else */
-                          if (datasourceInfo) {
-                              const fields = common__namespace.getProp(datasourceInfo, "fields");
-                              const basePath = common__namespace.getProp(datasourceInfo, "basePath");
-                              /* istanbul ignore else */
-                              if (Array.isArray(fields) && basePath) {
-                                  _obj = common__namespace.templatizeFieldReferences(_obj, fields, basePath);
-                                  _dataset = common__namespace.templatizeFieldReferences(_dataset, fields, basePath);
-                              }
-                          }
-                      }
-                      return _dataset;
-                  });
-                  return _obj;
-              }
-              else
-                  return _obj;
-          });
-      }
-      else {
-          return objs;
-      }
-  }
-  /**
-   * Find the appropriate datasource info object from the datasourceInfo collection
-   *
-   * @param obj Can be a Dataset or an event
-   * @param datasourceInfos A list of objects that contain key details about the datasources from the application
-   * @returns The supporting datasource info for the given object
-   * @private
-   */
-  function _getDatasourceInfo$1(obj, datasourceInfos) {
-      let info;
-      // the datasource will have an id property when it's referencing a map layer
-      // the fields collection will already be defined
-      const id = common__namespace.getProp(obj, "dataSource.id") || common__namespace.getProp(obj, "targetId");
-      if (id) {
-          const dashboardLayerId = id.split("#")[1];
-          if (!datasourceInfos.some(di => {
-              info = di.ids.indexOf(dashboardLayerId) > -1 ? di : info;
-              return di.ids.indexOf(dashboardLayerId) > -1;
-          })) {
-              // in some cases the id will not contain a layer name...it will have the dashboard id for another widget
-              // in that case lookup the datasource from referenced widget
-              const dashboardWidgetId = id.split("#")[0];
-              datasourceInfos.some(di => {
-                  const references = di.references || [];
-                  const hasRef = references.indexOf(dashboardWidgetId) > -1;
-                  info = hasRef ? di : info;
-                  return hasRef;
-              });
-          }
-      }
-      else {
-          // otherwise match the itemId and the layerId to get the correct fields and path
-          const itemId = common__namespace.cleanLayerBasedItemId(common__namespace.getProp(obj, "dataSource.itemId"));
-          const layerId = common__namespace.cleanLayerId(common__namespace.getProp(obj, "dataSource.layerId"));
-          /* istanbul ignore else */
-          if (itemId) {
-              datasourceInfos.some(di => {
-                  const matches = itemId === di.itemId && layerId === di.layerId;
-                  info = matches ? di : info;
-                  return matches;
-              });
-          }
-      }
-      return info;
-  }
-  /**
-   * Verifies if the datasource info contains the given id and adds it if not
-   *
-   * @param ds The datasource info to add the reference to
-   * @param id The id from dashboard object, commonly another widget
-   * @private
-   */
-  function _updateReferences(ds, id) {
-      ds.references = Array.isArray(ds.references) ? ds.references : [];
-      if (ds.references.indexOf(id) < 0) {
-          ds.references.push(id);
-      }
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-  // ------------------------------------------------------------------------------------------------------------------ //
-  /**
-   * Converts a web mapping application item into a template.
-   *
-   * @param itemInfo Info about the item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns A promise that will resolve when the template has been created
-   */
-  function convertItemToTemplate$7(itemTemplate, destAuthentication, srcAuthentication, templateDictionary) {
-      return new Promise((resolve, reject) => {
-          // Remove org base URL and app id, e.g.,
-          //   http://anOrg.maps.arcgis.com/apps/CrowdsourcePolling/index.html?appid=6fc5992522d34a6b5ce80d17835eea21
-          // to
-          //   <placeholder(SERVER_NAME)>/apps/CrowdsourcePolling/index.html?appid={{<itemId>.id}}
-          // Need to add placeholder server name because otherwise AGOL makes URL null
-          let portalUrl = "";
-          if (itemTemplate.item.url) {
-              const templatizedUrl = itemTemplate.item.url;
-              const iSep = templatizedUrl.indexOf("//");
-              itemTemplate.item.url =
-                  common__namespace.placeholder(common__namespace.SERVER_NAME) + // add placeholder server name
-                      templatizedUrl.substring(templatizedUrl.indexOf("/", iSep + 2), templatizedUrl.lastIndexOf("=") + 1) +
-                      itemTemplate.item.id; // templatized id
-              portalUrl = templatizedUrl.replace(templatizedUrl.substring(templatizedUrl.indexOf("/", iSep + 2)), "");
-          }
-          // Extract dependencies
-          itemTemplate.dependencies = _extractDependencies$2(itemTemplate);
-          // Set the folder
-          common__namespace.setProp(itemTemplate, "data.folderId", "{{folderId}}");
-          // Set the map or group after we've extracted them as dependencies
-          _templatizeIdPaths(itemTemplate, [
-              "data.map.itemId",
-              "data.map.appProxy.mapItemId",
-              "data.values.webmap",
-              "data.values.group"
-          ]);
-          // force the appItemId to be pulled directly from the template item
-          // this is to address solution.js #124
-          _templatizeIdPath(itemTemplate, "data.appItemId", itemTemplate.itemId);
-          setValues(itemTemplate, [
-              "data.logo",
-              "data.map.portalUrl",
-              "data.portalUrl",
-              "data.httpProxy.url"
-          ], common__namespace.placeholder(common__namespace.SERVER_NAME));
-          common__namespace.setProp(itemTemplate, "data.geometryService", common__namespace.placeholder(common__namespace.GEOMETRY_SERVER_NAME));
-          templatizeDatasources(itemTemplate, srcAuthentication, portalUrl, templateDictionary).then(() => {
-              templatizeWidgets(itemTemplate, srcAuthentication, portalUrl, "data.widgetPool.widgets").then(_itemTemplate => {
-                  templatizeWidgets(_itemTemplate, srcAuthentication, portalUrl, "data.widgetOnScreen.widgets", true).then(updatedItemTemplate => {
-                      templatizeValues(updatedItemTemplate, srcAuthentication, portalUrl, "data.values").then(_updatedItemTemplate => {
-                          resolve(_updatedItemTemplate);
-                      }, e => reject(common__namespace.fail(e)));
-                  }, e => reject(common__namespace.fail(e)));
-              }, e => reject(common__namespace.fail(e)));
-          }, e => reject(common__namespace.fail(e)));
-      });
-  }
-  /**
-   * Converts web mapping application datasources to variables for deployment
-   *
-   * @param itemTemplate The solution item template
-   * @param authentication Credentials for requests
-   * @param portalUrl Rest Url of the portal to perform the search
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns A promise that will resolve with the created template
-   */
-  function templatizeDatasources(itemTemplate, authentication, portalUrl, templateDictionary) {
-      return new Promise((resolve, reject) => {
-          const dataSources = common__namespace.getProp(itemTemplate, "data.dataSource.dataSources");
-          if (dataSources && Object.keys(dataSources).length > 0) {
-              const pendingRequests = new Array();
-              Object.keys(dataSources).forEach(k => {
-                  const ds = dataSources[k];
-                  common__namespace.setProp(ds, "portalUrl", common__namespace.placeholder(common__namespace.SERVER_NAME));
-                  const itemId = common__namespace.getProp(ds, "itemId");
-                  if (common__namespace.getProp(ds, "url")) {
-                      if (itemId) {
-                          const layerId = ds.url.substr(ds.url.lastIndexOf("/") + 1);
-                          common__namespace.cacheLayerInfo(layerId.toString(), itemId, ds.url, templateDictionary);
-                          ds.itemId = common__namespace.templatizeTerm(itemId, itemId, ".layer" + layerId + ".itemId");
-                      }
-                      const urlResults = findUrls(ds.url, portalUrl, [], [], authentication);
-                      pendingRequests.push(new Promise((resolveReq, rejectReq) => {
-                          handleServiceRequests(urlResults.serviceRequests, urlResults.requestUrls, urlResults.testString).then(response => {
-                              ds.url = response;
-                              resolveReq();
-                          }, e => rejectReq(common__namespace.fail(e)));
-                      }));
-                  }
-                  else {
-                      if (itemId) {
-                          ds.itemId = common__namespace.templatizeTerm(itemId, itemId, ".itemId");
-                      }
-                  }
-              });
-              Promise.all(pendingRequests).then(() => resolve(itemTemplate), e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve(itemTemplate);
-          }
-      });
-  }
-  function templatizeWidgets(itemTemplate, authentication, portalUrl, widgetPath, isOnScreen = false) {
-      return new Promise((resolve, reject) => {
-          // update widgets
-          const widgets = common__namespace.getProp(itemTemplate, widgetPath) || [];
-          let serviceRequests = [];
-          let requestUrls = [];
-          widgets.forEach(widget => {
-              /* istanbul ignore else */
-              if (!isOnScreen && common__namespace.getProp(widget, "icon")) {
-                  setValues(widget, ["icon"], common__namespace.placeholder(common__namespace.SERVER_NAME));
-              }
-              const config = widget.config;
-              if (config) {
-                  const sConfig = JSON.stringify(config);
-                  const urlResults = findUrls(sConfig, portalUrl, requestUrls, serviceRequests, authentication);
-                  widget.config = JSON.parse(urlResults.testString);
-                  serviceRequests = urlResults.serviceRequests;
-                  requestUrls = urlResults.requestUrls;
-              }
-          });
-          if (serviceRequests.length > 0) {
-              const sWidgets = JSON.stringify(widgets);
-              handleServiceRequests(serviceRequests, requestUrls, sWidgets).then(response => {
-                  common__namespace.setProp(itemTemplate, widgetPath, JSON.parse(response));
-                  resolve(itemTemplate);
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve(itemTemplate);
-          }
-      });
-  }
-  function templatizeValues(itemTemplate, authentication, portalUrl, widgetPath) {
-      return new Promise((resolve, reject) => {
-          // update properties of values collection for web app templates
-          let values = common__namespace.getProp(itemTemplate, widgetPath);
-          let serviceRequests = [];
-          let requestUrls = [];
-          if (values) {
-              if (common__namespace.getProp(values, "icon")) {
-                  setValues(values, ["icon"], common__namespace.placeholder(common__namespace.SERVER_NAME));
-              }
-              const sConfig = JSON.stringify(values);
-              const urlResults = findUrls(sConfig, portalUrl, requestUrls, serviceRequests, authentication);
-              values = JSON.parse(urlResults.testString);
-              serviceRequests = urlResults.serviceRequests;
-              requestUrls = urlResults.requestUrls;
-          }
-          if (serviceRequests.length > 0) {
-              const sWidgets = JSON.stringify(values);
-              handleServiceRequests(serviceRequests, requestUrls, sWidgets).then(response => {
-                  common__namespace.setProp(itemTemplate, widgetPath, JSON.parse(response));
-                  resolve(itemTemplate);
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve(itemTemplate);
-          }
-      });
-  }
-  function handleServiceRequests(serviceRequests, requestUrls, objString) {
-      return new Promise((resolve, reject) => {
-          if (serviceRequests && serviceRequests.length > 0) {
-              let i = 0;
-              Promise.all(serviceRequests).then(serviceResponses => {
-                  serviceResponses.forEach(serviceResponse => {
-                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
-                          const serviceTemplate = "{{" +
-                              serviceResponse.serviceItemId +
-                              (serviceResponse.hasOwnProperty("id")
-                                  ? ".layer" + serviceResponse.id
-                                  : "") +
-                              ".url}}";
-                          objString = replaceUrl(objString, requestUrls[i], serviceTemplate, true);
-                      }
-                      i++;
-                  });
-                  resolve(objString);
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve(objString);
-          }
-      });
-  }
-  function findUrls(testString, portalUrl, requestUrls, serviceRequests, authentication) {
-      const options = {
-          f: "json",
-          authentication: authentication
-      };
-      // test for URLs
-      const results = testString.match(/(\bhttps?:\/\/[-A-Z0-9/._]*)/gim);
-      if (results && results.length) {
-          results.forEach((url) => {
-              if (url.indexOf("NAServer") > -1) {
-                  testString = replaceUrl(testString, url, common__namespace.placeholder(common__namespace.NA_SERVER_NAME));
-              }
-              else if (url.indexOf("GeocodeServer") > -1) {
-                  testString = replaceUrl(testString, url, common__namespace.placeholder(common__namespace.GEOCODE_SERVER_NAME));
-              }
-              else if (portalUrl && url.indexOf(portalUrl) > -1) {
-                  testString = replaceUrl(testString, portalUrl, common__namespace.placeholder(common__namespace.SERVER_NAME));
-              }
-              else if (url.indexOf("FeatureServer") > -1) {
-                  if (requestUrls.indexOf(url) === -1) {
-                      requestUrls.push(url);
-                      serviceRequests.push(common__namespace.rest_request(url, options));
-                  }
-              }
-          });
-      }
-      return {
-          testString,
-          requestUrls,
-          serviceRequests
-      };
-  }
-  /**
-   * Replace url with templatized url value
-   *
-   * @param obj can be a single url string or a stringified JSON object
-   * @param url the current url we are testing for
-   * @param newUrl the templatized url
-   * @param validateFullUrl should only replace url when we have a full match.
-   * This property is only relevant when the obj is a stringified JSON object.
-   *
-   * @returns the obj with any instances of the url replaced
-   */
-  function replaceUrl(obj, url, newUrl, validateFullUrl = false) {
-      const enforceFullUrl = validateFullUrl && obj.indexOf('"') > -1;
-      const re = new RegExp(enforceFullUrl ? '"' + url + '"' : url, "gmi");
-      return obj.replace(re, enforceFullUrl ? '"' + newUrl + '"' : newUrl);
-  }
-  function setValues(itemTemplate, paths, base) {
-      paths.forEach(path => {
-          const url = common__namespace.getProp(itemTemplate, path);
-          if (url) {
-              const subString = url.substring(url.indexOf("/", url.indexOf("//") + 2));
-              common__namespace.setProp(itemTemplate, path, subString !== url ? base + subString : base);
-          }
-      });
-  }
-  function fineTuneCreatedItem$2(originalTemplate, newlyCreatedItem, templateDictionary, destinationAuthentication) {
-      return new Promise(resolve => {
-          // If this is a Web AppBuilder application, we will create a Code Attachment for downloading
-          if (common__namespace.hasAnyKeyword(originalTemplate, [
-              "WAB2D",
-              "WAB3D",
-              "Web AppBuilder"
-          ])) {
-              // Update item so properties like appItemId can now be set now that we know the new apps ID
-              const updateOptions = {
-                  id: newlyCreatedItem.itemId,
-                  url: newlyCreatedItem.item.url,
-                  data: newlyCreatedItem.data
-              };
-              const updateDef = common__namespace.updateItem(updateOptions, destinationAuthentication);
-              const itemInfo = {
-                  tags: originalTemplate.item.tags,
-                  title: originalTemplate.item.title,
-                  type: "Code Attachment",
-                  typeKeywords: ["Code", "Javascript", "Web Mapping Application"],
-                  relationshipType: "WMA2Code",
-                  originItemId: newlyCreatedItem.itemId,
-                  url: common__namespace.checkUrlPathTermination(common__namespace.replaceInTemplate(common__namespace.placeholder(common__namespace.SERVER_NAME), templateDictionary)) +
-                      "sharing/rest/content/items/" +
-                      newlyCreatedItem.itemId +
-                      "/package"
-              };
-              const createItemWithDataDef = common__namespace.createItemWithData(itemInfo, {}, destinationAuthentication, templateDictionary.folderId);
-              Promise.all([updateDef, createItemWithDataDef]).then(() => resolve(null), () => resolve(null));
-          }
-          else {
-              // Otherwise, nothing extra needed
-              resolve(null);
-          }
-      });
-  }
-  // ------------------------------------------------------------------------------------------------------------------ //
-  /**
-   * Gets the ids of the dependencies of an AGOL webapp item.
-   *
-   * @param fullItem A webapp item whose dependencies are sought
-   * @returns A promise that will resolve with list of dependent ids
-   * @private
-   */
-  function _extractDependencies$2(model) {
-      let processor = _getGenericWebAppDependencies;
-      /*
-      if (common.hasTypeKeyword(model, "Story Map")) {
-        processor = getStoryMapDependencies;
-      }
-      */
-      if (common__namespace.hasAnyKeyword(model, ["WAB2D", "WAB3D", "Web AppBuilder"])) {
-          processor = _getWABDependencies;
-      }
-      return processor(model);
-  }
-  /**
-   * Generic Web App Dependencies
-   *
-   * @private
-   */
-  function _getGenericWebAppDependencies(model) {
-      const props = ["data.values.webmap", "data.values.group"];
-      return common__namespace.getProps(model, props);
-  }
-  //???
-  function _getWABDependencies(model) {
-      const deps = [];
-      const v = common__namespace.getProp(model, "data.map.itemId");
-      if (v) {
-          deps.push(v);
-      }
-      const dataSources = common__namespace.getProp(model, "data.dataSource.dataSources");
-      if (dataSources) {
-          Object.keys(dataSources).forEach(k => {
-              const ds = dataSources[k];
-              if (ds.itemId) {
-                  deps.push(ds.itemId);
-              }
-          });
-      }
-      return deps;
-  }
-  /**
-   * Templatizes id properties for the paths provided
-   *
-   * @param itemTemplate The solution item template
-   * @param paths A list of property paths that contain ids
-   * @private
-   */
-  function _templatizeIdPaths(itemTemplate, paths) {
-      paths.forEach(path => {
-          const id = common__namespace.getProp(itemTemplate, path);
-          _templatizeIdPath(itemTemplate, path, id);
-      });
-  }
-  /**
-   * Templatizes id property for the path provided
-   *
-   * @param itemTemplate The solution item template
-   * @param path A path to an id property
-   * @param id The base id to use when templatizing
-   * @private
-   */
-  function _templatizeIdPath(itemTemplate, path, id) {
-      common__namespace.setProp(itemTemplate, path, common__namespace.templatizeTerm(id, id, ".itemId"));
-  }
-  /**
-   * Templatize field references for datasources and widgets.
-   *
-   * @param solutionTemplate The solution item template
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns The solutionTemplate with templatized field references
-   */
-  function postProcessFieldReferences$2(solutionTemplate, datasourceInfos) {
-      // handle datasources common for WAB apps
-      const dataSources = common__namespace.getProp(solutionTemplate, "data.dataSource.dataSources");
-      if (dataSources && Object.keys(dataSources).length > 0) {
-          Object.keys(dataSources).forEach(k => {
-              const ds = dataSources[k];
-              dataSources[k] = _templatizeObject(ds, datasourceInfos);
-          });
-          common__namespace.setProp(solutionTemplate, "data.dataSource.dataSources", dataSources);
-      }
-      // handle widgets common for WAB apps
-      const paths = [
-          "data.widgetPool.widgets",
-          "data.widgetOnScreen.widgets"
-      ];
-      paths.forEach(path => {
-          const widgets = common__namespace.getProp(solutionTemplate, path);
-          if (widgets) {
-              common__namespace.setProp(solutionTemplate, path, _templatizeObjectArray(widgets, datasourceInfos));
-          }
-      });
-      // handle values common for web app templates
-      const values = common__namespace.getProp(solutionTemplate, "data.values");
-      if (values) {
-          common__namespace.setProp(solutionTemplate, "data.values", _templatizeObject(values, datasourceInfos));
-      }
-      return solutionTemplate;
-  }
-  /**
-   * Templatize field references for given dataSource from the web application.
-   *
-   * @param obj The dataSource or widget object from the web application.
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns The dataSource with templatized field references
-   * @private
-   */
-  function _templatizeObject(obj, datasourceInfos, templatizeKeys = false) {
-      obj = _prioritizedTests(obj, datasourceInfos, templatizeKeys);
-      const replaceOrder = _getReplaceOrder(obj, datasourceInfos);
-      replaceOrder.forEach(ds => {
-          obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
-      });
-      return obj;
-  }
-  /**
-   * Templatize field references from an array of various objects from the web application.
-   *
-   * @param objects A list of widgets or objects from the web application that may contain field references.
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns The widgets with templatized field references
-   * @private
-   */
-  function _templatizeObjectArray(objects, datasourceInfos) {
-      const updateKeyObjects = ["SmartEditor", "Screening"];
-      return objects.map(obj => {
-          // only templatize the config and lower
-          if (obj.config) {
-              const templatizeKeys = updateKeyObjects.indexOf(obj.name) > -1;
-              obj.config = _templatizeObject(obj.config, datasourceInfos, templatizeKeys);
-          }
-          return obj;
-      });
-  }
-  /**
-   * Gets an order for testing wit the various datasource info objects against the widget or dataSource.
-   * A widget or dataSource that contain a layers url or webmap layer id are more likely
-   * to have field references from that layer.
-   *
-   * @param obj The dataSource or widget object from the web application.
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns A list of datasourceInfo objects sorted based on the presence of a layers url or id
-   * @private
-   */
-  function _getReplaceOrder(obj, datasourceInfos) {
-      const objString = JSON.stringify(obj);
-      // If we don't find any layer url, web map layer id, service url, agol itemId then remove the datasource.
-      const _datasourceInfos = datasourceInfos.filter(ds => _getSortOrder(ds, objString) < 4);
-      return _datasourceInfos.sort((a, b) => {
-          return _getSortOrder(a, objString) - _getSortOrder(b, objString);
-      });
-  }
-  /**
-   * Determine an order for checking field names against a dataSource or widget.
-   * Sort order preference is set in this order: layer url, web map layer id, service url, agol itemId
-   *
-   * @param datasourceInfo The datasource object with key properties about the service.
-   * @param testString A stringified version of a widget or dataSource
-   * @returns The prioritized order for testing
-   * @private
-   */
-  function _getSortOrder(datasourceInfo, testString) {
-      const url = datasourceInfo.url;
-      const itemId = datasourceInfo.itemId;
-      const layerId = datasourceInfo.layerId;
-      // if we have the url and the layerID and its found prioritize it first
-      // else if we find the maps layer id prioritze it first
-      let layerUrlTest;
-      if (url && !isNaN(layerId)) {
-          layerUrlTest = new RegExp(url.replace(/[.]/, ".layer" + layerId + "."), "gm");
-      }
-      if (layerUrlTest && layerUrlTest.test(testString)) {
-          return 1;
-      }
-      else if (datasourceInfo.ids.length > 0) {
-          if (datasourceInfo.ids.some(id => {
-              const layerMapIdTest = new RegExp(id, "gm");
-              return layerMapIdTest.test(testString);
-          })) {
-              return 1;
-          }
-      }
-      // if neither full layer url or map layer id are found...check to see if we can
-      // find the base service url
-      if (url) {
-          const serviceUrlTest = new RegExp(url, "gm");
-          if (serviceUrlTest.test(testString)) {
-              return 2;
-          }
-      }
-      // if none of the above see if we can find an AGOL item id reference
-      if (itemId) {
-          const itemIdTest = new RegExp(itemId, "gm");
-          if (itemIdTest.test(testString)) {
-              return 3;
-          }
-      }
-      return 4;
-  }
-  /**
-   * These tests will run prior to the tests associated with the higher level tests based on sort order.
-   * The tests work more like cloning an object where we go through and review each individual property.
-   * If we find a url or webmap layer id we will templatize the parent object that contains this property.
-   * Many widgets will store one of these two properties in an object that will also contain various field references.
-   *
-   * @param obj The dataSource or widget object from the application
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns An updated instance of the dataSource or widget with as many field references templatized as possible.
-   * @private
-   */
-  function _prioritizedTests(obj, datasourceInfos, templatizeKeys) {
-      const objString = JSON.stringify(obj);
-      const hasDatasources = datasourceInfos.filter(ds => {
-          let urlTest;
-          if (ds.url && !isNaN(ds.layerId)) {
-              urlTest = new RegExp(ds.url.replace(/[.]/, ".layer" + ds.layerId + "."), "gm");
-          }
-          let hasMapLayerId = false;
-          if (ds.ids.length > 0) {
-              hasMapLayerId = ds.ids.some(id => {
-                  const idTest = new RegExp(id, "gm");
-                  return idTest.test(objString);
-              });
-          }
-          if (hasMapLayerId || (urlTest && urlTest.test(objString))) {
-              return ds;
-          }
-      });
-      if (hasDatasources.length > 0) {
-          hasDatasources.forEach(ds => {
-              // specific url reference is the most common
-              obj = _templatizeParentByURL(obj, ds, templatizeKeys);
-              if (ds.ids.length > 0) {
-                  // the second most common is to use the layerId from the webmap
-                  ds.ids.forEach(id => {
-                      obj = _templatizeParentByWebMapLayerId(obj, ds, id, templatizeKeys);
-                  });
-              }
-          });
-      }
-      return obj;
-  }
-  /**
-   * This is very close to common.cloneObject but will test if an object
-   * has one of the datasource urls as a property. If it finds one it will
-   * templatize it's parent based on the fields from that datasource
-   *
-   * @param obj The dataSource or widget object from the application
-   * @param ds A datasourceInfo object to use for testing against the current dataSource or widget
-   * @returns The updated instance of the object with as many field references templatized as possible
-   * @private
-   */
-  function _templatizeParentByURL(obj, ds, templatizeKeys) {
-      let clone = {};
-      const url = ds.url;
-      const layerId = ds.layerId;
-      let urlTest;
-      if (url && !isNaN(layerId)) {
-          urlTest = new RegExp(url.replace(/[.]/, ".layer" + layerId + "."), "gm");
-      }
-      if (Array.isArray(obj)) {
-          clone = obj.map(c => {
-              return _templatizeParentByURL(c, ds, templatizeKeys);
-          });
-      }
-      else if (typeof obj === "object") {
-          for (const i in obj) {
-              if (obj[i] != null && typeof obj[i] === "object") {
-                  clone[i] = _templatizeParentByURL(obj[i], ds, templatizeKeys);
-              }
-              else {
-                  if (urlTest && urlTest.test(obj[i])) {
-                      obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
-                  }
-                  clone[i] = obj[i];
-              }
-          }
-      }
-      else {
-          clone = obj;
-      }
-      return clone;
-  }
-  /**
-   * This is very close to common.cloneObject but will test if an object
-   * has one of the datasource webmap layer ids as a property. If it finds one it will
-   * templatize it's parent based on the fields from that datasource.
-   *
-   * @param obj The dataSource or widget object from the application
-   * @param ds A datasourceInfo object to use for testing against the current dataSource or widget
-   * @param id A webmap layer id to test with.
-   * @returns The updated instance of the object with as many field references templatized as possible
-   * @private
-   */
-  function _templatizeParentByWebMapLayerId(obj, ds, id, templatizeKeys) {
-      let clone = {};
-      const idTest = new RegExp(id, "gm");
-      if (Array.isArray(obj)) {
-          clone = obj.map(c => {
-              return _templatizeParentByWebMapLayerId(c, ds, id, templatizeKeys);
-          });
-      }
-      else if (typeof obj === "object") {
-          for (const i in obj) {
-              if (obj[i] !== null) {
-                  // In some web application templates they store a stringified version of an object that can
-                  // contain multiple layer references at a very high level on the main values collection.
-                  // This was causing many other more typical layer references to be set incorrectly as the first
-                  // layerId found in this high level string would be used against the main object.
-                  let parsedProp;
-                  try {
-                      parsedProp = JSON.parse(obj[i]);
-                  }
-                  catch (error) {
-                      parsedProp = undefined;
-                  }
-                  if (parsedProp && typeof parsedProp === "object") {
-                      clone[i] = JSON.stringify(_templatizeParentByWebMapLayerId(parsedProp, ds, id, templatizeKeys));
-                  }
-                  else if (typeof obj[i] === "object") {
-                      // some widgets store the layerId as a key to a collection of details that contain field references
-                      if (idTest.test(i) && templatizeKeys) {
-                          obj[i] = common__namespace.templatizeFieldReferences(obj[i], ds.fields, ds.basePath, templatizeKeys);
-                      }
-                      clone[i] = _templatizeParentByWebMapLayerId(obj[i], ds, id, templatizeKeys);
-                  }
-                  else {
-                      if (idTest.test(obj[i])) {
-                          obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
-                      }
-                      clone[i] = obj[i];
-                  }
-              }
-              else {
-                  clone[i] = obj[i];
-              }
-          }
-      }
-      else {
-          clone = obj;
-      }
-      return clone;
-  }
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  /**
-   * Converts an workforce item to a template.
-   *
-   * @param itemTemplate template for the workforce project item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns templatized itemTemplate
-   */
-  function convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication, templateDictionary) {
-      return common__namespace.convertWorkforceItemToTemplate(itemTemplate, srcAuthentication, templateDictionary);
-  }
-  /**
-   * Gets the current user and updates the dispatchers service
-   *
-   * @param newlyCreatedItem Item to be created; n.b.: this item is modified
-   * @param destinationAuthentication The session used to create the new item(s)
-   * @returns A promise that will resolve with { "success" === true || false }
-   */
-  function fineTuneCreatedItem$1(newlyCreatedItem, destinationAuthentication, templateDictionary) {
-      return common__namespace.fineTuneCreatedWorkforceItem(newlyCreatedItem, destinationAuthentication, "", templateDictionary);
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-  function createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return new Promise(resolve => {
-          // Interrupt process if progress callback returns `false`
-          if (!itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Started, 0)) {
-              itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Ignored, 0);
-              resolve(common__namespace.generateEmptyCreationResponse(template.type));
-          }
-          else {
-              // Replace the templatized symbols in a copy of the template
-              let newItemTemplate = common__namespace.cloneObject(template);
-              newItemTemplate = common__namespace.replaceInTemplate(newItemTemplate, templateDictionary);
-              // Create the item, then update its URL with its new id
-              // some fieldnames are used as keys for objects
-              // when we templatize field references for web applications we first stringify the components of the
-              // web application that could contain field references and then serach for them with a regular expression.
-              // We also need to stringify the web application when de-templatizing so it will find all of these occurrences as well.
-              if (template.type === "Web Mapping Application" && template.data) {
-                  newItemTemplate = JSON.parse(common__namespace.replaceInTemplate(JSON.stringify(newItemTemplate), templateDictionary));
-              }
-              if (template.item.thumbnail) {
-                  newItemTemplate.item.thumbnail = template.item.thumbnail; // make sure that our File is still there
-              }
-              common__namespace
-                  .createItemWithData(newItemTemplate.item, newItemTemplate.data, destinationAuthentication, templateDictionary.folderId)
-                  .then(createResponse => {
-                  // Interrupt process if progress callback returns `false`
-                  if (!itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Created, template.estimatedDeploymentCostFactor / 2, createResponse.id)) {
-                      itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Cancelled, 0);
-                      common__namespace
-                          .removeItem(createResponse.id, destinationAuthentication)
-                          .then(() => resolve(common__namespace.generateEmptyCreationResponse(template.type)), () => resolve(common__namespace.generateEmptyCreationResponse(template.type)));
-                  }
-                  else {
-                      // Add the new item to the settings
-                      templateDictionary[template.itemId] = {
-                          itemId: createResponse.id
-                      };
-                      newItemTemplate.itemId = createResponse.id;
-                      // Set the appItemId manually to get around cases where the path was incorrectly set
-                      // in legacy deployments
-                      if (newItemTemplate.type === "Web Mapping Application" &&
-                          template.data) {
-                          common__namespace.setProp(newItemTemplate, "data.appItemId", createResponse.id);
-                      }
-                      const postProcess = common__namespace.hasUnresolvedVariables(newItemTemplate.data);
-                      // Update the template again now that we have the new item id
-                      const originalURL = newItemTemplate.item.url;
-                      newItemTemplate = common__namespace.replaceInTemplate(newItemTemplate, templateDictionary);
-                      // Update relationships
-                      let relationshipsDef = Promise.resolve([]);
-                      if (newItemTemplate.relatedItems) {
-                          // Templatize references in relationships obj
-                          const updatedRelatedItems = common__namespace.replaceInTemplate(common__namespace.templatizeIds(newItemTemplate.relatedItems), templateDictionary);
-                          // Add the relationships
-                          relationshipsDef = common__namespace.addForwardItemRelationships(newItemTemplate.itemId, updatedRelatedItems, destinationAuthentication);
-                      }
-                      // Check for extra processing for web mapping application et al.
-                      let customProcDef;
-                      if (template.type === "Web Mapping Application" &&
-                          template.data &&
-                          common__namespace.hasAnyKeyword(template, [
-                              "WAB2D",
-                              "WAB3D",
-                              "Web AppBuilder"
-                          ])) {
-                          // If this is a Web AppBuilder application, we will create a Code Attachment for downloading
-                          customProcDef = fineTuneCreatedItem$2(template, newItemTemplate, templateDictionary, destinationAuthentication);
-                      }
-                      else if (template.type === "Workforce Project") {
-                          customProcDef = fineTuneCreatedItem$1(newItemTemplate, destinationAuthentication, templateDictionary);
-                      }
-                      else if (template.type === "Notebook") {
-                          customProcDef = fineTuneCreatedItem(template, newItemTemplate, templateDictionary, destinationAuthentication);
-                      }
-                      else if (originalURL !== newItemTemplate.item.url) {
-                          // For web mapping applications that are not Web AppBuilder apps
-                          customProcDef = new Promise((resolve2, reject2) => {
-                              common__namespace
-                                  .updateItemURL(createResponse.id, newItemTemplate.item.url, destinationAuthentication)
-                                  .then(() => resolve2(), reject2);
-                          });
-                      }
-                      else {
-                          customProcDef = Promise.resolve(null);
-                      }
-                      Promise.all([relationshipsDef, customProcDef]).then(() => {
-                          // Interrupt process if progress callback returns `false`
-                          if (!itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Finished, template.estimatedDeploymentCostFactor / 2, createResponse.id)) {
-                              itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Cancelled, 0);
-                              common__namespace
-                                  .removeItem(createResponse.id, destinationAuthentication)
-                                  .then(() => resolve(common__namespace.generateEmptyCreationResponse(template.type)), () => resolve(common__namespace.generateEmptyCreationResponse(template.type)));
-                          }
-                          else {
-                              resolve({
-                                  item: newItemTemplate,
-                                  id: createResponse.id,
-                                  type: newItemTemplate.type,
-                                  postProcess: postProcess
-                              });
-                          }
-                      }, () => {
-                          itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Failed, 0);
-                          resolve(common__namespace.generateEmptyCreationResponse(template.type)); // fails to deploy all resources to the item
-                      });
-                  }
-              }, () => {
-                  itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Failed, 0);
-                  resolve(common__namespace.generateEmptyCreationResponse(template.type)); // fails to create item
-              });
-          }
-      });
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-  function updateNotebookData(itemId, data, authentication) {
-      const updateOptions = {
-          id: itemId,
-          data: common.jsonToBlob(data)
-      };
-      return common.updateItem(updateOptions, authentication);
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-
-  var notebookHelpers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createItemFromTemplate: createItemFromTemplate$3,
-    convertItemToTemplate: convertItemToTemplate$1,
-    updateNotebookData: updateNotebookData
-  });
-
-  /** @license
-   * Copyright 2020 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.
-   */
-  /**
-   * Converts a notebook item into a template.
-   *
-   * @param solutionItemId The solution to contain the template
-   * @param itemInfo Info about the item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
-   * @returns A promise that will resolve when the template has been created
-   */
-  function convertItemToTemplate$5(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
-      // Delegate back to simple-types, which will in-turn delegate
-      // to convertNotebookToTemplate at the correct point in the process
-      // This is a temporary refactor step
-      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
-  }
-  // Delegate back to simple-types
-  // This is a temporary refactor step
-  function createItemFromTemplate$2(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
-  }
-  /**
-   * Converts a Python Notebook item to a template.
-   *
-   * @param itemTemplate template for the Python Notebook
-   * @returns templatized itemTemplate
-   */
-  function convertNotebookToTemplate(itemTemplate) {
-      // The templates data to process
-      const data = itemTemplate.data;
-      deleteProps(data);
-      let dataString = JSON.stringify(data);
-      const idTest = /[0-9A-F]{32}/gim;
-      if (data && idTest.test(dataString)) {
-          const ids = dataString.match(idTest);
-          const verifiedIds = [];
-          ids.forEach(id => {
-              if (verifiedIds.indexOf(id) === -1) {
-                  verifiedIds.push(id);
-                  // templatize the itemId--but only once per unique id
-                  const regEx = new RegExp(id, "gm");
-                  dataString = dataString.replace(regEx, "{{" + id + ".itemId}}");
-                  // update the dependencies
-                  if (itemTemplate.dependencies.indexOf(id) === -1) {
-                      itemTemplate.dependencies.push(id);
-                  }
-              }
-          });
-          itemTemplate.data = JSON.parse(dataString);
-      }
-      return itemTemplate;
-  }
-  /**
-   * Remove interpreter and papermill props
-   *
-   * This function will update the data passed in by removing key props
-   *
-   * @param data The notebooks data object
-   *
-   */
-  function deleteProps(data) {
-      /* istanbul ignore else */
-      if (data) {
-          const props = ["metadata.interpreter", "metadata.papermill"];
-          common__namespace.deleteProps(data, props);
-          (data.cells || []).forEach((cell) => {
-              common__namespace.deleteProps(cell, props);
-          });
-      }
-  }
-  /**
-   * Update the notebooks data
-   *
-   * @param originalTemplate The original template item
-   * @param newlyCreatedItem The current item that may have unswapped variables
-   * @param templateDictionary Hash of facts: org URL, adlib replacements, deferreds for dependencies
-   * @param authentication Credentials for the requests to the destination
-   *
-   * @returns A promise that will resolve once any updates have been made
-   */
-  function fineTuneCreatedItem(originalTemplate, newlyCreatedItem, templateDictionary, authentication) {
-      return new Promise((resolve, reject) => {
-          const updateOptions = {
-              id: newlyCreatedItem.itemId,
-              url: newlyCreatedItem.item.url,
-              data: common__namespace.jsonToFile(newlyCreatedItem.data, newlyCreatedItem.itemId + ".ipynb")
-          };
-          common__namespace
-              .updateItem(updateOptions, authentication)
-              .then(() => resolve(null), reject);
-      });
-  }
-  /**
-   * Notebook specific post-processing actions
-   *
-   * @param {string} itemId The item ID
-   * @param {string} type The template type
-   * @param {any[]} itemInfos Array of \{id: 'ef3', type: 'Web Map'\} objects
-   * @param {any} templateDictionary The template dictionary
-   * @param {UserSession} authentication The destination session info
-   * @returns {Promise<any>}
-   */
-  function postProcess$2(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
-      return common__namespace.updateItemTemplateFromDictionary(itemId, templateDictionary, authentication);
-  }
-
-  var notebook = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convertItemToTemplate: convertItemToTemplate$5,
-    createItemFromTemplate: createItemFromTemplate$2,
-    convertNotebookToTemplate: convertNotebookToTemplate,
-    deleteProps: deleteProps,
-    fineTuneCreatedItem: fineTuneCreatedItem,
-    postProcess: postProcess$2
-  });
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  // ------------------------------------------------------------------------------------------------------------------ //
-  /**
-   * Converts an AGOL OIC (Oriented Imagery Catalog) item to a template.
-   *
-   * @param itemTemplate Template for the OIC (Oriented Imagery Catalog) item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @returns Template for the solution item that contains key details for item reconstruction
-   */
-  function convertItemToTemplate$4(itemTemplate, destAuthentication, srcAuthentication) {
-      return new Promise((resolve, reject) => {
-          // Extract dependencies
-          _extractDependencies$1(itemTemplate, srcAuthentication).then((results) => {
-              itemTemplate.dependencies = results.dependencies;
-              // Templatize the map layer ids after we've extracted them as dependencies
-              /* istanbul ignore else */
-              if (itemTemplate.data?.properties) {
-                  itemTemplate.data.properties.ServiceURL = _templatizeOicLayerUrl(itemTemplate.data.properties.ServiceURL, results.urlHash);
-                  itemTemplate.data.properties.OverviewURL = _templatizeOicLayerUrl(itemTemplate.data.properties.OverviewURL, results.urlHash);
-              }
-              resolve(itemTemplate);
-          }, e => reject(common__namespace.fail(e)));
-      });
-  }
-  /**
-   * Gets the ids of the dependencies of an AGOL OIC (Oriented Imagery Catalog) item.
-   *
-   * @param itemTemplate A OIC (Oriented Imagery Catalog) item whose dependencies are sought
-   * @param authentication Credentials for any requests
-   * @returns List of dependencies ids and url/itemId hash
-   * @private
-   */
-  function _extractDependencies$1(itemTemplate, authentication) {
-      return new Promise((resolve, reject) => {
-          const dependencies = [];
-          if (itemTemplate.data?.properties) {
-              const layerURLs = [];
-              /* istanbul ignore else */
-              if (itemTemplate.data.properties.ServiceURL) {
-                  layerURLs.push(itemTemplate.data.properties.ServiceURL);
-              }
-              /* istanbul ignore else */
-              if (itemTemplate.data.properties.OverviewURL &&
-                  itemTemplate.data.properties.OverviewURL !==
-                      itemTemplate.data.properties.ServiceURL) {
-                  layerURLs.push(itemTemplate.data.properties.OverviewURL);
-              }
-              _getLayerIds$1(layerURLs, dependencies, authentication).then(results => {
-                  resolve(results);
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve({
-                  dependencies: dependencies,
-                  urlHash: {}
-              });
-          }
-      });
-  }
-  /**
-   * Extracts the AGOL itemId for each layer in a list using the url.
-   *
-   * @param layerURLs List of OIC layer URLs
-   * @param dependencies Current list of dependencies
-   * @param authentication Credentials for any requests
-   * @returns List of dependencies ids and url/itemId hash
-   * @private
-   */
-  function _getLayerIds$1(layerURLs, dependencies, authentication) {
-      return new Promise((resolve, reject) => {
-          const urlHash = {};
-          const options = {
-              f: "json",
-              authentication: authentication
-          };
-          const layerPromises = [];
-          const layerChecks = {};
-          const filteredLayerURLs = layerURLs.filter(layerURL => {
-              if (layerURL) {
-                  const results = /.+FeatureServer/g.exec(layerURL);
-                  const baseUrl = Array.isArray(results) && results.length > 0 ? results[0] : undefined;
-                  if (baseUrl) {
-                      // avoid redundant checks when we have a layer with subLayers
-                      /* istanbul ignore else */
-                      if (Object.keys(layerChecks).indexOf(baseUrl) < 0) {
-                          layerChecks[baseUrl] = common__namespace.rest_request(layerURL, options);
-                      }
-                      layerPromises.push(layerChecks[baseUrl]);
-                      return true;
-                  }
-                  else {
-                      return false;
-                  }
-              }
-              else {
-                  return false;
-              }
-          });
-          if (layerPromises.length > 0) {
-              Promise.all(layerPromises).then(serviceResponses => {
-                  serviceResponses.forEach((serviceResponse, i) => {
-                      /* istanbul ignore else */
-                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
-                          const id = serviceResponse.serviceItemId;
-                          /* istanbul ignore else */
-                          if (dependencies.indexOf(id) < 0) {
-                              dependencies.push(id);
-                          }
-                          urlHash[filteredLayerURLs[i]] = id;
-                      }
-                  });
-                  resolve({
-                      dependencies: dependencies,
-                      urlHash: urlHash
-                  });
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve({
-                  dependencies: dependencies,
-                  urlHash: urlHash
-              });
-          }
-      });
-  }
-  /**
-   * Templatizes the url and item id for a layer.
-   *
-   * @param layerURL OIC layer URL
-   * @param urlHash Lookup object for analysis layers
-   * @returns Templatized URL if layerURL is in the urlHash
-   * @private
-   */
-  function _templatizeOicLayerUrl(layerURL, urlHash) {
-      let templatizedURL = layerURL;
-      if (layerURL) {
-          const id = urlHash[layerURL];
-          if (id) {
-              const layerId = layerURL.substr(layerURL.lastIndexOf("/") + 1);
-              templatizedURL = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url");
-          }
-          // replace everything up until /home with portalBaseUrl var and templatize the itemId
-          templatizedURL = common__namespace.templatizeIds(templatizedURL.replace(/.+?(?=\/home)/, "{{portalBaseUrl}}"));
-      }
-      return templatizedURL;
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-
-  var quickcaptureHelpers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createItemFromTemplate: createItemFromTemplate$3,
-    convertItemToTemplate: convertItemToTemplate$1
-  });
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  //#region Publish Process ---------------------------------------------------------------------------------------//
-  /**
-   * Converts a Quick Capture item into a template.
-   *
-   * @param solutionItemId The solution to contain the template
-   * @param itemInfo Info about the item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
-   * @returns A promise that will resolve when the template has been created
-   */
-  function convertItemToTemplate$3(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
-      // Delegate back to simple-types, which will in-turn delegate
-      // to convertNotebookToTemplate at the correct point in the process
-      // This is a temporary refactor step
-      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
-  }
-  /**
-   * Converts an quick capture item to a template.
-   *
-   * @param itemTemplate template for the quick capture project item
-   * @returns templatized itemTemplate
-   */
-  function convertQuickCaptureToTemplate(itemTemplate) {
-      return new Promise((resolve, reject) => {
-          // The templates data to process
-          const data = itemTemplate.data;
-          if (data && Array.isArray(data)) {
-              let applicationRequest = Promise.resolve(null);
-              let applicationName = "";
-              data.some((item) => {
-                  if (item.type === "application/json") {
-                      applicationName = item.name;
-                      applicationRequest = common__namespace.getBlobText(item);
-                      return true;
-                  }
-              });
-              applicationRequest.then(result => {
-                  // replace the template data array with the templatized application JSON
-                  itemTemplate.data = result
-                      ? {
-                          application: _templatizeApplication(JSON.parse(result), itemTemplate),
-                          name: applicationName
-                      }
-                      : {};
-                  resolve(itemTemplate);
-              }, reject);
-          }
-          else {
-              resolve(itemTemplate);
-          }
-      });
-  }
-  /**
-   * Templatizes key properties for a quick capture project and gathers item dependencies
-   *
-   * @param data the projects json
-   * @param itemTemplate template for the quick capture project item
-   * @returns templatized itemTemplate
-   * @private
-   */
-  function _templatizeApplication(data, itemTemplate) {
-      // Quick Project item id
-      _templatizeId(data, "itemId");
-      // Set the admin email
-      _templatizeAdminEmail(data);
-      // datasource item id and url
-      const dataSources = data.dataSources;
-      if (dataSources && Array.isArray(dataSources)) {
-          dataSources.forEach(ds => {
-              const id = ds.featureServiceItemId;
-              if (id) {
-                  _updateDependencies(id, itemTemplate);
-                  _templatizeUrl(ds, "featureServiceItemId", "url");
-                  _templatizeId(ds, "featureServiceItemId");
-              }
-          });
-      }
-      return data;
-  }
-  /**
-   * Templatize the email property
-   *
-   * @param data the quick capture application
-   * @private
-   */
-  function _templatizeAdminEmail(data) {
-      if (common__namespace.getProp(data, "preferences.adminEmail")) {
-          common__namespace.setProp(data, "preferences.adminEmail", "{{user.email}}");
-      }
-  }
-  /**
-   * Updates the templates dependencies list with unique item ids
-   *
-   * @param id the item id of the dependency
-   * @param itemTemplate template for the quick capture project item
-   * @returns templatized itemTemplate
-   */
-  function _updateDependencies(id, itemTemplate) {
-      if (itemTemplate.dependencies.indexOf(id) === -1) {
-          itemTemplate.dependencies.push(id);
-      }
-  }
-  /**
-   * Templatize a url property
-   *
-   * @param obj the datasource object
-   * @param idPath the path to the id property
-   * @param urlPath the path to the url property
-   * @private
-   */
-  function _templatizeUrl(obj, idPath, urlPath) {
-      const id = common__namespace.getProp(obj, idPath);
-      const url = common__namespace.getProp(obj, urlPath);
-      if (url) {
-          const layerId = url.substr(url.lastIndexOf("/") + 1);
-          common__namespace.setProp(obj, urlPath, common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url"));
-      }
-  }
-  /**
-   * Templatize the item id property
-   *
-   * @param obj the datasource or object that contains the item id property
-   * @param path the path to the id property
-   * @private
-   */
-  function _templatizeId(obj, path) {
-      const id = common__namespace.getProp(obj, path);
-      if (id) {
-          common__namespace.setProp(obj, path, common__namespace.templatizeTerm(id, id, ".itemId"));
-      }
-  }
-  //#endregion
-  //#region Deploy Process ---------------------------------------------------------------------------------------//
-  // Delegate back to simple-types
-  // This is a temporary refactor step
-  function createItemFromTemplate$1(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
-  }
-  /**
-   * QuickCapture post-processing actions
-   *
-   * @param {string} itemId The item ID
-   * @param {string} type The template type
-   * @param {any[]} itemInfos Array of \{id: 'ef3', type: 'Web Map'\} objects
-   * @param {any} templateDictionary The template dictionary
-   * @param {UserSession} authentication The destination session info
-   * @returns Promise resolving to successfulness of update
-   */
-  function postProcess$1(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
-      return new Promise((resolve, reject) => {
-          template.data = common__namespace.replaceInTemplate(template.data, templateDictionary);
-          common__namespace
-              .updateItemTemplateFromDictionary(itemId, templateDictionary, authentication)
-              .then(() => {
-              common__namespace
-                  .updateItemResourceText(itemId, template.data.name, JSON.stringify(template.data.application), authentication)
-                  .then(resolve, reject);
-          }, reject);
-      });
-  }
-  //#endregion
-
-  var quickcapture = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convertItemToTemplate: convertItemToTemplate$3,
-    convertQuickCaptureToTemplate: convertQuickCaptureToTemplate,
-    _templatizeApplication: _templatizeApplication,
-    _templatizeAdminEmail: _templatizeAdminEmail,
-    _updateDependencies: _updateDependencies,
-    _templatizeUrl: _templatizeUrl,
-    _templatizeId: _templatizeId,
-    createItemFromTemplate: createItemFromTemplate$1,
-    postProcess: postProcess$1
-  });
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  /**
-   * The portion of a Webmap URL between the server and the map id.
-   *
-   * @private
-   */
-  const WEBMAP_APP_URL_PART = "home/webmap/viewer.html?webmap=";
-  // ------------------------------------------------------------------------------------------------------------------ //
-  /**
-   * Converts an AGOL webmap item to a template.
-   *
-   * @param itemTemplate Template for the webmap item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns Template for the solution item that contains key details for item reconstruction
-   */
-  function convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication, templateDictionary) {
-      return new Promise((resolve, reject) => {
-          // Templatize the app URL
-          itemTemplate.item.url = itemTemplate.item.url ?
-              common__namespace.checkUrlPathTermination(common__namespace.placeholder(common__namespace.SERVER_NAME)) +
-                  WEBMAP_APP_URL_PART +
-                  itemTemplate.item.id : itemTemplate.item.url; // templatized id
-          // Extract dependencies
-          _extractDependencies(itemTemplate, srcAuthentication).then((results) => {
-              itemTemplate.dependencies = results.dependencies;
-              // Templatize the map layer ids after we've extracted them as dependencies
-              if (itemTemplate.data) {
-                  _templatizeWebmapLayerIdsAndUrls(itemTemplate.data.operationalLayers, results.urlHash, templateDictionary);
-                  _templatizeWebmapLayerIdsAndUrls(itemTemplate.data.tables, results.urlHash, templateDictionary);
-                  // Exclude intialState
-                  _excludeInitialState(itemTemplate.data);
-              }
-              resolve(itemTemplate);
-          }, e => reject(common__namespace.fail(e)));
-      });
-  }
-  /**
-   * Gets the ids of the dependencies of an AGOL webmap item.
-   *
-   * @param itemTemplate A webmap item whose dependencies are sought
-   * @param authentication Credentials for any requests
-   * @returns List of dependencies ids and url/itemId hash
-   * @private
-   */
-  function _extractDependencies(itemTemplate, authentication) {
-      return new Promise((resolve, reject) => {
-          const dependencies = [];
-          if (itemTemplate.data) {
-              const layers = itemTemplate.data.operationalLayers || [];
-              const tables = itemTemplate.data.tables || [];
-              const layersAndTables = layers.concat(tables);
-              _getLayerIds(layersAndTables, dependencies, authentication).then(results => {
-                  resolve(results);
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve({
-                  dependencies: dependencies,
-                  urlHash: {}
-              });
-          }
-      });
-  }
-  /**
-   * Remove the initialState prop from webmaps saved from the new map viewer.
-   * This allows the map to use the item extent property that we templatize.
-   *
-   * Added for issue #662
-   *
-   * @param data the data for the web maps item template
-   * @returns void
-   * @private
-   */
-  function _excludeInitialState(data) {
-      common__namespace.deleteProp(data, "initialState");
-  }
-  /**
-   * Extracts the AGOL itemId for each layer or table object in a list using the url.
-   *
-   * @param layerList List of map layers or tables
-   * @param dependencies Current list of dependencies
-   * @param authentication Credentials for any requests
-   * @returns List of dependencies ids and url/itemId hash
-   * @private
-   */
-  function _getLayerIds(layerList, dependencies, authentication) {
-      return new Promise((resolve, reject) => {
-          const urlHash = {};
-          const options = {
-              f: "json",
-              authentication: authentication
-          };
-          const layerPromises = [];
-          const layerChecks = {};
-          const layers = layerList.filter(layer => {
-              if (layer.url && layer.url.indexOf("{{velocityUrl}}") < 0) {
-                  const results = /.+FeatureServer/g.exec(layer.url);
-                  const baseUrl = Array.isArray(results) && results.length > 0 ? results[0] : undefined;
-                  if (baseUrl) {
-                      // avoid redundant checks when we have a layer with subLayers
-                      if (Object.keys(layerChecks).indexOf(baseUrl) < 0) {
-                          layerChecks[baseUrl] = common__namespace.rest_request(layer.url, options);
-                      }
-                      layerPromises.push(layerChecks[baseUrl]);
-                      return true;
-                  }
-                  else {
-                      return false;
-                  }
-              }
-              else {
-                  return false;
-              }
-          });
-          if (layerPromises.length > 0) {
-              Promise.all(layerPromises).then(serviceResponses => {
-                  serviceResponses.forEach((serviceResponse, i) => {
-                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
-                          const id = serviceResponse.serviceItemId;
-                          if (dependencies.indexOf(id) < 0) {
-                              dependencies.push(id);
-                          }
-                          urlHash[layers[i].url] = id;
-                      }
-                  });
-                  resolve({
-                      dependencies: dependencies,
-                      urlHash: urlHash
-                  });
-              }, e => reject(common__namespace.fail(e)));
-          }
-          else {
-              resolve({
-                  dependencies: dependencies,
-                  urlHash: urlHash
-              });
-          }
-      });
-  }
-  /**
-   * Templatizes the url and item id for layers or tables within the webmap.
-   *
-   * @param layerList List of map layers or tables
-   * @param urlHash Lookup object for analysis layers
-   * @param templateDictionary Hash of key details used for variable replacement
-   * @returns void
-   * @private
-   */
-  function _templatizeWebmapLayerIdsAndUrls(layerList = [], urlHash, templateDictionary) {
-      layerList.forEach((layer) => {
-          if (layer.url) {
-              const layerId = layer.url.substr(layer.url.lastIndexOf("/") + 1);
-              const id = Object.keys(urlHash).indexOf(layer.url) > -1
-                  ? urlHash[layer.url]
-                  : undefined;
-              if (id) {
-                  common__namespace.cacheLayerInfo(layerId, id, layer.url, templateDictionary);
-                  layer.url = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url");
-                  layer.itemId = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".itemId");
-              }
-          }
-      });
-  }
-  /**
-   * Templatize field references.
-   *
-   * @param solutionTemplate The solution item template
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns The solutionTemplate with templatized field references
-   */
-  function postProcessFieldReferences$1(solutionTemplate, datasourceInfos) {
-      const paths = [
-          "data.operationalLayers",
-          "data.tables",
-          "data.applicationProperties.viewing.search.layers"
-      ];
-      paths.forEach(p => _templatizeProperty(solutionTemplate, datasourceInfos, p));
-      return solutionTemplate;
-  }
-  /**
-   * Templatize field references.
-   *
-   * @param solutionTemplate The solution item template
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @param path A string path to the object property to templatize
-   * @private
-   */
-  function _templatizeProperty(solutionTemplate, datasourceInfos, path) {
-      const objs = common__namespace.getProp(solutionTemplate, path);
-      if (objs) {
-          common__namespace.setProp(solutionTemplate, path, _templatize(objs, datasourceInfos));
-      }
-  }
-  /**
-   * Templatize field references.
-   *
-   * @param objs Can be operationalLayers or tables or appProperties search layers
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns updated instances of the objects
-   * @private
-   */
-  function _templatize(objs, datasourceInfos) {
-      objs.forEach(obj => {
-          const ds = _getDatasourceInfo(obj, datasourceInfos);
-          if (ds) {
-              const fieldNames = ds.fields.map(f => f.name);
-              common__namespace._templatizePopupInfo(obj, ds, ds.basePath, ds.itemId, fieldNames);
-              common__namespace._templatizeDefinitionEditor(obj, ds.basePath, fieldNames);
-              if (obj.layerDefinition) {
-                  common__namespace._templatizeDrawingInfo(obj.layerDefinition, ds.basePath, fieldNames);
-                  common__namespace._templatizeDefinitionExpression(obj.layerDefinition, ds.basePath, fieldNames);
-              }
-              // used for applicationProperties search layers
-              const fieldName = common__namespace.getProp(obj, "field.name");
-              if (fieldName) {
-                  common__namespace.setProp(obj, "field.name", common__namespace._templatizeFieldName(fieldName, obj, ds.itemId, ds.basePath));
-              }
-          }
-      });
-      return objs;
-  }
-  /**
-   * Get datasourceInfo by map layer id
-   *
-   * @param obj Can be operationalLayer or table or appProperties search layer
-   * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
-   * @returns datasourceInfo for the given object id
-   * @private
-   */
-  function _getDatasourceInfo(obj, datasourceInfos) {
-      let datasourceInfo;
-      datasourceInfos.some(ds => {
-          if (ds.ids.indexOf(obj.id) > -1) {
-              datasourceInfo = ds;
-              return true;
-          }
-          else {
-              return false;
-          }
-      });
-      return datasourceInfo;
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-  /**
-   * Converts an item into a template.
-   *
-   * @param solutionItemId The solution to contain the template
-   * @param itemInfo Info about the item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
-   *
-   * @returns A promise that will resolve when the template has been created
-   */
-  function convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
-      return new Promise((resolve, reject) => {
-          // Init template
-          const itemTemplate = common__namespace.createInitializedItemTemplate(itemInfo);
-          // Templatize item info property values
-          itemTemplate.item.id = common__namespace.templatizeTerm(itemTemplate.item.id, itemTemplate.item.id, ".itemId");
-          // Request related items
-          const relatedPromise = common__namespace.getItemRelatedItemsInSameDirection(itemTemplate.itemId, "forward", srcAuthentication);
-          // Perform type-specific handling
-          let dataPromise = Promise.resolve({});
-          let resourcesPromise = Promise.resolve([]);
-          switch (itemInfo.type) {
-              case "Dashboard":
-              case "Feature Collection":
-              case "Feature Service":
-              case "Hub Initiative":
-              case "Hub Page":
-              case "Hub Site Application":
-              case "Insights Model":
-              case "Oriented Imagery Catalog":
-              case "Project Package":
-              case "Workforce Project":
-              case "Web Map":
-              case "Web Mapping Application":
-              case "Web Scene":
-              case "Notebook":
-                  dataPromise = new Promise(resolveJSON => {
-                      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                      common__namespace
-                          .getItemDataAsJson(itemTemplate.itemId, srcAuthentication)
-                          .then(json => resolveJSON(json));
-                  });
-                  break;
-              case "Form":
-                  dataPromise = common__namespace.getItemDataAsFile(itemTemplate.itemId, itemTemplate.item.name, srcAuthentication);
-                  break;
-              case "QuickCapture Project":
-                  dataPromise = new Promise(resolveJSON => {
-                      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                      common__namespace
-                          .getItemDataAsJson(itemTemplate.itemId, srcAuthentication)
-                          .then(json => resolveJSON(json));
-                  });
-                  resourcesPromise = common__namespace.getItemResourcesFiles(itemTemplate.itemId, srcAuthentication);
-                  break;
-          }
-          // Errors are handled as resolved empty values; this means that there's no `reject` clause to handle, hence:
-          // eslint-disable-next-line @typescript-eslint/no-floating-promises
-          Promise.all([dataPromise, relatedPromise, resourcesPromise]).then(responses => {
-              const [itemDataResponse, relatedItemsResponse, resourcesResponse] = responses;
-              // need to pre-process for velocity urls before they could be templatized by other processors
-              itemTemplate.data = common__namespace.updateVelocityReferences(itemDataResponse, itemInfo.type, templateDictionary);
-              const relationships = relatedItemsResponse;
-              // Save the mappings to related items & add those items to the dependencies, but not WMA Code Attachments
-              itemTemplate.dependencies = [];
-              itemTemplate.relatedItems = [];
-              relationships.forEach(relationship => {
-                  /* istanbul ignore else */
-                  if (relationship.relationshipType !== "WMA2Code") {
-                      itemTemplate.relatedItems.push(relationship);
-                      relationship.relatedItemIds.forEach(relatedItemId => {
-                          if (itemTemplate.dependencies.indexOf(relatedItemId) < 0) {
-                              itemTemplate.dependencies.push(relatedItemId);
-                          }
-                      });
-                  }
-              });
-              // Add QuickCapture basemap webmap references
-              if (itemInfo.type === "QuickCapture Project") {
-                  const basemap = itemDataResponse?.application?.basemap;
-                  if (basemap?.type === "WebMap") {
-                      itemTemplate.dependencies.push(basemap.itemId);
-                  }
-                  itemTemplate.resources = resourcesResponse;
-              }
-              // Create the template
-              let templateModifyingPromise = Promise.resolve(itemTemplate);
-              switch (itemInfo.type) {
-                  case "Dashboard":
-                      convertItemToTemplate$8(itemTemplate, templateDictionary);
-                      break;
-                  case "Form":
-                      // Store the form's data in the solution resources, not in template
-                      itemTemplate.data = null;
-                      // Add the form data to the template for a post-process resource upload
-                      if (itemDataResponse) {
-                          itemTemplate.item.name = _getFormDataFilename(itemTemplate.item.name, itemDataResponse.name, `${itemTemplate.itemId}.zip`);
-                          const storageName = common__namespace.convertItemResourceToStorageResource(itemTemplate.itemId, itemTemplate.item.name, common__namespace.SolutionTemplateFormatVersion, common__namespace.SolutionResourceType.data);
-                          // Add the data file to the template so that it can be uploaded with the other resources in the solution
-                          const dataFile = {
-                              itemId: itemTemplate.itemId,
-                              file: itemDataResponse,
-                              folder: storageName.folder,
-                              filename: itemTemplate.item.name
-                          };
-                          itemTemplate.dataFile = dataFile;
-                          // Update the template's resources
-                          itemTemplate.resources.push(storageName.folder + "/" + storageName.filename);
-                      }
-                      break;
-                  case "Notebook":
-                      convertNotebookToTemplate(itemTemplate);
-                      break;
-                  case "Oriented Imagery Catalog":
-                      templateModifyingPromise = convertItemToTemplate$4(itemTemplate, destAuthentication, srcAuthentication);
-                      break;
-                  case "Web Map":
-                  case "Web Scene":
-                      templateModifyingPromise = convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication, templateDictionary);
-                      break;
-                  case "Web Mapping Application":
-                      if (itemDataResponse) {
-                          templateModifyingPromise = convertItemToTemplate$7(itemTemplate, destAuthentication, srcAuthentication, templateDictionary);
-                      }
-                      break;
-                  case "Workforce Project":
-                      templateModifyingPromise = convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication, templateDictionary);
-                      break;
-                  case "QuickCapture Project":
-                      templateModifyingPromise = convertQuickCaptureToTemplate(itemTemplate);
-                      break;
-              }
-              templateModifyingPromise.then(resolve, err => reject(common__namespace.fail(err)));
-          });
-      });
-  }
-  /**
-   * Encapsulates the rules for naming a form's data file.
-   * Chooses the first parameter that's defined and is not the string "undefined".
-   *
-   * @param itemName Template's item name
-   * @param dataFilename The data file name
-   * @param itemIdAsName A name constructed from the template's id suffixed with ".zip"
-   *
-   * @return A name for the data file
-   */
-  function _getFormDataFilename(itemName, dataFilename, itemIdAsName) {
-      const originalFilename = itemName || dataFilename;
-      const filename = originalFilename && originalFilename !== "undefined"
-          ? originalFilename
-          : itemIdAsName;
-      return filename;
-  }
-
-  /** @license
-   * Copyright 2020 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.
-   */
-
-  var simpleTypeHelpers = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createItemFromTemplate: createItemFromTemplate$3,
-    convertItemToTemplate: convertItemToTemplate$1
-  });
-
-  /** @license
-   * Copyright 2018 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.
-   */
-  /**
-   * Converts an item into a template.
-   *
-   * @param solutionItemId The solution to contain the template
-   * @param itemInfo Info about the item
-   * @param destAuthentication Credentials for requests to the destination organization
-   * @param srcAuthentication Credentials for requests to source items
-   * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
-   * @returns A promise that will resolve when the template has been created
-   */
-  function convertItemToTemplate(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
-      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
-  }
-  /**
-   * Delegate to simpleType creator
-   *
-   * @param template
-   * @param templateDictionary
-   * @param destinationAuthentication
-   * @param itemProgressCallback
-   */
-  function createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
-  }
-  /**
-   * Templatizes field references within specific template types.
-   * Currently only handles web mapping applications
-   *
-   * @param template A solution template
-   * @param datasourceInfos A list of objects that store key datasource info used to templatizing field references
-   * @param type The item type
-   * @returns The updated solution template
-   */
-  function postProcessFieldReferences(solutionTemplate, datasourceInfos, type) {
-      switch (type) {
-          case "Web Mapping Application":
-              postProcessFieldReferences$2(solutionTemplate, datasourceInfos);
-              break;
-          case "Dashboard":
-              postProcessFieldReferences$3(solutionTemplate, datasourceInfos);
-              break;
-          case "Web Map":
-              postProcessFieldReferences$1(solutionTemplate, datasourceInfos);
-              break;
-      }
-      return solutionTemplate;
-  }
-  /**
-   * Simple Type post-processing actions
-   *
-   * @param {string} itemId The item ID
-   * @param {string} type The template type
-   * @param {any[]} itemInfos Array of \{id: 'ef3', type: 'Web Map'\} objects
-   * @param {any} templateDictionary The template dictionary
-   * @param {UserSession} authentication The destination session info
-   * @returns Promise resolving to successfulness of update
-   */
-  function postProcess(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
-      return common.updateItemTemplateFromDictionary(itemId, templateDictionary, authentication);
-  }
-
-  var simpleTypes = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    convertItemToTemplate: convertItemToTemplate,
-    createItemFromTemplate: createItemFromTemplate,
-    postProcessFieldReferences: postProcessFieldReferences,
-    postProcess: postProcess
-  });
-
-  exports.notebookHelpers = notebookHelpers;
-  exports.notebookProcessor = notebook;
-  exports.quickcaptureHelpers = quickcaptureHelpers;
-  exports.quickcaptureProcessor = quickcapture;
-  exports.simpleTypeHelpers = simpleTypeHelpers;
-  exports.simpleTypes = simpleTypes;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=simple-types.umd.js.map