@esri/solution-deployer 1.1.2 → 1.2.0

package/dist/esm/deploySolutionItems.js

@@ -20,7 +20,7 @@
  */
 import * as common from "@esri/solution-common";
 import { moduleMap } from "./module-map";
-var UNSUPPORTED = null;
+const UNSUPPORTED = null;
 // ------------------------------------------------------------------------------------------------------------------ //
 /**
  * Deploys a set of items defined by templates.
@@ -36,28 +36,26 @@ var UNSUPPORTED = null;
  * @return A promise that will resolve with the list of information about the created items
  */
 export function deploySolutionItems(portalSharingUrl, storageItemId, templates, storageAuthentication, templateDictionary, deployedSolutionId, destinationAuthentication, options) {
-    return new Promise(function (resolve, reject) {
-        var _a;
+    return new Promise((resolve, reject) => {
         // Prepare feedback mechanism
-        var totalEstimatedCost = _estimateDeploymentCost(templates) + 1; // solution items, plus avoid divide by 0
-        var percentDone = 10; // allow for previous deployment work
-        var progressPercentStep = (99 - percentDone) / totalEstimatedCost; // leave some % for caller for wrapup
-        var failedTemplateItemIds = [];
-        var deployedItemIds = [];
-        var statusOK = true;
+        const totalEstimatedCost = _estimateDeploymentCost(templates) + 1; // solution items, plus avoid divide by 0
+        let percentDone = 10; // allow for previous deployment work
+        const progressPercentStep = (99 - percentDone) / totalEstimatedCost; // leave some % for caller for wrapup
+        const failedTemplateItemIds = [];
+        const deployedItemIds = [];
+        let statusOK = true;
         // TODO: move to separate fn
-        var itemProgressCallback = function (itemId, status, costUsed, createdItemId // supplied when status is EItemProgressStatus.Created or .Finished
-        ) {
-            var _a;
+        const itemProgressCallback = (itemId, status, costUsed, createdItemId // supplied when status is EItemProgressStatus.Created or .Finished
+        ) => {
             percentDone += progressPercentStep * costUsed;
             /* istanbul ignore else */
             if (options.progressCallback) {
                 if (status === common.EItemProgressStatus.Finished) {
-                    var event_1 = {
+                    const event = {
                         event: common.SItemProgressStatus[status],
                         data: itemId
                     };
-                    options.progressCallback(Math.round(percentDone), options.jobId, event_1);
+                    options.progressCallback(Math.round(percentDone), options.jobId, event);
                 }
                 else {
                     options.progressCallback(Math.round(percentDone), options.jobId);
@@ -65,7 +63,7 @@ export function deploySolutionItems(portalSharingUrl, storageItemId, templates,
             }
             /* istanbul ignore if */
             if (options.consoleProgress) {
-                console.log(Date.now(), itemId, (_a = options.jobId) !== null && _a !== void 0 ? _a : "", common.SItemProgressStatus[status], percentDone.toFixed(0) + "%", costUsed, createdItemId ? "==> " + createdItemId : "");
+                console.log(Date.now(), itemId, options.jobId ?? "", common.SItemProgressStatus[status], percentDone.toFixed(0) + "%", costUsed, createdItemId ? "==> " + createdItemId : "");
             }
             if (status === common.EItemProgressStatus.Created) {
                 deployedItemIds.push(createdItemId);
@@ -85,27 +83,27 @@ export function deploySolutionItems(portalSharingUrl, storageItemId, templates,
         // Create an ordered graph of the templates so that dependencies are created before the items that need them.
         // Because cycles are permitted, we also keep track of items that need to be patched later because their
         // dependencies are necessarily created after they are created.
-        var _b = common.topologicallySortItems(templates), buildOrder = _b.buildOrder, itemsToBePatched = _b.itemsToBePatched;
+        const { buildOrder, itemsToBePatched } = common.topologicallySortItems(templates);
         // For each item in order from no dependencies to dependent on other items,
         //   * replace template symbols using template dictionary
         //   * create item in destination group
         //   * add created item's id into the template dictionary
-        var awaitAllItems = [];
-        var reuseItemsDef = _reuseDeployedItems(templates, (_a = options.enableItemReuse) !== null && _a !== void 0 ? _a : false, templateDictionary, destinationAuthentication);
+        const awaitAllItems = [];
+        const reuseItemsDef = _reuseDeployedItems(templates, options.enableItemReuse ?? false, templateDictionary, destinationAuthentication);
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        reuseItemsDef.then(function () {
-            var useExistingItemsDef = _useExistingItems(templates, common.getProp(templateDictionary, "params.useExisting"), templateDictionary, destinationAuthentication);
+        reuseItemsDef.then(() => {
+            const useExistingItemsDef = _useExistingItems(templates, common.getProp(templateDictionary, "params.useExisting"), templateDictionary, destinationAuthentication);
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            useExistingItemsDef.then(function () {
+            useExistingItemsDef.then(() => {
                 templates = common.setNamesAndTitles(templates, templateDictionary.solutionItemId);
-                buildOrder.forEach(function (id) {
+                buildOrder.forEach((id) => {
                     // Get the item's template out of the list of templates
-                    var template = common.findTemplateInList(templates, id);
+                    const template = common.findTemplateInList(templates, id);
                     awaitAllItems.push(_createItemFromTemplateWhenReady(template, common.generateStorageFilePaths(portalSharingUrl, storageItemId, template.resources, options.storageVersion), storageAuthentication, templateDictionary, destinationAuthentication, itemProgressCallback));
                 });
                 // Wait until all items have been created
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                Promise.all(awaitAllItems).then(function (clonedSolutionItems) {
+                Promise.all(awaitAllItems).then((clonedSolutionItems) => {
                     if (failedTemplateItemIds.length === 0) {
                         // Do we have any items to be patched (i.e., they refer to dependencies using the template id rather
                         // than the cloned id because the item had to be created before the dependency)? Flag these items
@@ -115,19 +113,17 @@ export function deploySolutionItems(portalSharingUrl, storageItemId, templates,
                     }
                     else {
                         // Delete created items
-                        var progressOptions = {
+                        const progressOptions = {
                             consoleProgress: true
                         };
                         // eslint-disable-next-line @typescript-eslint/no-floating-promises
                         common
                             .deleteSolutionByComponents(deployedSolutionId, deployedItemIds, templates, templateDictionary, destinationAuthentication, progressOptions)
-                            .then(function () {
-                            return reject(common.failWithIds(failedTemplateItemIds));
-                        });
+                            .then(() => reject(common.failWithIds(failedTemplateItemIds)));
                     }
                 });
             });
-        }, function (e) {
+        }, e => {
             console.error(e);
             reject(common.fail(e));
         });
@@ -141,13 +137,13 @@ export function deploySolutionItems(portalSharingUrl, storageItemId, templates,
  * @param templates A collection of AGO item templates
  */
 export function _flagPatchItemsForPostProcessing(itemsToBePatched, templateDictionary, templates) {
-    var itemIdsToBePatched = Object.keys(itemsToBePatched);
+    let itemIdsToBePatched = Object.keys(itemsToBePatched);
     /* istanbul ignore else */
     if (itemIdsToBePatched.length > 0) {
         // Replace the ids of the items to be patched (which are template ids) with their cloned versions
-        itemIdsToBePatched = itemIdsToBePatched.map(function (id) { return templateDictionary[id].itemId; });
+        itemIdsToBePatched = itemIdsToBePatched.map(id => templateDictionary[id].itemId);
         // Make sure that the items to be patched are flagged for post processing
-        templates.forEach(function (item) {
+        templates.forEach(item => {
             /* istanbul ignore else */
             if (itemIdsToBePatched.includes(item.id)) {
                 item.postProcess = true;
@@ -168,16 +164,16 @@ export function _flagPatchItemsForPostProcessing(itemsToBePatched, templateDicti
 export function _evaluateSharedViewSources(templates) {
     // update the templates so we can defer the deployment when more than one view shares the same source
     // these are not classic dependencies but are in some ways similar
-    var views = _getViews(templates);
+    const views = _getViews(templates);
     _updateViewTemplates(templates, views);
-    var viewHash = _getViewHash(views);
-    var processed = [];
-    var visited = [];
-    Object.keys(viewHash).forEach(function (k) {
-        var _views = viewHash[k];
-        _views.forEach(function (cv) {
-            var template = common.findTemplateInList(templates, cv);
-            var syncViews = common.getProp(template, "properties.syncViews");
+    const viewHash = _getViewHash(views);
+    let processed = [];
+    const visited = [];
+    Object.keys(viewHash).forEach(k => {
+        const _views = viewHash[k];
+        _views.forEach(cv => {
+            const template = common.findTemplateInList(templates, cv);
+            const syncViews = common.getProp(template, "properties.syncViews");
             /* istanbul ignore else */
             if (visited.indexOf(template.itemId) > -1) {
                 processed = processed.concat(syncViews);
@@ -212,9 +208,9 @@ export function _evaluateSharedViewSources(templates) {
  *
  */
 export function _updateViewTemplates(templates, views) {
-    views.forEach(function (v) {
-        v.dependencies.forEach(function (id) {
-            templates = templates.map(function (t) {
+    views.forEach(v => {
+        v.dependencies.forEach((id) => {
+            templates = templates.map(t => {
                 /* istanbul ignore else */
                 if (common.getProp(t, "properties.service.isView") &&
                     t.dependencies.indexOf(id) > -1 &&
@@ -245,9 +241,9 @@ export function _updateViewTemplates(templates, views) {
  * @protected
  */
 export function _getViewHash(views) {
-    var viewHash = {};
-    views.forEach(function (v) {
-        v.dependencies.forEach(function (d) {
+    const viewHash = {};
+    views.forEach(v => {
+        v.dependencies.forEach((d) => {
             /* istanbul ignore else */
             if (Object.keys(viewHash).indexOf(d) < 0) {
                 viewHash[d] = [v.id];
@@ -269,7 +265,7 @@ export function _getViewHash(views) {
  * @protected
  */
 export function _getViews(templates) {
-    return templates.reduce(function (acc, v) {
+    return templates.reduce((acc, v) => {
         /* istanbul ignore else */
         if (common.getProp(v, "properties.service.isView")) {
             acc.push({
@@ -293,17 +289,17 @@ export function _getViews(templates) {
  * @protected
  */
 export function _reuseDeployedItems(templates, reuseItems, templateDictionary, authentication) {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         if (reuseItems) {
-            var existingItemsByKeyword = _findExistingItemByKeyword(templates, templateDictionary, authentication);
-            Promise.all(existingItemsByKeyword).then(function (existingItemsByKeywordResponse) {
-                var existingItemsByTag = _handleExistingItems(existingItemsByKeywordResponse, templateDictionary, authentication, true);
-                Promise.all(existingItemsByTag).then(function (existingItemsByTagResponse) {
+            const existingItemsByKeyword = _findExistingItemByKeyword(templates, templateDictionary, authentication);
+            Promise.all(existingItemsByKeyword).then((existingItemsByKeywordResponse) => {
+                const existingItemsByTag = _handleExistingItems(existingItemsByKeywordResponse, templateDictionary, authentication, true);
+                Promise.all(existingItemsByTag).then(existingItemsByTagResponse => {
                     _handleExistingItems(existingItemsByTagResponse, templateDictionary, authentication, false);
                     // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     _updateTemplateDictionary(templates, templateDictionary, authentication).then(resolve);
-                }, function (e) { return reject(common.fail(e)); });
-            }, function (e) { return reject(common.fail(e)); });
+                }, e => reject(common.fail(e)));
+            }, e => reject(common.fail(e)));
         }
         else {
             resolve(null);
@@ -331,30 +327,30 @@ export function _reuseDeployedItems(templates, reuseItems, templateDictionary, a
  * @protected
  */
 export function _useExistingItems(templates, useExisting, templateDictionary, authentication) {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
         if (useExisting) {
-            var itemDefs_1 = [];
-            var sourceIdHash_1 = {};
-            var itemIds_1 = [];
-            Object.keys(templateDictionary.params).forEach(function (k) {
-                var v = templateDictionary.params[k];
+            const itemDefs = [];
+            const sourceIdHash = {};
+            const itemIds = [];
+            Object.keys(templateDictionary.params).forEach(k => {
+                const v = templateDictionary.params[k];
                 /* istanbul ignore else */
                 if (v.itemId && /[0-9A-F]{32}/i.test(k)) {
                     _updateTemplateDictionaryById(templateDictionary, k, v.itemId, v);
                     // need to check and set the typeKeyword if it doesn't exist on this service yet
                     // when the user has passed in an itemId that does not come from a previous deployment
-                    itemDefs_1.push(common.getItemBase(v.itemId, authentication));
-                    sourceIdHash_1[v.itemId] = k;
+                    itemDefs.push(common.getItemBase(v.itemId, authentication));
+                    sourceIdHash[v.itemId] = k;
                     /* istanbul ignore else */
-                    if (itemIds_1.indexOf(k) < 0) {
-                        itemIds_1.push(k);
+                    if (itemIds.indexOf(k) < 0) {
+                        itemIds.push(k);
                     }
                 }
             });
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            _setTypekeywordForExisting(itemDefs_1, sourceIdHash_1, authentication).then(function () {
+            _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication).then(() => {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                _updateTemplateDictionary(itemIds_1.map(function (id) { return common.getTemplateById(templates, id); }), templateDictionary, authentication).then(resolve);
+                _updateTemplateDictionary(itemIds.map(id => common.getTemplateById(templates, id)), templateDictionary, authentication).then(resolve);
             });
         }
         else {
@@ -374,32 +370,32 @@ export function _useExistingItems(templates, useExisting, templateDictionary, au
  * @return a promise to indicate when the requests are complete
  */
 export function _setTypekeywordForExisting(itemDefs, sourceIdHash, authentication) {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
         if (itemDefs.length > 0) {
-            Promise.all(itemDefs).then(function (results) {
-                var itemUpdateDefs = [];
-                results.forEach(function (result) {
-                    var sourceId = sourceIdHash[result.id];
+            Promise.all(itemDefs).then(results => {
+                const itemUpdateDefs = [];
+                results.forEach(result => {
+                    const sourceId = sourceIdHash[result.id];
                     /* istanbul ignore else */
                     if (result && sourceId && result.typeKeywords) {
-                        var sourceKeyword = "source-" + sourceId;
-                        var typeKeywords = result.typeKeywords;
+                        const sourceKeyword = `source-${sourceId}`;
+                        const typeKeywords = result.typeKeywords;
                         /* istanbul ignore else */
                         if (typeKeywords.indexOf(sourceKeyword) < 0) {
                             typeKeywords.push(sourceKeyword);
-                            var itemUpdate = { id: result.id, typeKeywords: typeKeywords };
+                            const itemUpdate = { id: result.id, typeKeywords };
                             itemUpdateDefs.push(common.updateItem(itemUpdate, authentication));
                         }
                     }
                 });
                 // wait for updates to finish before we resolve
                 if (itemUpdateDefs.length > 0) {
-                    Promise.all(itemUpdateDefs).then(resolve, function () { return resolve(undefined); });
+                    Promise.all(itemUpdateDefs).then(resolve, () => resolve(undefined));
                 }
                 else {
                     resolve(undefined);
                 }
-            }, function () { return resolve(undefined); });
+            }, () => resolve(undefined));
         }
         else {
             resolve(undefined);
@@ -415,18 +411,18 @@ export function _setTypekeywordForExisting(itemDefs, sourceIdHash, authenticatio
  * @protected
  */
 export function _updateTemplateDictionary(templates, templateDictionary, authentication) {
-    return new Promise(function (resolve) {
-        var defs = [];
-        var urls = [];
-        var types = [];
-        var ids = [];
-        templates.forEach(function (t) {
-            var templateInfo = templateDictionary[t.itemId];
+    return new Promise(resolve => {
+        const defs = [];
+        const urls = [];
+        const types = [];
+        const ids = [];
+        templates.forEach(t => {
+            const templateInfo = templateDictionary[t.itemId];
             /* istanbul ignore else */
             if (templateInfo && templateInfo.url && templateInfo.itemId) {
                 /* istanbul ignore else */
                 if (t.item.type === "Feature Service") {
-                    var enterpriseIDMapping = common.getProp(templateDictionary, "params." + t.itemId + ".enterpriseIDMapping");
+                    const enterpriseIDMapping = common.getProp(templateDictionary, `params.${t.itemId}.enterpriseIDMapping`);
                     Object.assign(templateDictionary[t.itemId], common.getLayerSettings(common.getLayersAndTables(t), templateInfo.url, templateInfo.itemId, enterpriseIDMapping));
                     // if the service has veiws keep track of the fields so we can use them to
                     // compare with the view fields
@@ -442,7 +438,7 @@ export function _updateTemplateDictionary(templates, templateDictionary, authent
                 /* istanbul ignore else */
                 if (urls.indexOf(templateInfo.url) < 0) {
                     defs.push(t.item.type === "Feature Service"
-                        ? common.rest_request(templateInfo.url, { authentication: authentication })
+                        ? common.rest_request(templateInfo.url, { authentication })
                         : common.getItemBase(templateInfo.itemId, authentication));
                     urls.push(templateInfo.url);
                     types.push(t.item.type);
@@ -452,23 +448,23 @@ export function _updateTemplateDictionary(templates, templateDictionary, authent
         });
         if (defs.length > 0) {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            Promise.all(defs.map(function (p) { return p.catch(function (e) { return e; }); })).then(function (results) {
+            Promise.all(defs.map(p => p.catch(e => e))).then(results => {
                 /* istanbul ignore else */
                 if (Array.isArray(results) && results.length > 0) {
-                    var fieldDefs_1 = [];
-                    results.forEach(function (r, i) {
+                    const fieldDefs = [];
+                    results.forEach((r, i) => {
                         // a feature service result will contain a serviceItemId if it was successfully fetched
                         if (r.serviceItemId && types[i] === "Feature Service") {
-                            Object.keys(templateDictionary).forEach(function (k) {
-                                var v = templateDictionary[k];
+                            Object.keys(templateDictionary).forEach(k => {
+                                const v = templateDictionary[k];
                                 /* istanbul ignore else */
                                 if (v.itemId && v.itemId === r.serviceItemId) {
                                     common.setDefaultSpatialReference(templateDictionary, k, r.spatialReference);
                                     // keep the extent values from these responses as well
-                                    common.setCreateProp(templateDictionary, k + ".defaultExtent", r.fullExtent || r.initialExtent);
-                                    var layerIds = (r.layers || []).map(function (l) { return l.id; });
-                                    var tablesIds = (r.tables || []).map(function (t) { return t.id; });
-                                    fieldDefs_1.push(common.getExistingLayersAndTables(urls[i], layerIds.concat(tablesIds), authentication));
+                                    common.setCreateProp(templateDictionary, `${k}.defaultExtent`, r.fullExtent || r.initialExtent);
+                                    const layerIds = (r.layers || []).map((l) => l.id);
+                                    const tablesIds = (r.tables || []).map((t) => t.id);
+                                    fieldDefs.push(common.getExistingLayersAndTables(urls[i], layerIds.concat(tablesIds), authentication));
                                 }
                             });
                         }
@@ -481,26 +477,26 @@ export function _updateTemplateDictionary(templates, templateDictionary, authent
                             }
                         }
                     });
-                    if (fieldDefs_1.length > 0) {
+                    if (fieldDefs.length > 0) {
                         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        Promise.all(fieldDefs_1).then(function (layerTableResult) {
-                            layerTableResult.forEach(function (l) {
-                                l.forEach(function (ll) {
-                                    Object.keys(templateDictionary).forEach(function (k) {
+                        Promise.all(fieldDefs).then(layerTableResult => {
+                            layerTableResult.forEach(l => {
+                                l.forEach((ll) => {
+                                    Object.keys(templateDictionary).forEach(k => {
                                         /* istanbul ignore else */
                                         if (templateDictionary[k].itemId === ll.serviceItemId) {
-                                            var sourceId_1 = "";
-                                            Object.keys(templateDictionary).some(function (_k) {
+                                            let sourceId = "";
+                                            Object.keys(templateDictionary).some(_k => {
                                                 /* istanbul ignore else */
                                                 if (templateDictionary[_k].itemId === ll.serviceItemId) {
-                                                    sourceId_1 = _k;
+                                                    sourceId = _k;
                                                     return true;
                                                 }
                                             });
-                                            var enterpriseIDMapping_1 = common.getProp(templateDictionary, "params." + sourceId_1 + ".enterpriseIDMapping");
-                                            if (enterpriseIDMapping_1) {
-                                                Object.keys(enterpriseIDMapping_1).forEach(function (id) {
-                                                    if (enterpriseIDMapping_1[id].toString() ===
+                                            const enterpriseIDMapping = common.getProp(templateDictionary, `params.${sourceId}.enterpriseIDMapping`);
+                                            if (enterpriseIDMapping) {
+                                                Object.keys(enterpriseIDMapping).forEach(id => {
+                                                    if (enterpriseIDMapping[id].toString() ===
                                                         ll.id.toString()) {
                                                         _setFields(templateDictionary, k, id, ll.fields);
                                                     }
@@ -541,7 +537,7 @@ export function _updateTemplateDictionary(templates, templateDictionary, authent
  * @protected
  */
 export function _setFields(templateDictionary, itemId, layerId, fields) {
-    var layerInfo = common.getProp(templateDictionary, itemId + ".layer" + layerId);
+    const layerInfo = common.getProp(templateDictionary, `${itemId}.layer${layerId}`);
     /* istanbul ignore else */
     if (layerInfo && fields) {
         layerInfo.fields = fields;
@@ -562,17 +558,17 @@ export function _setFields(templateDictionary, itemId, layerId, fields) {
 export function _updateTemplateDictionaryForError(templateDictionary, itemId) {
     /* istanbul ignore else */
     if (itemId) {
-        var removeKey_1 = "";
-        Object.keys(templateDictionary).some(function (k) {
+        let removeKey = "";
+        Object.keys(templateDictionary).some(k => {
             /* istanbul ignore else */
             if (templateDictionary[k].itemId === itemId) {
-                removeKey_1 = k;
+                removeKey = k;
                 return true;
             }
         });
         /* istanbul ignore else */
-        if (removeKey_1 !== "") {
-            delete templateDictionary[removeKey_1];
+        if (removeKey !== "") {
+            delete templateDictionary[removeKey];
         }
     }
     return templateDictionary;
@@ -589,30 +585,28 @@ export function _updateTemplateDictionaryForError(templateDictionary, itemId) {
  */
 export function _handleExistingItems(existingItemsResponse, templateDictionary, authentication, addTagQuery) {
     // if items are not found by type keyword search by tag
-    var existingItemsByTag = [Promise.resolve(null)];
+    const existingItemsByTag = [Promise.resolve(null)];
     /* istanbul ignore else */
     if (existingItemsResponse && Array.isArray(existingItemsResponse)) {
-        existingItemsResponse.forEach(function (existingItem) {
+        existingItemsResponse.forEach(existingItem => {
             /* istanbul ignore else */
-            if (Array.isArray(existingItem === null || existingItem === void 0 ? void 0 : existingItem.results)) {
-                var result = void 0;
-                var results = existingItem.results;
+            if (Array.isArray(existingItem?.results)) {
+                let result;
+                const results = existingItem.results;
                 if (results.length === 1) {
                     result = results[0];
                 }
                 else if (results.length > 1) {
-                    result = results.reduce(function (a, b) {
-                        return a.created > b.created ? a : b;
-                    });
+                    result = results.reduce((a, b) => a.created > b.created ? a : b);
                 }
                 else {
                     if (addTagQuery && existingItem.query) {
-                        var tagQuery = existingItem.query.replace("typekeywords", "tags");
+                        const tagQuery = existingItem.query.replace("typekeywords", "tags");
                         existingItemsByTag.push(_findExistingItem(tagQuery, authentication));
                     }
                 }
                 if (result) {
-                    var sourceId = existingItem.query
+                    const sourceId = existingItem.query
                         ? existingItem.query.match(/[0-9A-F]{32}/i)[0]
                         : existingItem.sourceId;
                     /* istanbul ignore else */
@@ -628,7 +622,7 @@ export function _handleExistingItems(existingItemsResponse, templateDictionary,
 export function _updateTemplateDictionaryById(templateDictionary, sourceId, itemId, v) {
     templateDictionary[sourceId] = Object.assign(templateDictionary[sourceId] || {}, {
         def: Promise.resolve(common.generateEmptyCreationResponse(v.type, itemId)),
-        itemId: itemId,
+        itemId,
         name: v.name,
         title: v.title,
         url: v.url
@@ -643,17 +637,16 @@ export function _updateTemplateDictionaryById(templateDictionary, sourceId, item
  * @protected
  */
 export function _findExistingItemByKeyword(templates, templateDictionary, authentication) {
-    var existingItemsDefs = [];
-    templates.forEach(function (template) {
-        var _a;
+    const existingItemsDefs = [];
+    templates.forEach(template => {
         if (template.item.type === "Group") {
-            var userGroups = (_a = templateDictionary.user) === null || _a === void 0 ? void 0 : _a.groups;
+            const userGroups = templateDictionary.user?.groups;
             /* istanbul ignore else */
             if (Array.isArray(userGroups)) {
                 existingItemsDefs.push(Promise.resolve({
                     results: userGroups
-                        .filter(function (g) { return g.tags.indexOf("source-" + template.itemId) > -1; })
-                        .map(function (g) {
+                        .filter(g => g.tags.indexOf(`source-${template.itemId}`) > -1)
+                        .map(g => {
                         g.type = "Group";
                         return g;
                     }),
@@ -662,7 +655,7 @@ export function _findExistingItemByKeyword(templates, templateDictionary, authen
             }
         }
         else {
-            existingItemsDefs.push(_findExistingItem("typekeywords:source-" + template.itemId + " type:" + template.item.type + " owner:" + templateDictionary.user.username, authentication));
+            existingItemsDefs.push(_findExistingItem(`typekeywords:source-${template.itemId} type:${template.item.type} owner:${templateDictionary.user.username}`, authentication));
         }
     });
     return existingItemsDefs;
@@ -676,7 +669,7 @@ export function _findExistingItemByKeyword(templates, templateDictionary, authen
  * @protected
  */
 export function _findExistingItem(query, authentication) {
-    var searchOptions = {
+    const searchOptions = {
         q: query,
         authentication: authentication,
         pagingParam: { start: 1, num: 100 }
@@ -702,16 +695,16 @@ export function _createItemFromTemplateWhenReady(template, resourceFilePaths, st
     // or if we have a basic entry without the deferred request for its creation, add it
     if (!templateDictionary.hasOwnProperty(template.itemId) ||
         !common.getProp(templateDictionary[template.itemId], "def")) {
-        var createResponse_1;
-        var statusCode_1 = common.EItemProgressStatus.Unknown;
-        var itemHandler_1;
+        let createResponse;
+        let statusCode = common.EItemProgressStatus.Unknown;
+        let itemHandler;
         templateDictionary[template.itemId] =
             templateDictionary[template.itemId] || {};
         // Save the deferred for the use of items that depend on this item being created first
-        templateDictionary[template.itemId].def = new Promise(function (resolve) {
+        templateDictionary[template.itemId].def = new Promise(resolve => {
             // Wait until all of the item's dependencies are deployed
-            var _awaitDependencies = template.dependencies.reduce(function (acc, id) {
-                var def = common.getProp(templateDictionary, id + ".def");
+            const _awaitDependencies = template.dependencies.reduce((acc, id) => {
+                const def = common.getProp(templateDictionary, `${id}.def`);
                 // can't use maybePush as that clones the object, which does not work for Promises
                 /* istanbul ignore else */
                 if (def) {
@@ -719,10 +712,10 @@ export function _createItemFromTemplateWhenReady(template, resourceFilePaths, st
                 }
                 return acc;
             }, []);
-            var syncViews = common.getProp(template, "properties.syncViews");
-            var awaitDependencies = syncViews && syncViews.length > 0
-                ? syncViews.reduce(function (acc, v) {
-                    var def = common.getProp(templateDictionary, v + ".def");
+            const syncViews = common.getProp(template, "properties.syncViews");
+            const awaitDependencies = syncViews && syncViews.length > 0
+                ? syncViews.reduce((acc, v) => {
+                    const def = common.getProp(templateDictionary, `${v}.def`);
                     /* istanbul ignore else */
                     if (def) {
                         acc.push(def);
@@ -731,55 +724,55 @@ export function _createItemFromTemplateWhenReady(template, resourceFilePaths, st
                 }, _awaitDependencies)
                 : _awaitDependencies;
             Promise.all(awaitDependencies)
-                .then(function () {
+                .then(() => {
                 // Find the conversion handler for this item type
-                var templateType = template.type;
-                itemHandler_1 = moduleMap[templateType];
-                if (!itemHandler_1 || itemHandler_1 === UNSUPPORTED) {
-                    if (itemHandler_1 === UNSUPPORTED) {
-                        statusCode_1 = common.EItemProgressStatus.Ignored;
+                const templateType = template.type;
+                itemHandler = moduleMap[templateType];
+                if (!itemHandler || itemHandler === UNSUPPORTED) {
+                    if (itemHandler === UNSUPPORTED) {
+                        statusCode = common.EItemProgressStatus.Ignored;
                         throw new Error();
                     }
                     else {
-                        statusCode_1 = common.EItemProgressStatus.Failed;
+                        statusCode = common.EItemProgressStatus.Failed;
                         throw new Error();
                     }
                 }
                 // Get the item's thumbnail
                 return common.getThumbnailFromStorageItem(storageAuthentication, resourceFilePaths);
             })
-                .then(function (thumbnail) {
+                .then(thumbnail => {
                 template.item.thumbnail = thumbnail;
                 // Delegate the creation of the item to the handler
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                return itemHandler_1.createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
+                return itemHandler.createItemFromTemplate(template, templateDictionary, destinationAuthentication, itemProgressCallback);
             })
-                .then(function (response) {
+                .then((response) => {
                 if (response.id === "") {
-                    statusCode_1 = common.EItemProgressStatus.Failed;
+                    statusCode = common.EItemProgressStatus.Failed;
                     throw new Error("handled"); // fails to create item
                 }
                 /* istanbul ignore else */
-                createResponse_1 = response;
-                if (createResponse_1.item.item.url) {
-                    common.setCreateProp(templateDictionary, template.itemId + ".url", createResponse_1.item.item.url);
+                createResponse = response;
+                if (createResponse.item.item.url) {
+                    common.setCreateProp(templateDictionary, template.itemId + ".url", createResponse.item.item.url);
                 }
                 if (resourceFilePaths.length > 0) {
                     // Copy resources, metadata, form
-                    return common.copyFilesFromStorageItem(storageAuthentication, resourceFilePaths, templateDictionary.folderId, createResponse_1.id, destinationAuthentication, createResponse_1.item);
+                    return common.copyFilesFromStorageItem(storageAuthentication, resourceFilePaths, templateDictionary.folderId, createResponse.id, destinationAuthentication, createResponse.item);
                 }
                 else {
                     return Promise.resolve(null);
                 }
             })
-                .then(function () {
-                resolve(createResponse_1);
+                .then(() => {
+                resolve(createResponse);
             })
-                .catch(function (error) {
+                .catch(error => {
                 if (!error || error.message !== "handled") {
-                    itemProgressCallback(template.itemId, statusCode_1 === common.EItemProgressStatus.Unknown
+                    itemProgressCallback(template.itemId, statusCode === common.EItemProgressStatus.Unknown
                         ? common.EItemProgressStatus.Failed
-                        : statusCode_1, 0);
+                        : statusCode, 0);
                 }
                 // Item type not supported or fails to get item dependencies
                 resolve(common.generateEmptyCreationResponse(template.type));
@@ -796,15 +789,15 @@ export function _createItemFromTemplateWhenReady(template, resourceFilePaths, st
  * @protected
  */
 export function _estimateDeploymentCost(templates) {
-    return templates.reduce(function (accumulatedEstimatedCost, template) {
+    return templates.reduce((accumulatedEstimatedCost, template) => {
         return (accumulatedEstimatedCost + (template.estimatedDeploymentCostFactor || 1));
     }, 0);
 }
 // TODO: Return a Promise vs array of promises
 export function _getGroupUpdates(template, authentication, templateDictionary) {
-    var groups = template.groups || [];
-    return groups.map(function (sourceGroupId) {
-        return common.shareItem(templateDictionary[sourceGroupId].itemId, template.itemId, authentication);
+    const groups = template.groups || [];
+    return groups.map((sourceGroupId) => {
+        return common.shareItem(templateDictionary[sourceGroupId].itemId, template.itemId, authentication, common.isTrackingViewTemplate(template) ? templateDictionary.locationTracking.owner : undefined);
     });
 }
 //# sourceMappingURL=deploySolutionItems.js.map