@esri/solution-simple-types 1.1.5 → 1.2.0

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

@@ -1,7 +1,7 @@
 /* @preserve
-* @esri/solution-simple-types - v1.1.5 - Apache-2.0
+* @esri/solution-simple-types - v1.2.0 - Apache-2.0
 * Copyright (c) 2018-2021 Esri, Inc.
-* Tue Nov 16 2021 07:12:29 GMT-0800 (Pacific Standard Time)
+* Thu Dec 09 2021 16:04:06 GMT-0800 (Pacific Standard Time)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -18,8 +18,28 @@
 (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 = global || self, factory(global.arcgisSolution = global.arcgisSolution || {}, global.arcgisSolution));
-}(this, (function (exports, common) { 'use strict';
+  (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
@@ -42,8 +62,8 @@
    * @param itemTemplate Template for the dashboard item
    * @return templatized itemTemplate
    */
-  function convertItemToTemplate(itemTemplate) {
-      return _extractDependencies(itemTemplate);
+  function convertItemToTemplate$8(itemTemplate) {
+      return _extractDependencies$3(itemTemplate);
   }
   /**
    * Templatizes all itemIds and updates the dependency array
@@ -52,7 +72,7 @@
    * @return The updated itemTemplate
    * @protected
    */
-  function _extractDependencies(itemTemplate) {
+  function _extractDependencies$3(itemTemplate) {
       // get dependencies from any
       const updatePaths = [
           "data.widgets",
@@ -61,7 +81,7 @@
           "data.urlParameters"
       ];
       updatePaths.forEach(path => {
-          const objs = common.getProp(itemTemplate, path);
+          const objs = common__namespace.getProp(itemTemplate, path);
           if (Array.isArray(objs)) {
               objs.forEach(obj => {
                   /* istanbul ignore else */
@@ -70,7 +90,7 @@
                       if (itemTemplate.dependencies.indexOf(obj.itemId) < 0) {
                           itemTemplate.dependencies.push(obj.itemId);
                       }
-                      obj.itemId = common.templatizeTerm(obj.itemId, obj.itemId, ".itemId");
+                      obj.itemId = common__namespace.templatizeTerm(obj.itemId, obj.itemId, ".itemId");
                   }
                   /* istanbul ignore else */
                   if (Array.isArray(obj.datasets)) {
@@ -90,16 +110,16 @@
   function _getDatasourceDependencies(obj, itemTemplate) {
       obj.datasets.forEach((dataset) => {
           // when the datasource has an itemId is an external datasource
-          const itemId = common.getProp(dataset, "dataSource.itemId");
+          const itemId = common__namespace.getProp(dataset, "dataSource.itemId");
           if (itemId) {
               if (itemTemplate.dependencies.indexOf(itemId) < 0) {
                   itemTemplate.dependencies.push(itemId);
               }
-              const layerId = common.getProp(dataset, "dataSource.layerId");
-              dataset.dataSource.itemId = common.templatizeTerm(itemId, itemId, layerId !== undefined ? ".layer" + layerId + ".itemId" : ".itemId");
+              const layerId = common__namespace.getProp(dataset, "dataSource.layerId");
+              dataset.dataSource.itemId = common__namespace.templatizeTerm(itemId, itemId, layerId !== undefined ? ".layer" + layerId + ".itemId" : ".itemId");
               /* istanbul ignore else */
               if (layerId !== undefined) {
-                  dataset.dataSource.layerId = common.templatizeTerm(itemId, itemId, ".layer" + layerId + ".layerId");
+                  dataset.dataSource.layerId = common__namespace.templatizeTerm(itemId, itemId, ".layer" + layerId + ".layerId");
               }
           }
       });
@@ -111,7 +131,7 @@
    * @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(solutionTemplate, datasourceInfos) {
+  function postProcessFieldReferences$3(solutionTemplate, datasourceInfos) {
       const updatePaths = [
           "data.widgets",
           "data.headerPanel.selectors",
@@ -121,12 +141,12 @@
       // dashboards reference datasets from other widgets
       // add reference IDs to the appropriate datasourceInfos
       updatePaths.forEach(path => {
-          const objs = common.getProp(solutionTemplate, 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(solutionTemplate, path, datasourceInfos);
+          _templatize$1(solutionTemplate, path, datasourceInfos);
       });
       return solutionTemplate;
   }
@@ -145,9 +165,9 @@
               if (Array.isArray(obj.datasets)) {
                   obj.datasets.forEach((dataset) => {
                       // when the datasource has an itemId it's an external datasource
-                      const itemId = common.cleanLayerBasedItemId(common.getProp(dataset, "dataSource.itemId"));
+                      const itemId = common__namespace.cleanLayerBasedItemId(common__namespace.getProp(dataset, "dataSource.itemId"));
                       if (itemId) {
-                          const layerId = common.cleanLayerId(common.getProp(dataset, "dataSource.layerId"));
+                          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);
@@ -161,7 +181,7 @@
                       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.getProp(dataset, "dataSource.id");
+                          const id = common__namespace.getProp(dataset, "dataSource.id");
                           if (id) {
                               const dashboardLayerId = id.split("#")[1];
                               datasourceInfos.some(ds => {
@@ -188,11 +208,11 @@
    * @param datasourceInfos A list of objects that contain key details about the datasources from the application
    * @protected
    */
-  function _templatize(itemTemplate, path, datasourceInfos) {
-      const obj = common.getProp(itemTemplate, path);
+  function _templatize$1(itemTemplate, path, datasourceInfos) {
+      const obj = common__namespace.getProp(itemTemplate, path);
       /* istanbul ignore else */
       if (obj) {
-          common.setProp(itemTemplate, path, _templatizeByDatasource(obj, datasourceInfos));
+          common__namespace.setProp(itemTemplate, path, _templatizeByDatasource(obj, datasourceInfos));
       }
   }
   /**
@@ -220,16 +240,16 @@
                               if (_action.fieldMap &&
                                   _action.targetId &&
                                   _action.targetId.indexOf("#") > -1) {
-                                  const datasourceInfo = _getDatasourceInfo(_action, datasourceInfos);
+                                  const datasourceInfo = _getDatasourceInfo$1(_action, datasourceInfos);
                                   /* istanbul ignore else */
                                   if (datasourceInfo) {
-                                      const fields = common.getProp(datasourceInfo, "fields");
-                                      const basePath = common.getProp(datasourceInfo, "basePath");
+                                      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.templatizeFieldReferences(_m.targetName, fields, basePath);
+                                              _m.targetName = common__namespace.templatizeFieldReferences(_m.targetName, fields, basePath);
                                               return _m;
                                           });
                                       }
@@ -245,15 +265,15 @@
                   _obj.datasets = _obj.datasets.map((dataset) => {
                       let _dataset = dataset;
                       if (_dataset.type === "serviceDataset") {
-                          const datasourceInfo = _getDatasourceInfo(dataset, datasourceInfos);
+                          const datasourceInfo = _getDatasourceInfo$1(dataset, datasourceInfos);
                           /* istanbul ignore else */
                           if (datasourceInfo) {
-                              const fields = common.getProp(datasourceInfo, "fields");
-                              const basePath = common.getProp(datasourceInfo, "basePath");
+                              const fields = common__namespace.getProp(datasourceInfo, "fields");
+                              const basePath = common__namespace.getProp(datasourceInfo, "basePath");
                               /* istanbul ignore else */
                               if (Array.isArray(fields) && basePath) {
-                                  _obj = common.templatizeFieldReferences(_obj, fields, basePath);
-                                  _dataset = common.templatizeFieldReferences(_dataset, fields, basePath);
+                                  _obj = common__namespace.templatizeFieldReferences(_obj, fields, basePath);
+                                  _dataset = common__namespace.templatizeFieldReferences(_dataset, fields, basePath);
                               }
                           }
                       }
@@ -277,11 +297,11 @@
    * @return The supporting datasource info for the given object
    * @protected
    */
-  function _getDatasourceInfo(obj, datasourceInfos) {
+  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.getProp(obj, "dataSource.id") || common.getProp(obj, "targetId");
+      const id = common__namespace.getProp(obj, "dataSource.id") || common__namespace.getProp(obj, "targetId");
       if (id) {
           const dashboardLayerId = id.split("#")[1];
           if (!datasourceInfos.some(di => {
@@ -301,8 +321,8 @@
       }
       else {
           // otherwise match the itemId and the layerId to get the correct fields and path
-          const itemId = common.cleanLayerBasedItemId(common.getProp(obj, "dataSource.itemId"));
-          const layerId = common.cleanLayerId(common.getProp(obj, "dataSource.layerId"));
+          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 => {
@@ -352,7 +372,7 @@
    * @param srcAuthentication Credentials for requests to source items
    * @return A promise that will resolve when the template has been created
    */
-  function convertItemToTemplate$1(itemTemplate, destAuthentication, srcAuthentication) {
+  function convertItemToTemplate$7(itemTemplate, destAuthentication, srcAuthentication) {
       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
@@ -364,15 +384,15 @@
               const templatizedUrl = itemTemplate.item.url;
               const iSep = templatizedUrl.indexOf("//");
               itemTemplate.item.url =
-                  common.placeholder(common.SERVER_NAME) + // add placeholder server name
+                  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$1(itemTemplate);
+          itemTemplate.dependencies = _extractDependencies$2(itemTemplate);
           // Set the folder
-          common.setProp(itemTemplate, "data.folderId", "{{folderId}}");
+          common__namespace.setProp(itemTemplate, "data.folderId", "{{folderId}}");
           // Set the map or group after we've extracted them as dependencies
           _templatizeIdPaths(itemTemplate, [
               "data.map.itemId",
@@ -388,48 +408,48 @@
               "data.map.portalUrl",
               "data.portalUrl",
               "data.httpProxy.url"
-          ], common.placeholder(common.SERVER_NAME));
-          common.setProp(itemTemplate, "data.geometryService", common.placeholder(common.GEOMETRY_SERVER_NAME));
+          ], 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).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.fail(e)));
-                  }, e => reject(common.fail(e)));
-              }, e => reject(common.fail(e)));
-          }, e => reject(common.fail(e)));
+                      }, e => reject(common__namespace.fail(e)));
+                  }, e => reject(common__namespace.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
+          }, e => reject(common__namespace.fail(e)));
       });
   }
   function templatizeDatasources(itemTemplate, authentication, portalUrl) {
       return new Promise((resolve, reject) => {
-          const dataSources = common.getProp(itemTemplate, "data.dataSource.dataSources");
+          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.setProp(ds, "portalUrl", common.placeholder(common.SERVER_NAME));
-                  const itemId = common.getProp(ds, "itemId");
-                  if (common.getProp(ds, "url")) {
+                  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);
-                          ds.itemId = common.templatizeTerm(itemId, itemId, ".layer" + layerId + ".itemId");
+                          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.fail(e)));
+                          }, e => rejectReq(common__namespace.fail(e)));
                       }));
                   }
                   else {
                       if (itemId) {
-                          ds.itemId = common.templatizeTerm(itemId, itemId, ".itemId");
+                          ds.itemId = common__namespace.templatizeTerm(itemId, itemId, ".itemId");
                       }
                   }
               });
-              Promise.all(pendingRequests).then(() => resolve(itemTemplate), e => reject(common.fail(e)));
+              Promise.all(pendingRequests).then(() => resolve(itemTemplate), e => reject(common__namespace.fail(e)));
           }
           else {
               resolve(itemTemplate);
@@ -439,13 +459,13 @@
   function templatizeWidgets(itemTemplate, authentication, portalUrl, widgetPath, isOnScreen = false) {
       return new Promise((resolve, reject) => {
           // update widgets
-          const widgets = common.getProp(itemTemplate, widgetPath) || [];
+          const widgets = common__namespace.getProp(itemTemplate, widgetPath) || [];
           let serviceRequests = [];
           let requestUrls = [];
           widgets.forEach(widget => {
               /* istanbul ignore else */
-              if (!isOnScreen && common.getProp(widget, "icon")) {
-                  setValues(widget, ["icon"], common.placeholder(common.SERVER_NAME));
+              if (!isOnScreen && common__namespace.getProp(widget, "icon")) {
+                  setValues(widget, ["icon"], common__namespace.placeholder(common__namespace.SERVER_NAME));
               }
               const config = widget.config;
               if (config) {
@@ -459,9 +479,9 @@
           if (serviceRequests.length > 0) {
               const sWidgets = JSON.stringify(widgets);
               handleServiceRequests(serviceRequests, requestUrls, sWidgets).then(response => {
-                  common.setProp(itemTemplate, widgetPath, JSON.parse(response));
+                  common__namespace.setProp(itemTemplate, widgetPath, JSON.parse(response));
                   resolve(itemTemplate);
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve(itemTemplate);
@@ -471,12 +491,12 @@
   function templatizeValues(itemTemplate, authentication, portalUrl, widgetPath) {
       return new Promise((resolve, reject) => {
           // update properties of values collection for web app templates
-          let values = common.getProp(itemTemplate, widgetPath);
+          let values = common__namespace.getProp(itemTemplate, widgetPath);
           let serviceRequests = [];
           let requestUrls = [];
           if (values) {
-              if (common.getProp(values, "icon")) {
-                  setValues(values, ["icon"], common.placeholder(common.SERVER_NAME));
+              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);
@@ -487,9 +507,9 @@
           if (serviceRequests.length > 0) {
               const sWidgets = JSON.stringify(values);
               handleServiceRequests(serviceRequests, requestUrls, sWidgets).then(response => {
-                  common.setProp(itemTemplate, widgetPath, JSON.parse(response));
+                  common__namespace.setProp(itemTemplate, widgetPath, JSON.parse(response));
                   resolve(itemTemplate);
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve(itemTemplate);
@@ -502,7 +522,7 @@
               let i = 0;
               Promise.all(serviceRequests).then(serviceResponses => {
                   serviceResponses.forEach(serviceResponse => {
-                      if (common.getProp(serviceResponse, "serviceItemId")) {
+                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
                           const serviceTemplate = "{{" +
                               serviceResponse.serviceItemId +
                               (serviceResponse.hasOwnProperty("id")
@@ -514,7 +534,7 @@
                       i++;
                   });
                   resolve(objString);
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve(objString);
@@ -531,18 +551,18 @@
       if (results && results.length) {
           results.forEach((url) => {
               if (url.indexOf("NAServer") > -1) {
-                  testString = replaceUrl(testString, url, common.placeholder(common.NA_SERVER_NAME));
+                  testString = replaceUrl(testString, url, common__namespace.placeholder(common__namespace.NA_SERVER_NAME));
               }
               else if (url.indexOf("GeocodeServer") > -1) {
-                  testString = replaceUrl(testString, url, common.placeholder(common.GEOCODE_SERVER_NAME));
+                  testString = replaceUrl(testString, url, common__namespace.placeholder(common__namespace.GEOCODE_SERVER_NAME));
               }
               else if (portalUrl && url.indexOf(portalUrl) > -1) {
-                  testString = replaceUrl(testString, portalUrl, common.placeholder(common.SERVER_NAME));
+                  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.rest_request(url, options));
+                      serviceRequests.push(common__namespace.rest_request(url, options));
                   }
               }
           });
@@ -571,17 +591,17 @@
   }
   function setValues(itemTemplate, paths, base) {
       paths.forEach(path => {
-          const url = common.getProp(itemTemplate, path);
+          const url = common__namespace.getProp(itemTemplate, path);
           if (url) {
               const subString = url.substring(url.indexOf("/", url.indexOf("//") + 2));
-              common.setProp(itemTemplate, path, subString !== url ? base + subString : base);
+              common__namespace.setProp(itemTemplate, path, subString !== url ? base + subString : base);
           }
       });
   }
-  function fineTuneCreatedItem(originalTemplate, newlyCreatedItem, templateDictionary, destinationAuthentication) {
+  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.hasAnyKeyword(originalTemplate, [
+          if (common__namespace.hasAnyKeyword(originalTemplate, [
               "WAB2D",
               "WAB3D",
               "Web AppBuilder"
@@ -592,7 +612,7 @@
                   url: newlyCreatedItem.item.url,
                   data: newlyCreatedItem.data
               };
-              const updateDef = common.updateItem(updateOptions, destinationAuthentication);
+              const updateDef = common__namespace.updateItem(updateOptions, destinationAuthentication);
               const itemInfo = {
                   tags: originalTemplate.item.tags,
                   title: originalTemplate.item.title,
@@ -600,12 +620,12 @@
                   typeKeywords: ["Code", "Javascript", "Web Mapping Application"],
                   relationshipType: "WMA2Code",
                   originItemId: newlyCreatedItem.itemId,
-                  url: common.checkUrlPathTermination(common.replaceInTemplate(common.placeholder(common.SERVER_NAME), templateDictionary)) +
+                  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.createItemWithData(itemInfo, {}, destinationAuthentication, templateDictionary.folderId);
+              const createItemWithDataDef = common__namespace.createItemWithData(itemInfo, {}, destinationAuthentication, templateDictionary.folderId);
               Promise.all([updateDef, createItemWithDataDef]).then(() => resolve(null), () => resolve(null));
           }
           else {
@@ -622,14 +642,14 @@
    * @return A promise that will resolve with list of dependent ids
    * @protected
    */
-  function _extractDependencies$1(model) {
+  function _extractDependencies$2(model) {
       let processor = _getGenericWebAppDependencies;
       /*
       if (common.hasTypeKeyword(model, "Story Map")) {
         processor = getStoryMapDependencies;
       }
       */
-      if (common.hasAnyKeyword(model, ["WAB2D", "WAB3D", "Web AppBuilder"])) {
+      if (common__namespace.hasAnyKeyword(model, ["WAB2D", "WAB3D", "Web AppBuilder"])) {
           processor = _getWABDependencies;
       }
       return processor(model);
@@ -639,15 +659,15 @@
    */
   function _getGenericWebAppDependencies(model) {
       const props = ["data.values.webmap", "data.values.group"];
-      return common.getProps(model, props);
+      return common__namespace.getProps(model, props);
   }
   function _getWABDependencies(model) {
       const deps = [];
-      const v = common.getProp(model, "data.map.itemId");
+      const v = common__namespace.getProp(model, "data.map.itemId");
       if (v) {
           deps.push(v);
       }
-      const dataSources = common.getProp(model, "data.dataSource.dataSources");
+      const dataSources = common__namespace.getProp(model, "data.dataSource.dataSources");
       if (dataSources) {
           Object.keys(dataSources).forEach(k => {
               const ds = dataSources[k];
@@ -667,7 +687,7 @@
    */
   function _templatizeIdPaths(itemTemplate, paths) {
       paths.forEach(path => {
-          const id = common.getProp(itemTemplate, path);
+          const id = common__namespace.getProp(itemTemplate, path);
           _templatizeIdPath(itemTemplate, path, id);
       });
   }
@@ -680,7 +700,7 @@
    * @protected
    */
   function _templatizeIdPath(itemTemplate, path, id) {
-      common.setProp(itemTemplate, path, common.templatizeTerm(id, id, ".itemId"));
+      common__namespace.setProp(itemTemplate, path, common__namespace.templatizeTerm(id, id, ".itemId"));
   }
   /**
    * Templatize field references for datasources and widgets.
@@ -689,15 +709,15 @@
    * @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) {
+  function postProcessFieldReferences$2(solutionTemplate, datasourceInfos) {
       // handle datasources common for WAB apps
-      const dataSources = common.getProp(solutionTemplate, "data.dataSource.dataSources");
+      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.setProp(solutionTemplate, "data.dataSource.dataSources", dataSources);
+          common__namespace.setProp(solutionTemplate, "data.dataSource.dataSources", dataSources);
       }
       // handle widgets common for WAB apps
       const paths = [
@@ -705,15 +725,15 @@
           "data.widgetOnScreen.widgets"
       ];
       paths.forEach(path => {
-          const widgets = common.getProp(solutionTemplate, path);
+          const widgets = common__namespace.getProp(solutionTemplate, path);
           if (widgets) {
-              common.setProp(solutionTemplate, path, _templatizeObjectArray(widgets, datasourceInfos));
+              common__namespace.setProp(solutionTemplate, path, _templatizeObjectArray(widgets, datasourceInfos));
           }
       });
       // handle values common for web app templates
-      const values = common.getProp(solutionTemplate, "data.values");
+      const values = common__namespace.getProp(solutionTemplate, "data.values");
       if (values) {
-          common.setProp(solutionTemplate, "data.values", _templatizeObject(values, datasourceInfos));
+          common__namespace.setProp(solutionTemplate, "data.values", _templatizeObject(values, datasourceInfos));
       }
       return solutionTemplate;
   }
@@ -728,7 +748,7 @@
       obj = _prioritizedTests(obj, datasourceInfos, templatizeKeys);
       const replaceOrder = _getReplaceOrder(obj, datasourceInfos);
       replaceOrder.forEach(ds => {
-          obj = common.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
+          obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
       });
       return obj;
   }
@@ -884,7 +904,7 @@
               }
               else {
                   if (urlTest && urlTest.test(obj[i])) {
-                      obj = common.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
+                      obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
                   }
                   clone[i] = obj[i];
               }
@@ -933,13 +953,13 @@
                   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.templatizeFieldReferences(obj[i], ds.fields, ds.basePath, 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.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
+                          obj = common__namespace.templatizeFieldReferences(obj, ds.fields, ds.basePath, templatizeKeys);
                       }
                       clone[i] = obj[i];
                   }
@@ -978,8 +998,8 @@
    * @param srcAuthentication Credentials for requests to source items
    * @return templatized itemTemplate
    */
-  function convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication) {
-      return common.convertWorkforceItemToTemplate(itemTemplate, srcAuthentication);
+  function convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication) {
+      return common__namespace.convertWorkforceItemToTemplate(itemTemplate, srcAuthentication);
   }
   /**
    * Gets the current user and updates the dispatchers service
@@ -989,7 +1009,7 @@
    * @return A promise that will resolve with { "success" === true || false }
    */
   function fineTuneCreatedItem$1(newlyCreatedItem, destinationAuthentication, templateDictionary) {
-      return common.fineTuneCreatedWorkforceItem(newlyCreatedItem, destinationAuthentication, "", templateDictionary);
+      return common__namespace.fineTuneCreatedWorkforceItem(newlyCreatedItem, destinationAuthentication, "", templateDictionary);
   }
 
   /** @license
@@ -1007,35 +1027,37 @@
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
-  function createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
+  function createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
       return new Promise(resolve => {
           // Interrupt process if progress callback returns `false`
-          if (!itemProgressCallback(template.itemId, common.EItemProgressStatus.Started, 0)) {
-              itemProgressCallback(template.itemId, common.EItemProgressStatus.Ignored, 0);
-              resolve(common.generateEmptyCreationResponse(template.type));
+          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.cloneObject(template);
-              newItemTemplate = common.replaceInTemplate(newItemTemplate, templateDictionary);
+              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.replaceInTemplate(JSON.stringify(newItemTemplate), templateDictionary));
+                  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.createItemWithData(newItemTemplate.item, newItemTemplate.data, destinationAuthentication, templateDictionary.folderId)
+              common__namespace
+                  .createItemWithData(newItemTemplate.item, newItemTemplate.data, destinationAuthentication, templateDictionary.folderId)
                   .then(createResponse => {
                   // Interrupt process if progress callback returns `false`
-                  if (!itemProgressCallback(template.itemId, common.EItemProgressStatus.Created, template.estimatedDeploymentCostFactor / 2, createResponse.id)) {
-                      itemProgressCallback(template.itemId, common.EItemProgressStatus.Cancelled, 0);
-                      common.removeItem(createResponse.id, destinationAuthentication)
-                          .then(() => resolve(common.generateEmptyCreationResponse(template.type)), () => resolve(common.generateEmptyCreationResponse(template.type)));
+                  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
@@ -1047,42 +1069,43 @@
                       // in legacy deployments
                       if (newItemTemplate.type === "Web Mapping Application" &&
                           template.data) {
-                          common.setProp(newItemTemplate, "data.appItemId", createResponse.id);
+                          common__namespace.setProp(newItemTemplate, "data.appItemId", createResponse.id);
                       }
-                      const postProcess = common.hasUnresolvedVariables(newItemTemplate.data);
+                      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.replaceInTemplate(newItemTemplate, templateDictionary);
+                      newItemTemplate = common__namespace.replaceInTemplate(newItemTemplate, templateDictionary);
                       // Update relationships
                       let relationshipsDef = Promise.resolve([]);
                       if (newItemTemplate.relatedItems) {
                           // Templatize references in relationships obj
-                          const updatedRelatedItems = common.replaceInTemplate(common.templatizeIds(newItemTemplate.relatedItems), templateDictionary);
+                          const updatedRelatedItems = common__namespace.replaceInTemplate(common__namespace.templatizeIds(newItemTemplate.relatedItems), templateDictionary);
                           // Add the relationships
-                          relationshipsDef = common.addForwardItemRelationships(newItemTemplate.itemId, updatedRelatedItems, destinationAuthentication);
+                          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.hasAnyKeyword(template, [
+                          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(template, newItemTemplate, templateDictionary, destinationAuthentication);
+                          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$2(template, newItemTemplate, templateDictionary, destinationAuthentication);
+                          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.updateItemURL(createResponse.id, newItemTemplate.item.url, destinationAuthentication)
+                              common__namespace
+                                  .updateItemURL(createResponse.id, newItemTemplate.item.url, destinationAuthentication)
                                   .then(() => resolve2(), reject2);
                           });
                       }
@@ -1091,10 +1114,11 @@
                       }
                       Promise.all([relationshipsDef, customProcDef]).then(() => {
                           // Interrupt process if progress callback returns `false`
-                          if (!itemProgressCallback(template.itemId, common.EItemProgressStatus.Finished, template.estimatedDeploymentCostFactor / 2, createResponse.id)) {
-                              itemProgressCallback(template.itemId, common.EItemProgressStatus.Cancelled, 0);
-                              common.removeItem(createResponse.id, destinationAuthentication)
-                                  .then(() => resolve(common.generateEmptyCreationResponse(template.type)), () => resolve(common.generateEmptyCreationResponse(template.type)));
+                          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({
@@ -1105,13 +1129,13 @@
                               });
                           }
                       }, () => {
-                          itemProgressCallback(template.itemId, common.EItemProgressStatus.Failed, 0);
-                          resolve(common.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 deploy all resources to the item
                       });
                   }
               }, () => {
-                  itemProgressCallback(template.itemId, common.EItemProgressStatus.Failed, 0);
-                  resolve(common.generateEmptyCreationResponse(template.type)); // fails to create item
+                  itemProgressCallback(template.itemId, common__namespace.EItemProgressStatus.Failed, 0);
+                  resolve(common__namespace.generateEmptyCreationResponse(template.type)); // fails to create item
               });
           }
       });
@@ -1158,8 +1182,8 @@
 
   var notebookHelpers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    createItemFromTemplate: createItemFromTemplate,
-    convertItemToTemplate: convertItemToTemplate$7,
+    createItemFromTemplate: createItemFromTemplate$3,
+    convertItemToTemplate: convertItemToTemplate$1,
     updateNotebookData: updateNotebookData
   });
 
@@ -1188,16 +1212,16 @@
    * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
    * @return A promise that will resolve when the template has been created
    */
-  function convertItemToTemplate$3(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
+  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$7(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
+      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
   }
   // Delegate back to simple-types
   // This is a temporary refactor step
-  function createItemFromTemplate$1(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
+  function createItemFromTemplate$2(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
+      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
   }
   /**
    * Converts a Python Notebook item to a template.
@@ -1239,14 +1263,15 @@
    *
    * @return A promise that will resolve once any updates have been made
    */
-  function fineTuneCreatedItem$2(originalTemplate, newlyCreatedItem, templateDictionary, authentication) {
+  function fineTuneCreatedItem(originalTemplate, newlyCreatedItem, templateDictionary, authentication) {
       return new Promise((resolve, reject) => {
           const updateOptions = {
               id: newlyCreatedItem.itemId,
               url: newlyCreatedItem.item.url,
-              data: common.jsonToFile(newlyCreatedItem.data, newlyCreatedItem.itemId + ".ipynb")
+              data: common__namespace.jsonToFile(newlyCreatedItem.data, newlyCreatedItem.itemId + ".ipynb")
           };
-          common.updateItem(updateOptions, authentication)
+          common__namespace
+              .updateItem(updateOptions, authentication)
               .then(() => resolve(null), reject);
       });
   }
@@ -1260,17 +1285,17 @@
    * @param {UserSession} authentication The destination session info
    * @returns {Promise<any>}
    */
-  function postProcess(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
-      return common.updateItemTemplateFromDictionary(itemId, templateDictionary, authentication);
+  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$3,
-    createItemFromTemplate: createItemFromTemplate$1,
+    convertItemToTemplate: convertItemToTemplate$5,
+    createItemFromTemplate: createItemFromTemplate$2,
     convertNotebookToTemplate: convertNotebookToTemplate,
-    fineTuneCreatedItem: fineTuneCreatedItem$2,
-    postProcess: postProcess
+    fineTuneCreatedItem: fineTuneCreatedItem,
+    postProcess: postProcess$2
   });
 
   /** @license
@@ -1300,7 +1325,7 @@
   function convertItemToTemplate$4(itemTemplate, destAuthentication, srcAuthentication) {
       return new Promise((resolve, reject) => {
           // Extract dependencies
-          _extractDependencies$2(itemTemplate, srcAuthentication).then((results) => {
+          _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 */
@@ -1309,7 +1334,7 @@
                   itemTemplate.data.properties.OverviewURL = _templatizeOicLayerUrl(itemTemplate.data.properties.OverviewURL, results.urlHash);
               }
               resolve(itemTemplate);
-          }, e => reject(common.fail(e)));
+          }, e => reject(common__namespace.fail(e)));
       });
   }
   /**
@@ -1320,7 +1345,7 @@
    * @return List of dependencies ids and url/itemId hash
    * @protected
    */
-  function _extractDependencies$2(itemTemplate, authentication) {
+  function _extractDependencies$1(itemTemplate, authentication) {
       return new Promise((resolve, reject) => {
           const dependencies = [];
           if (itemTemplate.data?.properties) {
@@ -1335,9 +1360,9 @@
                       itemTemplate.data.properties.ServiceURL) {
                   layerURLs.push(itemTemplate.data.properties.OverviewURL);
               }
-              _getLayerIds(layerURLs, dependencies, authentication).then(results => {
+              _getLayerIds$1(layerURLs, dependencies, authentication).then(results => {
                   resolve(results);
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve({
@@ -1356,7 +1381,7 @@
    * @return List of dependencies ids and url/itemId hash
    * @protected
    */
-  function _getLayerIds(layerURLs, dependencies, authentication) {
+  function _getLayerIds$1(layerURLs, dependencies, authentication) {
       return new Promise((resolve, reject) => {
           const urlHash = {};
           const options = {
@@ -1373,7 +1398,7 @@
                       // avoid redundant checks when we have a layer with subLayers
                       /* istanbul ignore else */
                       if (Object.keys(layerChecks).indexOf(baseUrl) < 0) {
-                          layerChecks[baseUrl] = common.rest_request(layerURL, options);
+                          layerChecks[baseUrl] = common__namespace.rest_request(layerURL, options);
                       }
                       layerPromises.push(layerChecks[baseUrl]);
                       return true;
@@ -1390,7 +1415,7 @@
               Promise.all(layerPromises).then(serviceResponses => {
                   serviceResponses.forEach((serviceResponse, i) => {
                       /* istanbul ignore else */
-                      if (common.getProp(serviceResponse, "serviceItemId")) {
+                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
                           const id = serviceResponse.serviceItemId;
                           /* istanbul ignore else */
                           if (dependencies.indexOf(id) < 0) {
@@ -1403,7 +1428,7 @@
                       dependencies: dependencies,
                       urlHash: urlHash
                   });
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve({
@@ -1427,10 +1452,10 @@
           const id = urlHash[layerURL];
           if (id) {
               const layerId = layerURL.substr(layerURL.lastIndexOf("/") + 1);
-              templatizedURL = common.templatizeTerm(id, id, ".layer" + layerId + ".url");
+              templatizedURL = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url");
           }
           // replace everything up until /home with portalBaseUrl var and templatize the itemId
-          templatizedURL = common.templatizeIds(templatizedURL.replace(/.+?(?=\/home)/, "{{portalBaseUrl}}"));
+          templatizedURL = common__namespace.templatizeIds(templatizedURL.replace(/.+?(?=\/home)/, "{{portalBaseUrl}}"));
       }
       return templatizedURL;
   }
@@ -1453,8 +1478,8 @@
 
   var quickcaptureHelpers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    createItemFromTemplate: createItemFromTemplate,
-    convertItemToTemplate: convertItemToTemplate$7
+    createItemFromTemplate: createItemFromTemplate$3,
+    convertItemToTemplate: convertItemToTemplate$1
   });
 
   /** @license
@@ -1483,11 +1508,11 @@
    * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
    * @return A promise that will resolve when the template has been created
    */
-  function convertItemToTemplate$5(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
+  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$7(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
+      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
   }
   /**
    * Converts an quick capture item to a template.
@@ -1505,7 +1530,7 @@
               data.some((item) => {
                   if (item.type === "application/json") {
                       applicationName = item.name;
-                      applicationRequest = common.getBlobText(item);
+                      applicationRequest = common__namespace.getBlobText(item);
                       return true;
                   }
               });
@@ -1557,8 +1582,8 @@
    * @param data the quick capture application
    */
   function _templatizeAdminEmail(data) {
-      if (common.getProp(data, "preferences.adminEmail")) {
-          common.setProp(data, "preferences.adminEmail", "{{user.email}}");
+      if (common__namespace.getProp(data, "preferences.adminEmail")) {
+          common__namespace.setProp(data, "preferences.adminEmail", "{{user.email}}");
       }
   }
   /**
@@ -1581,11 +1606,11 @@
    * @param urlPath the path to the url property
    */
   function _templatizeUrl(obj, idPath, urlPath) {
-      const id = common.getProp(obj, idPath);
-      const url = common.getProp(obj, 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.setProp(obj, urlPath, common.templatizeTerm(id, id, ".layer" + layerId + ".url"));
+          common__namespace.setProp(obj, urlPath, common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url"));
       }
   }
   /**
@@ -1595,17 +1620,17 @@
    * @param path the path to the id property
    */
   function _templatizeId(obj, path) {
-      const id = common.getProp(obj, path);
+      const id = common__namespace.getProp(obj, path);
       if (id) {
-          common.setProp(obj, path, common.templatizeTerm(id, id, ".itemId"));
+          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$2(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
+  function createItemFromTemplate$1(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
+      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
   }
   /**
    * QuickCapture post-processing actions
@@ -1619,10 +1644,12 @@
    */
   function postProcess$1(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
       return new Promise((resolve, reject) => {
-          template.data = common.replaceInTemplate(template.data, templateDictionary);
-          common.updateItemTemplateFromDictionary(itemId, templateDictionary, authentication)
+          template.data = common__namespace.replaceInTemplate(template.data, templateDictionary);
+          common__namespace
+              .updateItemTemplateFromDictionary(itemId, templateDictionary, authentication)
               .then(() => {
-              common.updateItemResourceText(itemId, template.data.name, JSON.stringify(template.data.application), authentication)
+              common__namespace
+                  .updateItemResourceText(itemId, template.data.name, JSON.stringify(template.data.application), authentication)
                   .then(resolve, reject);
           }, reject);
       });
@@ -1631,14 +1658,14 @@
 
   var quickcapture = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    convertItemToTemplate: convertItemToTemplate$5,
+    convertItemToTemplate: convertItemToTemplate$3,
     convertQuickCaptureToTemplate: convertQuickCaptureToTemplate,
     _templatizeApplication: _templatizeApplication,
     _templatizeAdminEmail: _templatizeAdminEmail,
     _updateDependencies: _updateDependencies,
     _templatizeUrl: _templatizeUrl,
     _templatizeId: _templatizeId,
-    createItemFromTemplate: createItemFromTemplate$2,
+    createItemFromTemplate: createItemFromTemplate$1,
     postProcess: postProcess$1
   });
 
@@ -1672,15 +1699,15 @@
    * @param srcAuthentication Credentials for requests to source items
    * @return Template for the solution item that contains key details for item reconstruction
    */
-  function convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication) {
+  function convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication) {
       return new Promise((resolve, reject) => {
           // Templatize the app URL
           itemTemplate.item.url =
-              common.checkUrlPathTermination(common.placeholder(common.SERVER_NAME)) +
+              common__namespace.checkUrlPathTermination(common__namespace.placeholder(common__namespace.SERVER_NAME)) +
                   WEBMAP_APP_URL_PART +
                   itemTemplate.item.id; // templatized id
           // Extract dependencies
-          _extractDependencies$3(itemTemplate, srcAuthentication).then((results) => {
+          _extractDependencies(itemTemplate, srcAuthentication).then((results) => {
               itemTemplate.dependencies = results.dependencies;
               // Templatize the map layer ids after we've extracted them as dependencies
               if (itemTemplate.data) {
@@ -1690,7 +1717,7 @@
                   _excludeInitialState(itemTemplate.data);
               }
               resolve(itemTemplate);
-          }, e => reject(common.fail(e)));
+          }, e => reject(common__namespace.fail(e)));
       });
   }
   /**
@@ -1701,16 +1728,16 @@
    * @return List of dependencies ids and url/itemId hash
    * @protected
    */
-  function _extractDependencies$3(itemTemplate, authentication) {
+  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$1(layersAndTables, dependencies, authentication).then(results => {
+              _getLayerIds(layersAndTables, dependencies, authentication).then(results => {
                   resolve(results);
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve({
@@ -1731,7 +1758,7 @@
    * @protected
    */
   function _excludeInitialState(data) {
-      common.deleteProp(data, "initialState");
+      common__namespace.deleteProp(data, "initialState");
   }
   /**
    * Extracts the AGOL itemId for each layer or table object in a list using the url.
@@ -1742,7 +1769,7 @@
    * @return List of dependencies ids and url/itemId hash
    * @protected
    */
-  function _getLayerIds$1(layerList, dependencies, authentication) {
+  function _getLayerIds(layerList, dependencies, authentication) {
       return new Promise((resolve, reject) => {
           const urlHash = {};
           const options = {
@@ -1758,7 +1785,7 @@
                   if (baseUrl) {
                       // avoid redundant checks when we have a layer with subLayers
                       if (Object.keys(layerChecks).indexOf(baseUrl) < 0) {
-                          layerChecks[baseUrl] = common.rest_request(layer.url, options);
+                          layerChecks[baseUrl] = common__namespace.rest_request(layer.url, options);
                       }
                       layerPromises.push(layerChecks[baseUrl]);
                       return true;
@@ -1774,7 +1801,7 @@
           if (layerPromises.length > 0) {
               Promise.all(layerPromises).then(serviceResponses => {
                   serviceResponses.forEach((serviceResponse, i) => {
-                      if (common.getProp(serviceResponse, "serviceItemId")) {
+                      if (common__namespace.getProp(serviceResponse, "serviceItemId")) {
                           const id = serviceResponse.serviceItemId;
                           if (dependencies.indexOf(id) < 0) {
                               dependencies.push(id);
@@ -1786,7 +1813,7 @@
                       dependencies: dependencies,
                       urlHash: urlHash
                   });
-              }, e => reject(common.fail(e)));
+              }, e => reject(common__namespace.fail(e)));
           }
           else {
               resolve({
@@ -1812,8 +1839,8 @@
                   ? urlHash[layer.url]
                   : undefined;
               if (id) {
-                  layer.url = common.templatizeTerm(id, id, ".layer" + layerId + ".url");
-                  layer.itemId = common.templatizeTerm(id, id, ".layer" + layerId + ".itemId");
+                  layer.url = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".url");
+                  layer.itemId = common__namespace.templatizeTerm(id, id, ".layer" + layerId + ".itemId");
               }
           }
       });
@@ -1825,7 +1852,7 @@
    * @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) {
+  function postProcessFieldReferences$1(solutionTemplate, datasourceInfos) {
       const paths = [
           "data.operationalLayers",
           "data.tables",
@@ -1842,9 +1869,9 @@
    * @param path A string path to the object property to templatize
    */
   function _templatizeProperty(solutionTemplate, datasourceInfos, path) {
-      const objs = common.getProp(solutionTemplate, path);
+      const objs = common__namespace.getProp(solutionTemplate, path);
       if (objs) {
-          common.setProp(solutionTemplate, path, _templatize$1(objs, datasourceInfos));
+          common__namespace.setProp(solutionTemplate, path, _templatize(objs, datasourceInfos));
       }
   }
   /**
@@ -1854,21 +1881,21 @@
    * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
    * @returns updated instances of the objects
    */
-  function _templatize$1(objs, datasourceInfos) {
+  function _templatize(objs, datasourceInfos) {
       objs.forEach(obj => {
-          const ds = _getDatasourceInfo$1(obj, datasourceInfos);
+          const ds = _getDatasourceInfo(obj, datasourceInfos);
           if (ds) {
               const fieldNames = ds.fields.map(f => f.name);
-              common._templatizePopupInfo(obj, ds, ds.basePath, ds.itemId, fieldNames);
-              common._templatizeDefinitionEditor(obj, ds.basePath, fieldNames);
+              common__namespace._templatizePopupInfo(obj, ds, ds.basePath, ds.itemId, fieldNames);
+              common__namespace._templatizeDefinitionEditor(obj, ds.basePath, fieldNames);
               if (obj.layerDefinition) {
-                  common._templatizeDrawingInfo(obj.layerDefinition, ds.basePath, fieldNames);
-                  common._templatizeDefinitionExpression(obj.layerDefinition, ds.basePath, fieldNames);
+                  common__namespace._templatizeDrawingInfo(obj.layerDefinition, ds.basePath, fieldNames);
+                  common__namespace._templatizeDefinitionExpression(obj.layerDefinition, ds.basePath, fieldNames);
               }
               // used for applicationProperties search layers
-              const fieldName = common.getProp(obj, "field.name");
+              const fieldName = common__namespace.getProp(obj, "field.name");
               if (fieldName) {
-                  common.setProp(obj, "field.name", common._templatizeFieldName(fieldName, obj, ds.itemId, ds.basePath));
+                  common__namespace.setProp(obj, "field.name", common__namespace._templatizeFieldName(fieldName, obj, ds.itemId, ds.basePath));
               }
           }
       });
@@ -1881,7 +1908,7 @@
    * @param datasourceInfos A list of datasource info objects that contain key values to templatize field references
    * @returns datasourceInfo for the given object id
    */
-  function _getDatasourceInfo$1(obj, datasourceInfos) {
+  function _getDatasourceInfo(obj, datasourceInfos) {
       let datasourceInfo;
       datasourceInfos.some(ds => {
           if (ds.ids.indexOf(obj.id) > -1) {
@@ -1921,14 +1948,14 @@
    *
    * @return A promise that will resolve when the template has been created
    */
-  function convertItemToTemplate$7(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
+  function convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
       return new Promise((resolve, reject) => {
           // Init template
-          const itemTemplate = common.createInitializedItemTemplate(itemInfo);
+          const itemTemplate = common__namespace.createInitializedItemTemplate(itemInfo);
           // Templatize item info property values
-          itemTemplate.item.id = common.templatizeTerm(itemTemplate.item.id, itemTemplate.item.id, ".itemId");
+          itemTemplate.item.id = common__namespace.templatizeTerm(itemTemplate.item.id, itemTemplate.item.id, ".itemId");
           // Request related items
-          const relatedPromise = common.getItemRelatedItemsInSameDirection(itemTemplate.itemId, "forward", srcAuthentication);
+          const relatedPromise = common__namespace.getItemRelatedItemsInSameDirection(itemTemplate.itemId, "forward", srcAuthentication);
           // Perform type-specific handling
           let dataPromise = Promise.resolve({});
           switch (itemInfo.type) {
@@ -1948,15 +1975,16 @@
               case "Notebook":
                   dataPromise = new Promise(resolveJSON => {
                       // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                      common.getItemDataAsJson(itemTemplate.itemId, srcAuthentication)
+                      common__namespace
+                          .getItemDataAsJson(itemTemplate.itemId, srcAuthentication)
                           .then(json => resolveJSON(json));
                   });
                   break;
               case "Form":
-                  dataPromise = common.getItemDataAsFile(itemTemplate.itemId, itemTemplate.item.name, srcAuthentication);
+                  dataPromise = common__namespace.getItemDataAsFile(itemTemplate.itemId, itemTemplate.item.name, srcAuthentication);
                   break;
               case "QuickCapture Project":
-                  dataPromise = common.getItemResourcesFiles(itemTemplate.itemId, srcAuthentication);
+                  dataPromise = 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:
@@ -1964,7 +1992,7 @@
           Promise.all([dataPromise, relatedPromise]).then(responses => {
               const [itemDataResponse, relatedItemsResponse] = responses;
               // need to pre-process for velocity urls before they could be templatized by other processors
-              itemTemplate.data = common.updateVelocityReferences(itemDataResponse, itemInfo.type, templateDictionary);
+              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 = [];
@@ -1984,7 +2012,7 @@
               let templateModifyingPromise = Promise.resolve(itemTemplate);
               switch (itemInfo.type) {
                   case "Dashboard":
-                      convertItemToTemplate(itemTemplate);
+                      convertItemToTemplate$8(itemTemplate);
                       break;
                   case "Form":
                       // Store the form's data in the solution resources, not in template
@@ -1996,9 +2024,10 @@
                               ? originalFilename
                               : `${itemTemplate.itemId}.zip`;
                           itemTemplate.item.name = filename;
-                          const storageName = common.convertItemResourceToStorageResource(itemTemplate.itemId + "_info_data", filename, common.SolutionTemplateFormatVersion);
+                          const storageName = common__namespace.convertItemResourceToStorageResource(itemTemplate.itemId + "_info_data", filename, common__namespace.SolutionTemplateFormatVersion);
                           wrapupPromise = new Promise((resolveDataStorage, rejectDataStorage) => {
-                              common.addResourceFromBlob(itemDataResponse, solutionItemId, storageName.folder, filename, destAuthentication)
+                              common__namespace
+                                  .addResourceFromBlob(itemDataResponse, solutionItemId, storageName.folder, filename, destAuthentication)
                                   .then(() => {
                                   // Update the template's resources
                                   itemTemplate.resources.push(storageName.folder + "/" + storageName.filename);
@@ -2015,23 +2044,23 @@
                       break;
                   case "Web Map":
                   case "Web Scene":
-                      templateModifyingPromise = convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication);
+                      templateModifyingPromise = convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication);
                       break;
                   case "Web Mapping Application":
                       if (itemDataResponse) {
-                          templateModifyingPromise = convertItemToTemplate$1(itemTemplate, destAuthentication, srcAuthentication);
+                          templateModifyingPromise = convertItemToTemplate$7(itemTemplate, destAuthentication, srcAuthentication);
                       }
                       break;
                   case "Workforce Project":
-                      templateModifyingPromise = convertItemToTemplate$2(itemTemplate, destAuthentication, srcAuthentication);
+                      templateModifyingPromise = convertItemToTemplate$6(itemTemplate, destAuthentication, srcAuthentication);
                       break;
                   case "QuickCapture Project":
                       templateModifyingPromise = convertQuickCaptureToTemplate(itemTemplate);
                       break;
               }
               wrapupPromise.then(() => {
-                  templateModifyingPromise.then(resolve, err => reject(common.fail(err)));
-              }, err => reject(common.fail(err)));
+                  templateModifyingPromise.then(resolve, err => reject(common__namespace.fail(err)));
+              }, err => reject(common__namespace.fail(err)));
           });
       });
   }
@@ -2054,8 +2083,8 @@
 
   var simpleTypeHelpers = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    createItemFromTemplate: createItemFromTemplate,
-    convertItemToTemplate: convertItemToTemplate$7
+    createItemFromTemplate: createItemFromTemplate$3,
+    convertItemToTemplate: convertItemToTemplate$1
   });
 
   /** @license
@@ -2083,8 +2112,8 @@
    * @param templateDictionary Hash of facts: folder id, org URL, adlib replacements
    * @return A promise that will resolve when the template has been created
    */
-  function convertItemToTemplate$8(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
-      return convertItemToTemplate$7(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
+  function convertItemToTemplate(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary) {
+      return convertItemToTemplate$1(solutionItemId, itemInfo, destAuthentication, srcAuthentication, templateDictionary);
   }
   /**
    * Delegate to simpleType creator
@@ -2094,8 +2123,8 @@
    * @param destinationAuthentication
    * @param itemProgressCallback
    */
-  function createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
-      return createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
+  function createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback) {
+      return createItemFromTemplate$3(template, templateDictionary, destinationAuthentication, itemProgressCallback);
   }
   /**
    * Templatizes field references within specific template types.
@@ -2106,16 +2135,16 @@
    * @param type The item type
    * @return The updated solution template
    */
-  function postProcessFieldReferences$3(solutionTemplate, datasourceInfos, type) {
+  function postProcessFieldReferences(solutionTemplate, datasourceInfos, type) {
       switch (type) {
           case "Web Mapping Application":
-              postProcessFieldReferences$1(solutionTemplate, datasourceInfos);
+              postProcessFieldReferences$2(solutionTemplate, datasourceInfos);
               break;
           case "Dashboard":
-              postProcessFieldReferences(solutionTemplate, datasourceInfos);
+              postProcessFieldReferences$3(solutionTemplate, datasourceInfos);
               break;
           case "Web Map":
-              postProcessFieldReferences$2(solutionTemplate, datasourceInfos);
+              postProcessFieldReferences$1(solutionTemplate, datasourceInfos);
               break;
       }
       return solutionTemplate;
@@ -2130,16 +2159,16 @@
    * @param {UserSession} authentication The destination session info
    * @returns Promise resolving to successfulness of update
    */
-  function postProcess$2(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
+  function postProcess(itemId, type, itemInfos, template, templates, templateDictionary, authentication) {
       return common.updateItemTemplateFromDictionary(itemId, templateDictionary, authentication);
   }
 
   var simpleTypes = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    convertItemToTemplate: convertItemToTemplate$8,
-    createItemFromTemplate: createItemFromTemplate$3,
-    postProcessFieldReferences: postProcessFieldReferences$3,
-    postProcess: postProcess$2
+    convertItemToTemplate: convertItemToTemplate,
+    createItemFromTemplate: createItemFromTemplate,
+    postProcessFieldReferences: postProcessFieldReferences,
+    postProcess: postProcess
   });
 
   exports.notebookHelpers = notebookHelpers;
@@ -2151,5 +2180,5 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=simple-types.umd.js.map