@esri/solutions-components 0.6.17 → 0.6.19

package/dist/esm/{solution-store-b29d50f7.js → solution-resource-be35d35b.js}

@@ -3,10 +3,7 @@
  * Licensed under the Apache License, Version 2.0
  * http://www.apache.org/licenses/LICENSE-2.0
  */
-import { c as createStore } from './index-f4bd5aa3.js';
-import { d as EUpdateType } from './interfaces-7470d906.js';
 import { c as createCommonjsModule, a as commonjsGlobal, b as commonjsRequire } from './_commonjsHelpers-d5f9d613.js';
-import { c as cleanUrl, r as request } from './clean-url-bce022e6.js';
 
 /** @license
  * Copyright 2018 Esri
@@ -63,263 +60,6 @@ var EItemProgressStatus;
 })(EItemProgressStatus || (EItemProgressStatus = {}));
 //#endregion ---------------------------------------------------------------------------------------------------------//
 
-/* Copyright (c) 2018-2019 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * Returns an array with arrays of the given size.
- *
- * @param arr Array to split
- * @param size Size of every group
- */
-function chunkArray(arr, size) {
-    const results = [];
-    let index = 0;
-    while (index < arr.length) {
-        results.push(arr.slice(index, index + size));
-        index += size;
-    }
-    return results;
-}
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * Helper that returns the appropriate portal url for a given request. `requestOptions.portal` is given
- * precedence over `authentication.portal`. If neither `portal` nor `authentication` is present,
- * `www.arcgis.com/sharing/rest` is returned.
- *
- * @param requestOptions - Request options that may have authentication manager
- * @returns Portal url to be used in API requests
- */
-function getPortalUrl(requestOptions) {
-    if (requestOptions === void 0) { requestOptions = {}; }
-    // use portal in options if specified
-    if (requestOptions.portal) {
-        return cleanUrl(requestOptions.portal);
-    }
-    // if auth was passed, use that portal
-    if (requestOptions.authentication) {
-        // the portal url is already scrubbed in the auth package
-        return requestOptions.authentication.portal;
-    }
-    // default to arcgis.com
-    return "https://www.arcgis.com/sharing/rest";
-}
-
-/* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * Serialize an item and its data into a json format accepted by the Portal API for create and update operations
- *
- * @param item Item to be serialized
- * @returns a formatted json object to be sent to Portal
- */
-function serializeItem(item) {
-    // create a clone so we're not messing with the original
-    var clone = JSON.parse(JSON.stringify(item));
-    // binary data needs POSTed as a `file`
-    // JSON object literals should be passed as `text`.
-    if (clone.data) {
-        (typeof Blob !== "undefined" && item.data instanceof Blob) ||
-            // Node.js doesn't implement Blob
-            item.data.constructor.name === "ReadStream"
-            ? (clone.file = item.data)
-            : (clone.text = item.data);
-        delete clone.data;
-    }
-    return clone;
-}
-/**
- * `requestOptions.owner` is given priority, `requestOptions.item.owner` will be checked next. If neither are present, `authentication.getUserName()` will be used instead.
- */
-function determineOwner(requestOptions) {
-    if (requestOptions.owner) {
-        return Promise.resolve(requestOptions.owner);
-    }
-    else if (requestOptions.item && requestOptions.item.owner) {
-        return Promise.resolve(requestOptions.item.owner);
-    }
-    else if (requestOptions.authentication &&
-        requestOptions.authentication.getUsername) {
-        return requestOptions.authentication.getUsername();
-    }
-    else {
-        return Promise.reject(new Error("Could not determine the owner of this item. Pass the `owner`, `item.owner`, or `authentication` option."));
-    }
-}
-/**
- * checks if the extent is a valid BBox (2 element array of coordinate pair arrays)
- * @param extent
- * @returns
- */
-function isBBox(extent) {
-    return (Array.isArray(extent) &&
-        Array.isArray(extent[0]) &&
-        Array.isArray(extent[1]));
-}
-/**
- * Given a Bbox, convert it to a string. Some api endpoints expect a string
- *
- * @param {BBox} extent
- * @return {*}  {string}
- */
-function bboxToString(extent) {
-    return extent.join(",");
-}
-
-/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * ```js
- * import { updateItem } from "@esri/arcgis-rest-portal";
- * //
- * updateItem({
- *   item: {
- *     id: "3ef",
- *     description: "A three hour tour"
- *   },
- *   authentication
- * })
- *   .then(response)
- * ```
- * Update an Item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/update-item.htm) for more information.
- *
- * @param requestOptions - Options for the request.
- * @returns A Promise that updates an item.
- */
-function updateItem$1(requestOptions) {
-    return determineOwner(requestOptions).then(function (owner) {
-        var url = requestOptions.folderId
-            ? getPortalUrl(requestOptions) + "/content/users/" + owner + "/" + requestOptions.folderId + "/items/" + requestOptions.item.id + "/update"
-            : getPortalUrl(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.item.id + "/update";
-        // serialize the item into something Portal will accept
-        requestOptions.params = __assign(__assign({}, requestOptions.params), serializeItem(requestOptions.item));
-        // convert extent, if present, into a string from bbox
-        // processParams was previously doing this sort of work,
-        // however now we need to let array of arrays through
-        // Thus for extents we need to move this logic here
-        if (requestOptions.params.extent && isBBox(requestOptions.params.extent)) {
-            requestOptions.params.extent = bboxToString(requestOptions.params.extent);
-        }
-        return request(url, requestOptions);
-    });
-}
-/**
- * ```js
- * import { updateItemResource } from "@esri/arcgis-rest-portal";
- * //
- * updateItemResource({
- *   id: '3ef',
- *   resource: file,
- *   name: 'bigkahuna.jpg',
- *   authentication
- * })
- *   .then(response)
- * ```
- * Update a resource associated with an item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/update-resources.htm) for more information.
- *
- * @param requestOptions - Options for the request
- * @returns A Promise that updates an item resource.
- */
-function updateItemResource(requestOptions) {
-    return determineOwner(requestOptions).then(function (owner) {
-        var url = getPortalUrl(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/updateResources";
-        // mix in user supplied params
-        requestOptions.params = __assign({ file: requestOptions.resource, fileName: requestOptions.name, resourcesPrefix: requestOptions.prefix, text: requestOptions.content }, requestOptions.params);
-        // only override the access specified previously if 'private' is passed explicitly
-        if (typeof requestOptions.private !== "undefined") {
-            requestOptions.params.access = requestOptions.private
-                ? "private"
-                : "inherit";
-        }
-        return request(url, requestOptions);
-    });
-}
-
-/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * ```js
- * import { addItemResource } from "@esri/arcgis-rest-portal";
- * //
- * // Add a file resource
- * addItemResource({
- *   id: '3ef',
- *   resource: file,
- *   name: 'bigkahuna.jpg',
- *   authentication
- * })
- *   .then(response)
- * //
- * // Add a text resource
- * addItemResource({
- *   id: '4fg',
- *   content: "Text content",
- *   name: 'bigkahuna.txt',
- *   authentication
- * })
- *   .then(response)
- * ```
- * Add a resource associated with an item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/add-resources.htm) for more information.
- *
- * @param requestOptions - Options for the request
- * @returns A Promise to add item resources.
- */
-function addItemResource(requestOptions) {
-    return determineOwner(requestOptions).then(function (owner) {
-        var url = getPortalUrl(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/addResources";
-        requestOptions.params = __assign({ file: requestOptions.resource, fileName: requestOptions.name, resourcesPrefix: requestOptions.prefix, text: requestOptions.content, access: requestOptions.private ? "private" : "inherit" }, requestOptions.params);
-        return request(url, requestOptions);
-    });
-}
-
-/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
- * Apache-2.0 */
-/**
- * Remove a resource associated with an item
- *
- * @param requestOptions - Options for the request
- * @returns A Promise that deletes an item resource.
- */
-function removeItemResource(requestOptions) {
-    return determineOwner(requestOptions).then(function (owner) {
-        var url = getPortalUrl(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/removeResources";
-        // mix in user supplied params
-        requestOptions.params = __assign(__assign({}, requestOptions.params), { resource: requestOptions.resource });
-        // only override the deleteAll param specified previously if it is passed explicitly
-        if (typeof requestOptions.deleteAll !== "undefined") {
-            requestOptions.params.deleteAll = requestOptions.deleteAll;
-        }
-        return request(url, requestOptions);
-    });
-}
-
 var jszip_min = createCommonjsModule(function (module, exports) {
 /*!
 
@@ -2035,408 +1775,6 @@ var xss = FilterXSS;
 	}
 } (lib$1, lib$1.exports));
 
-/** @license
- * Copyright 2020 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Supplies the File constructor for Microsoft Legacy Edge.
- *
- * @param fileBits Contents for file
- * @param fileName Name for file
- * @param options Bucket of options, euch as `type` for the MIME type; defaults to empty string for `type`
- * @returns File or, for Microsoft Legacy Edge, Blob
- * @see https://developer.mozilla.org/en-US/docs/Web/API/File/File
- * @see https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob
- */
-function new_File(fileBits, fileName, options) {
-    let file;
-    try {
-        // Modern browser
-        file = new File(fileBits, fileName, options);
-    }
-    catch (error) {
-        // Microsoft Legacy Edge
-        /* istanbul ignore next */
-        file = (function () {
-            if (typeof options === "undefined") {
-                // Microsoft Legacy Edge fails in karma if options is not defined
-                options = {
-                    type: ""
-                };
-            }
-            const blob = new Blob(fileBits, options);
-            blob.lastModified = new Date();
-            blob.name = fileName;
-            return blob;
-        })();
-    }
-    return file;
-}
-
-/** @license
- * Copyright 2018 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Extracts JSON from a Blob.
- *
- * @param blob Blob to use as source
- * @returns A promise that will resolve with JSON or null
- */
-function blobToJson(blob) {
-    return new Promise(resolve => {
-        blobToText(blob).then(blobContents => {
-            try {
-                resolve(JSON.parse(blobContents));
-            }
-            catch (err) {
-                resolve(null);
-            }
-        }, () => resolve(null));
-    });
-}
-/**
- * Converts a Blob to a File.
- *
- * @param blob Blob to use as source
- * @param filename Name to use for file
- * @param mimeType MIME type to override blob's MIME type
- * @returns File created out of Blob and filename
- */
-function blobToFile(blob, filename, mimeType) {
-    return blob
-        ? new_File([blob], filename ? filename : "", {
-            type: mimeType || blob.type
-        })
-        : null;
-}
-/**
- * Extracts text from a Blob.
- *
- * @param blob Blob to use as source
- * @returns A promise that will resolve with text read from blob
- */
-function blobToText(blob) {
-    return new Promise(resolve => {
-        const reader = new FileReader();
-        reader.onload = function (evt) {
-            // Disable needed because Node requires cast
-            // tslint:disable-next-line: no-unnecessary-type-assertion
-            const blobContents = evt.target.result;
-            resolve(blobContents ? blobContents : ""); // not handling ArrayContents variant
-        };
-        reader.readAsText(blob);
-    });
-}
-/**
- * Checks that a URL path ends with a slash.
- *
- * @param url URL to check
- * @returns URL, appended with slash if missing
- */
-function checkUrlPathTermination(url) {
-    return url ? (url.endsWith("/") ? url : url + "/") : url;
-}
-/**
- * Gets a property out of a deeply nested object.
- * Does not handle anything but nested object graph
- *
- * @param obj Object to retrieve value from
- * @param path Path into an object, e.g., "data.values.webmap", where "data" is a top-level property
- *             in obj
- * @returns Value at end of path
- */
-function getProp(obj, path) {
-    return path.split(".").reduce(function (prev, curr) {
-        /* istanbul ignore next no need to test undefined scenario */
-        return prev ? prev[curr] : undefined;
-    }, obj);
-}
-/**
- * Sets a deeply nested property of an object.
- * Creates the full path if it does not exist.
- *
- * @param obj Object to set value of
- * @param path Path into an object, e.g., "data.values.webmap", where "data" is a top-level property in obj
- * @param value The value to set at the end of the path
- */
-function setCreateProp(obj, path, value) {
-    const pathParts = path.split(".");
-    pathParts.reduce((a, b, c) => {
-        if (c === pathParts.length - 1) {
-            a[b] = value;
-            return value;
-        }
-        else {
-            if (!a[b]) {
-                a[b] = {};
-            }
-            return a[b];
-        }
-    }, obj);
-}
-
-/**
- * Gets a Blob from a web site.
- *
- * @param url Address of Blob
- * @param authentication Credentials for the request
- * @param requestOptions - Options for the request, including parameters relevant to the endpoint.
- * @returns Promise that will resolve with Blob or an AGO-style JSON failure response
- */
-function getBlob(url, authentication, requestOptions = {}) {
-    if (!url) {
-        return Promise.reject("Url must be provided");
-    }
-    const blobRequestOptions = {
-        authentication: authentication,
-        rawResponse: true,
-        ...requestOptions
-    };
-    return request(url, blobRequestOptions).then(response => {
-        return response.blob();
-    });
-}
-
-/** @license
- * Copyright 2018 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// ------------------------------------------------------------------------------------------------------------------ //
-const ZIP_FILE_HEADER_SIGNATURE = "PK";
-/**
- * Gets a Blob from a web site and casts it as a file using the supplied name.
- *
- * @param url Address of Blob
- * @param filename Name to use for file
- * @param authentication Credentials for the request
- * @returns Promise that will resolve with a File, undefined if the Blob is null, or an AGO-style JSON failure response
- */
-function getBlobAsFile(url, filename, authentication, ignoreErrors = [], mimeType) {
-    return new Promise((resolve, reject) => {
-        // Get the blob from the URL
-        getBlobCheckForError(url, authentication, ignoreErrors).then(blob => !blob ? resolve(null) : resolve(blobToFile(blob, filename, mimeType)), reject);
-    });
-}
-/**
- * Gets a Blob from a web site and checks for a JSON error packet in the Blob.
- *
- * @param url Address of Blob
- * @param authentication Credentials for the request
- * @param ignoreErrors List of HTTP error codes that should be ignored
- * @returns Promise that will resolve with Blob or an AGO-REST JSON failure response
- */
-function getBlobCheckForError(url, authentication, ignoreErrors = []) {
-    return new Promise((resolve, reject) => {
-        // Get the blob from the URL
-        getBlob(url, authentication).then(blob => {
-            // Reclassify text/plain blobs as needed
-            _fixTextBlobType(blob).then(adjustedBlob => {
-                if (adjustedBlob.type === "application/json") {
-                    // Blob may be an error
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    blobToJson(adjustedBlob).then((json) => {
-                        // Check for valid JSON with an error
-                        if (json?.error) {
-                            const code = json.error.code;
-                            if (code !== undefined && ignoreErrors.indexOf(code) >= 0) {
-                                resolve(null); // Error, but ignored
-                            }
-                            else {
-                                reject(json); // Other error; fail with error
-                            }
-                        }
-                        else {
-                            resolve(adjustedBlob);
-                        }
-                    });
-                }
-                else {
-                    resolve(adjustedBlob);
-                }
-            }, reject);
-        }, reject);
-    });
-}
-/**
- * Gets the data information of an AGO item in its JSON form.
- *
- * @param itemId Id of an item whose data information is sought
- * @param filename Name to use for file
- * @param authentication Credentials for the request to AGO
- * @returns Promise that will resolve with JSON, or an AGO-style JSON failure response
- */
-function getItemDataAsJson(itemId, authentication) {
-    return new Promise(resolve => {
-        getItemDataBlob(itemId, authentication).then(blob => resolve(blobToJson(blob)), () => resolve(null));
-    });
-}
-/**
- * Gets the data information of an AGO item in its raw (Blob) form.
- *
- * @param itemId Id of an item whose data information is sought
- * @param authentication Credentials for the request to AGO
- * @returns A promise that will resolve with the data Blob or null if the item doesn't have a data section
- */
-function getItemDataBlob(itemId, authentication) {
-    return new Promise(resolve => {
-        const url = getItemDataBlobUrl(itemId, authentication);
-        getBlobCheckForError(url, authentication, [400, 500]).then(blob => resolve(_fixTextBlobType(blob)), () => resolve(null));
-    });
-}
-/**
- * Gets the URL to the data information of an AGO item in its raw (Blob) form.
- *
- * @param itemId Id of an item whose data information is sought
- * @param authentication Credentials for the request to AGO
- * @returns URL string
- */
-function getItemDataBlobUrl(itemId, authentication) {
-    return `${getPortalSharingUrlFromAuth(authentication)}/content/items/${itemId}/data`;
-}
-/**
- * Extracts the portal sharing url from a supplied authentication.
- *
- * @param authentication Credentials for the request to AGO
- * @returns Portal sharing url to be used in API requests, defaulting to `https://www.arcgis.com/sharing/rest`
- */
-function getPortalSharingUrlFromAuth(authentication) {
-    // If auth was passed, use that portal
-    return getProp(authentication, "portal") || "https://www.arcgis.com/sharing/rest";
-}
-function getThumbnailFile(url, filename, authentication) {
-    return new Promise(resolve => {
-        getBlobAsFile(url, filename, authentication, [500]).then(resolve, () => resolve(null));
-    });
-}
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Fixes the types of Blobs incorrectly typed as text/plain.
- *
- * @param blob Blob to check
- * @returns Promise resolving to original Blob, unless it's originally typed as text/plain but is
- * really JSON, ZIP, or XML
- * @private
- */
-function _fixTextBlobType(blob) {
-    return new Promise((resolve, reject) => {
-        if (blob &&
-            blob.size > 0 &&
-            (blob.type.startsWith("text/plain") ||
-                blob.type.startsWith("application/json"))) {
-            blobToText(blob).then(blobText => {
-                // Convertible to JSON?
-                try {
-                    JSON.parse(blobText);
-                    // Yes; reclassify as JSON
-                    resolve(new Blob([blob], { type: "application/json" }));
-                }
-                catch (ignored) {
-                    // Nope; test for ZIP file
-                    if (blobText.length > 4 &&
-                        blobText.substr(0, 4) === ZIP_FILE_HEADER_SIGNATURE) {
-                        // Yes; reclassify as ZIP
-                        resolve(new Blob([blob], { type: "application/zip" }));
-                    }
-                    else if (blobText.startsWith("<")) {
-                        // Reclassify as XML; since the blob started out as text/plain, it's more likely that is
-                        // meant to be human-readable, so we'll use text/xml instead of application/xml
-                        resolve(new Blob([blob], { type: "text/xml" }));
-                    }
-                    else {
-                        // Leave as text
-                        resolve(blob);
-                    }
-                }
-            }, 
-            // Faulty blob
-            reject);
-        }
-        else {
-            // Empty or not typed as plain text, so simply return
-            if (blob) {
-                resolve(blob);
-            }
-            else {
-                reject();
-            }
-        }
-    });
-}
-
-/** @license
- * Copyright 2018 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Updates an item.
- *
- * @param itemInfo The base info of an item; note that this content will be serialized, which doesn't work
- * for binary content
- * @param authentication Credentials for request
- * @param folderId Item's folder
- * @param additionalParams Updates that are put under the `params` property, which is not serialized
- * @return
- */
-function updateItem(itemInfo, authentication, folderId, additionalParams) {
-    return new Promise((resolve, reject) => {
-        const updateOptions = {
-            item: itemInfo,
-            folderId: folderId,
-            authentication: authentication,
-            params: {
-                ...(additionalParams ?? {})
-            }
-        };
-        updateItem$1(updateOptions).then(response => (response.success ? resolve(response) : reject(response)), err => reject(err));
-    });
-}
-
 /** @license
  * Copyright 2018 Esri
  *
@@ -2495,1038 +1833,4 @@ var SolutionResourceType;
     SolutionResourceType[SolutionResourceType["info"] = 5] = "info";
 })(SolutionResourceType || (SolutionResourceType = {}));
 
-/** @license
- * Copyright 2020 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Extracts an item's resource folder and filename from the filename used to store a copy in a storage item.
- *
- * @param storageResourceFilename Filename used to store the resource, metadata, or thumbnail of an item
- * @param storageVersion Version of the Solution template
- * @returns Folder and filename for storing information in an item, as well as the type (resource, metadata,
- * or thumbnail) of the information; the folder property is only meaningful for the resource type
- * @see generateResourceStorageFilename
- * @see generateMetadataStorageFilename
- * @see generateThumbnailStorageFilename
- * @see convertItemResourceToStorageResource
- */
-function convertStorageResourceToItemResource(storageResourceFilename, storageVersion = 0) {
-    const nameParts = storageResourceFilename.split("/");
-    let filename = nameParts.pop();
-    let folder = "";
-    const firstPrefixPart = nameParts.shift(); // undefined if there's no folder
-    // Handle special "folders"
-    let type = EFileType.Resource;
-    if (firstPrefixPart) {
-        if (firstPrefixPart.endsWith("_info_thumbnail")) {
-            type = EFileType.Thumbnail;
-        }
-        else if (firstPrefixPart.endsWith("_info_metadata")) {
-            type = EFileType.Metadata;
-            filename = "metadata.xml";
-        }
-        else if (firstPrefixPart.endsWith("_info_data")) {
-            type = EFileType.Data;
-        }
-        else if (firstPrefixPart.endsWith("_info_dataz")) {
-            filename = filename.replace(/\.zip$/, "");
-            type = EFileType.Data;
-            // Otherwise, strip off item id
-        }
-        else if (storageVersion < 1) {
-            // Version 0
-            const folderStart = firstPrefixPart.indexOf("_");
-            if (folderStart > 0) {
-                folder = firstPrefixPart.substr(folderStart + 1);
-            }
-        }
-        else {
-            // Version ≥ 1
-            folder = nameParts.join("/"); // folder is optional, in which case this will be ""
-        }
-    }
-    return { type, folder, filename };
-}
-
-/** @license
- * Copyright 2021 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Generates IAssociatedFileCopyResults object.
- *
- * @param fileInfo Info about item that was to be copied
- * @param fetchedFromSource Status of fetching item from source
- * @param copiedToDestination Status of copying item to destination
- * @returns IAssociatedFileCopyResults object
- */
-function createCopyResults(fileInfo, fetchedFromSource, copiedToDestination) {
-    return {
-        ...fileInfo,
-        fetchedFromSource,
-        copiedToDestination
-    };
-}
-
-/** @license
- * Copyright 2021 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Copies a resource into a zipfile.
- *
- * @param file Information about the source and destination of the file such as its URL, folder, filename
- * @param zipInfo Information about a zipfile such as its name and its zip object
- * @returns The result of the copy
- */
-function copyResourceIntoZip(file, zipInfo) {
-    // Add it to the zip
-    if (file.folder) {
-        zipInfo.zip
-            .folder(file.folder)
-            .file(file.filename, file.file, { binary: true });
-    }
-    else {
-        zipInfo.zip.file(file.filename, file.file, { binary: true });
-    }
-    zipInfo.filelist.push(file);
-    return createCopyResults(file, true);
-}
-
-/** @license
- * Copyright 2021 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Copies a zipfile into an AGO item.
- *
- * @param zipInfo Information about a zipfile such as its name and its zip object
- * @param destinationItemId Id of item to receive copy of resource/metadata/thumbnail
- * @param destinationAuthentication Credentials for the request to the storage
- * @returns A promise which resolves to the result of the copy
- */
-function copyZipIntoItem(zipInfo, destinationItemId, destinationAuthentication) {
-    return new Promise(resolve => {
-        zipInfo.zip
-            .generateAsync({ type: "blob" })
-            .then((content) => {
-            return blobToFile(content, zipInfo.filename, "application/zip");
-        })
-            .then((zipfile) => {
-            const addResourceOptions = {
-                id: destinationItemId,
-                resource: zipfile,
-                authentication: destinationAuthentication,
-                params: {
-                    archive: true
-                }
-            };
-            return addItemResource(addResourceOptions);
-        })
-            .then(() => resolve(createCopyResults(zipInfo, true, true)), () => resolve(createCopyResults(zipInfo, true, false)) // unable to add resource
-        );
-    });
-}
-
-/** @license
- * Copyright 2021 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// ------------------------------------------------------------------------------------------------------------------ //
-/**
- * Copies the files for storing the resources, metadata, and thumbnail of an item or group to a storage item
- * with a specified path by collecting files into zip files.
- *
- * @param files List of item files' URLs and folder/filenames for storing the files
- * @param destinationItemId Id of item to receive copy of resource/metadata/thumbnail
- * @param destinationAuthentication Credentials for the request to the storage
- * @param filesPerZip Number of files to include per zip file; AGO limits zips to 50 files
- * @returns A promise which resolves to a list of the result of the copies
- */
-function copyFilesAsResources(files, destinationItemId, destinationAuthentication, filesPerZip = 40) {
-    return new Promise(resolve => {
-        let awaitAllItems = [];
-        const zipInfos = [];
-        if (files.length > 0) {
-            // Bundle the resources into chunked zip updates because AGO tends to have problems with
-            // many updates in a row to the same item: it claims success despite randomly failing.
-            // Note that AGO imposes a limit of 50 files per zip, so we break the list of resource
-            // file info into chunks below this threshold and start a zip for each
-            // https://developers.arcgis.com/rest/users-groups-and-items/add-resources.htm
-            const chunkedResourceFiles = chunkArray(files, filesPerZip);
-            chunkedResourceFiles.forEach((chunk, index) => {
-                // Create a zip for this chunk
-                const zipInfo = {
-                    filename: `resources${index}.zip`,
-                    zip: new jszip_min(),
-                    filelist: []
-                };
-                awaitAllItems = awaitAllItems.concat(chunk.map(file => copyResourceIntoZip(file, zipInfo)));
-                zipInfos.push(zipInfo);
-            });
-        }
-        if (awaitAllItems.length > 0) {
-            // Wait until the Resource zip file(s) are prepared
-            void Promise.all(awaitAllItems).then((results) => {
-                // We have three types of results:
-                // | fetchedFromSource | copiedToDestination |             interpretation            |        |
-                // +-------------------+---------------------+------------------------------------------------+
-                // |       false       |          *          | could not fetch file from source               |
-                // |       true        |        true         | file has been fetched and sent to AGO          |
-                // |       true        |      undefined      | file has been fetched and will be sent via zip |
-                // Filter out copiedToDestination===undefined; we'll get their status when we send their zip
-                results = results.filter((result) => !(result.fetchedFromSource &&
-                    typeof result.copiedToDestination === "undefined"));
-                // Now send the resources to AGO
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                _copyAssociatedFileZips(zipInfos, destinationItemId, destinationAuthentication).then((zipResults) => {
-                    resolve(results.concat(zipResults));
-                });
-            });
-        }
-        else {
-            // No data, metadata, or resources to send; we're done
-            resolve([]);
-        }
-    });
-}
-/**
- * Copies one or more zipfiles to a storage item.
- *
- * @param zipInfos List of zip files containing files to store
- * @param destinationItemId Id of item to receive copy of resource/metadata/thumbnail
- * @param destinationAuthentication Credentials for the request to the storage
- * @returns A promise which resolves to a list of the result of the copies
- * @private
- */
-function _copyAssociatedFileZips(zipInfos, destinationItemId, destinationAuthentication) {
-    return new Promise(resolve => {
-        const results = [];
-        // Filter out empty zips, which can happen when none of the files in the chunk going into a zip
-        // can be fetched; e.g., the only file is metadata.xml, and the source item doesn't have metadata
-        const nonEmptyZipInfos = zipInfos.filter((zipInfo) => Object.keys(zipInfo.zip.files).length > 0);
-        if (nonEmptyZipInfos.length > 0) {
-            // Send the zip(s) to AGO
-            void _sendZipsSeriallyToItem(nonEmptyZipInfos, destinationItemId, destinationAuthentication).then((zipResults) => {
-                resolve(zipResults);
-            });
-        }
-        else {
-            // No resources to send; we're done
-            resolve(results);
-        }
-    });
-}
-/**
- * Copies one or more zipfiles to a storage item in a serial fashion, waiting a bit between sends.
- *
- * @param zipInfos List of zip files containing files to store
- * @param destinationItemId Id of item to receive copy of resource/metadata/thumbnail
- * @param destinationAuthentication Credentials for the request to the storage
- * @returns A promise which resolves to a list of the result of the copies
- */
-function _sendZipsSeriallyToItem(zipInfos, destinationItemId, destinationAuthentication) {
-    return new Promise(resolve => {
-        let allResults = [];
-        // Remove zip from bottom of list
-        const zipInfoToSend = zipInfos.pop();
-        // Send predecessors in list
-        let sendOthersPromise = Promise.resolve([]);
-        if (zipInfos.length > 0) {
-            sendOthersPromise = _sendZipsSeriallyToItem(zipInfos, destinationItemId, destinationAuthentication);
-        }
-        void sendOthersPromise
-            .then((response) => {
-            allResults = response;
-            // Stall a little to give AGO time to catch up
-            return new Promise(resolveSleep => {
-                setTimeout(() => resolveSleep(), 1000);
-            });
-        })
-            .then(() => {
-            // Now send the zip removed from bottom of the input list
-            return copyZipIntoItem(zipInfoToSend, destinationItemId, destinationAuthentication);
-        })
-            .then((zipResult) => {
-            // Save the result of copying this zip as a status for each of the files that it contains
-            zipResult.filelist.forEach((fileInfo) => {
-                allResults.push(createCopyResults(fileInfo, true, zipResult.copiedToDestination));
-            });
-            resolve(allResults);
-        });
-    });
-}
-
-/** @license
- * Copyright 2018 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Copies the files for storing the resources, metadata, and thumbnail of an item or group to a storage item
- * with a specified path.
- *
- * @param files List of item files and paths for storing the files
- * @param storageItemId Id of item to receive copy of resource/metadata
- * @param storageAuthentication Credentials for the request to the storage
- * @returns A promise which resolves to a list of the filenames under which the resource/metadata are stored
- */
-function copyFilesToStorageItem(files, storageItemId, storageAuthentication) {
-    return new Promise(resolve => {
-        // tslint:disable-next-line: no-floating-promises
-        void copyFilesAsResources(files, storageItemId, storageAuthentication).then((results) => {
-            resolve(results
-                // Filter out failures
-                .filter((result) => result.fetchedFromSource && result.copiedToDestination)
-                // Return folder and filename in storage item's resources
-                .map((result) => result.folder + "/" + result.filename));
-        });
-    });
-}
-/**
- * Generates the URL for reading an item's resource given the filename of the resource.
- *
- * @param sourcePortalSharingUrl Server/sharing
- * @param itemId Id of item
- * @param sourceResourceFilename Either filename or folder/filename to resource
- * @returns URL string
- */
-function generateSourceResourceUrl(sourcePortalSharingUrl, itemId, sourceResourceFilename) {
-    return (checkUrlPathTermination(sourcePortalSharingUrl) +
-        "content/items/" +
-        itemId +
-        "/resources/" +
-        sourceResourceFilename);
-}
-/**
- * Generates a list of full URLs and folder/filename combinations used to store the resources, metadata,
- * and thumbnail of an item.
- *
- * @param portalSharingUrl Server/sharing
- * @param storageItemId Id of storage item
- * @param resourceFilenames List of resource filenames for an item, e.g., ["file1", "myFolder/file2"]
- * @param storageVersion Version of the Solution template
- * @returns List of item files' URLs and folder/filenames for storing the files
- */
-function generateStorageFilePaths(portalSharingUrl, storageItemId, resourceFilenames = [], storageVersion = 0) {
-    return resourceFilenames.map(resourceFilename => {
-        return {
-            url: generateSourceResourceUrl(portalSharingUrl, storageItemId, resourceFilename),
-            ...convertStorageResourceToItemResource(resourceFilename, storageVersion)
-        };
-    });
-}
-function isSupportedFileType(filename) {
-    // Supported file formats are: .json, .xml, .txt, .png, .pbf, .zip, .jpeg, .jpg, .gif, .bmp, .gz, .svg,
-    // .svgz, .geodatabase (https://developers.arcgis.com/rest/users-groups-and-items/add-resources.htm)
-    const filenameExtension = filename.match(/\.([a-z]+)$/i);
-    const supportedExtensions = "|.json|.xml|.txt|.png|.pbf|.zip|.jpeg|.jpg|.gif|.bmp|.gz|.svg|.svgz|.geodatabase|";
-    return (!!filenameExtension &&
-        supportedExtensions.indexOf("|" + filenameExtension[0] + "|") >= 0);
-}
-/**
- * Gets the thumbnail of an item or group.
- *
- * @param authentication Credentials for the request to the storage
- * @param filePaths List of item files' URLs and folder/filenames for storing the files
- * @returns A promise which resolves to a boolean indicating if the copies were successful
- */
-function getThumbnailFromStorageItem(authentication, filePaths) {
-    let thumbnailUrl;
-    let thumbnailFilename;
-    filePaths.forEach(path => {
-        if (path.type === EFileType.Thumbnail) {
-            thumbnailUrl = path.url;
-            thumbnailFilename = path.filename;
-        }
-    });
-    if (!thumbnailUrl) {
-        return Promise.resolve(null);
-    }
-    return getThumbnailFile(thumbnailUrl, thumbnailFilename, authentication);
-}
-/**
- * Removes the item's resource that matches the filename with new content
- *
- * @param itemId Id of the item to remove
- * @param filename Name of the resource file to remove
- * @param authentication Credentials for the request to the storage
- * @returns A promise which resolves with a success true/false response
- */
-function removeItemResourceFile(itemId, filename, authentication) {
-    return removeItemResource({
-        id: itemId,
-        resource: filename,
-        authentication: authentication
-    });
-}
-/**
- * Updates the item's resource that matches the filename with new content
- *
- * @param itemId Id of the item to update
- * @param filename Name of the resource file to update; prefix optional (e.g., a/b/file.txt)
- * @param resource The new content to update the resource with
- * @param authentication Credentials for the request to the storage
- * @returns A promise which resolves with a success true/false response
- */
-function updateItemResourceFile(itemId, filename, resource, authentication) {
-    // Prefix has to be specified separately
-    const prefixedFilenameParts = filename.split("/");
-    const prefix = prefixedFilenameParts.length > 1 ? prefixedFilenameParts.slice(0, prefixedFilenameParts.length - 1).join("/") : undefined;
-    const suffix = prefixedFilenameParts[prefixedFilenameParts.length - 1];
-    return updateItemResource({
-        id: itemId,
-        prefix: prefix,
-        name: suffix,
-        resource,
-        authentication: authentication
-    });
-}
-
-/** @license
- * Copyright 2022 Esri
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const EmptySolutionStore = {
-  solutionItemId: "",
-  defaultWkid: undefined,
-  solutionData: { metadata: {}, templates: [] },
-  templateEdits: {},
-  featureServices: [],
-  spatialReferenceInfo: {
-    enabled: false,
-    services: {},
-    spatialReference: undefined
-  }
-};
-class SolutionStore {
-  /**
-   * Creates singleton instance when accessed; default export from module.
-   *
-   * @returns Static instance of the class
-   */
-  static get Store() {
-    return this._instance || (this._instance = new this());
-  }
-  /**
-   * Creates an empty store.
-   *
-   * @protected
-   */
-  constructor() {
-    this._hasChanges = false;
-    this._store = createStore(Object.assign({}, EmptySolutionStore));
-  }
-  /**
-   * Returns the stored information of an item.
-   *
-   * @param itemId Id of item to fetch
-   *
-   * @returns Item information or `undefined` if not found
-   */
-  getItemInfo(itemId) {
-    const templates = this._store.get("solutionData").templates;
-    let template;
-    templates.some((t) => {
-      if (itemId == t.itemId) {
-        template = t;
-        return true;
-      }
-      return false;
-    });
-    return template;
-  }
-  /**
-   * Returns a top-level store property: solutionItemId, defaultWkid, etc.
-   *
-   * @param propName Name of property
-   *
-   * @returns Value of property
-   */
-  getStoreInfo(propName) {
-    return this._store.get(propName);
-  }
-  /**
-   * Loads a Solution into the store from AGO.
-   *
-   * @param solutionItemId Id of the solution represented in the store
-   * @param authentication Credentials for fetching information to be loaded into the store
-   *
-   * @returns Promise that resolves when task is done
-   */
-  async loadSolution(solutionItemId, authentication) {
-    this._authentication = authentication;
-    const solutionData = await getItemDataAsJson(solutionItemId, authentication);
-    if (solutionData) {
-      const defaultWkid = getProp(solutionData, "params.wkid.default");
-      await this._prepareSolutionItemsForEditing(solutionItemId, solutionData.templates, authentication);
-      const featureServices = this._getFeatureServices(solutionData.templates);
-      const spatialReferenceInfo = this._getSpatialReferenceInfo(featureServices, defaultWkid);
-      this._store.set("solutionItemId", solutionItemId);
-      this._store.set("defaultWkid", defaultWkid);
-      this._store.set("solutionData", solutionData);
-      this._store.set("featureServices", featureServices);
-      this._store.set("spatialReferenceInfo", spatialReferenceInfo);
-    }
-    this._flagStoreHasChanges(false);
-  }
-  /**
-   * Queues the replacement of the thumbnail associated with a template item in the store.
-   *
-   * @param itemEdit Details of the template to modify, containing the new thumbnail in the `thumbnail`
-   * property
-   */
-  replaceItemThumbnail(itemEdit) {
-    // Flag the current thumbnail and any replacements for removal
-    itemEdit.resourceFilePaths.forEach((path) => {
-      if (path.type === EFileType.Thumbnail) {
-        if (path.updateType === EUpdateType.None) {
-          // Existing thumbnail not yet flagged for removal
-          path.updateType = EUpdateType.Remove;
-        }
-        else if (path.updateType === EUpdateType.Add || path.updateType === EUpdateType.Update) {
-          // An earlier replacement
-          path.updateType = EUpdateType.Obsolete;
-        }
-      }
-    });
-    // Remove any replacements already queued
-    itemEdit.resourceFilePaths =
-      itemEdit.resourceFilePaths.filter((path) => path.updateType != EUpdateType.Obsolete);
-    // Add the new thumbnail to the store item
-    itemEdit.resourceFilePaths.push({
-      blob: itemEdit.thumbnail,
-      filename: itemEdit.thumbnail.name,
-      type: EFileType.Thumbnail,
-      updateType: EUpdateType.Add
-    });
-    // Update the store
-    this.setItemInfo(itemEdit);
-  }
-  /**
-   * Writes a Solution into AGO from the store. Must use `loadSolution` to continue with solution.
-   *
-   * @returns Promise that resolves when task is done
-   */
-  async saveSolution() {
-    // Update the templates in the original solution item data
-    const solutionItemId = this._store.get("solutionItemId");
-    const solutionData = this._store.get("solutionData");
-    const spatialReferenceInfo = this._store.get("spatialReferenceInfo");
-    await this._prepareSolutionItemsForStorage(solutionItemId, solutionData.templates, this._authentication);
-    const updatedDefaultWkid = this._setSpatialReferenceInfo(spatialReferenceInfo, solutionData.templates);
-    if (updatedDefaultWkid) {
-      setCreateProp(solutionData, "params.wkid", {
-        "label": "Spatial Reference",
-        "default": updatedDefaultWkid,
-        "valueType": "spatialReference",
-        "attributes": {
-          "required": "true"
-        }
-      });
-    }
-    else {
-      setCreateProp(solutionData, "params.wkid", {});
-    }
-    const itemInfo = {
-      id: solutionItemId,
-      text: solutionData
-    };
-    await updateItem(itemInfo, this._authentication);
-  }
-  /**
-   * Stores information for item.
-   *
-   * @param itemEdit Item information
-   */
-  setItemInfo(itemEdit) {
-    const solutionData = this._store.get("solutionData");
-    const templates = solutionData.templates;
-    templates.some((t) => {
-      if (itemEdit.itemId == t.itemId) {
-        t = itemEdit;
-        this._store.set("solutionData", solutionData);
-        this._flagStoreHasChanges(true);
-        return true;
-      }
-      return false;
-    });
-  }
-  /**
-   * Sets a top-level store property: solutionItemId, defaultWkid, etc.
-   *
-   * @param propName Name of property
-   * @param value Value of property
-   */
-  setStoreInfo(propName, value) {
-    this._store.set(propName, value);
-    this._flagStoreHasChanges(true);
-  }
-  //------------------------------------------------------------------------------------------------------------------//
-  /** Provides access to protected methods for unit testing.
-   *
-   *  @param methodName Name of protected method to run
-   *  @param arg1 First argument to forward to method, e.g., for "_prepareSolutionItemsForEditing", `solutionItemId`
-   *  @param arg2 Second argument to forward to method, e.g., for "_prepareSolutionItemsForEditing", `templates`
-   *  @param arg3 Third argument to forward to method, e.g., for "_prepareSolutionItemsForEditing", `authentication`
-   *
-   *  @returns
-   */
-  _testAccess(methodName, arg1, arg2, arg3) {
-    switch (methodName) {
-      case "_emptyTheStore":
-        this._emptyTheStore();
-        break;
-      case "_getFeatureServices":
-        return this._getFeatureServices(arg1);
-      case "_getItemsSharedWithThisGroup":
-        return this._getItemsSharedWithThisGroup(arg1, arg2);
-      case "_getResourceFilePaths":
-        return this._getResourceFilePaths(arg1, arg2, arg3);
-      case "_getResourceStorageName":
-        return this._getResourceStorageName(arg1, arg2);
-      case "_getSpatialReferenceInfo":
-        return this._getSpatialReferenceInfo(arg1, arg2);
-      case "_prepareSolutionItemsForEditing":
-        return this._prepareSolutionItemsForEditing(arg1, arg2, arg3);
-      case "_prepareSolutionItemsForStorage":
-        return this._prepareSolutionItemsForStorage(arg1, arg2, arg3);
-      case "_setSpatialReferenceInfo":
-        return this._setSpatialReferenceInfo(arg1, arg2);
-      case "_splitFilename":
-        return this._splitFilename(arg1);
-    }
-    return null;
-  }
-  /**
-   * Returns the store to the empty state.
-   *
-   * @protected
-   */
-  _emptyTheStore() {
-    this._store.set("solutionItemId", EmptySolutionStore.solutionItemId);
-    this._store.set("defaultWkid", EmptySolutionStore.defaultWkid);
-    this._store.set("solutionData", EmptySolutionStore.solutionData);
-    this._store.set("templateEdits", EmptySolutionStore.templateEdits);
-    this._store.set("featureServices", EmptySolutionStore.featureServices);
-    this._store.set("spatialReferenceInfo", EmptySolutionStore.spatialReferenceInfo);
-  }
-  /**
-   * Sets the store's flag indicating if it has changes and dispatches an event when
-   * the flag value changes.
-   *
-   * @param flagHasChanges Current state of change in the store; if it doesn't match the value saved in this
-   * object, an event is dispatched with the new value and the saved value is updated
-   *
-   * @protected
-   */
-  _flagStoreHasChanges(flagHasChanges) {
-    // Event for notifying if the store has changes or not
-    if (this._hasChanges !== flagHasChanges) {
-      window.dispatchEvent(new CustomEvent("solutionStoreHasChanges", {
-        detail: flagHasChanges,
-        bubbles: true,
-        cancelable: false,
-        composed: true
-      }));
-    }
-    this._hasChanges = flagHasChanges;
-  }
-  /**
-   * Gets a list of Feature Services that are not views.
-   *
-   * @param templates A list of item templates from the solution
-   *
-   * @returns a list of feature services
-   *
-   * @protected
-   */
-  _getCustomizableFeatureServices(templates) {
-    return templates.reduce((prev, cur) => {
-      if (cur.type === "Feature Service" && cur.item.typeKeywords.indexOf("View Service") < 0) {
-        prev.push(cur);
-      }
-      return prev;
-    }, []);
-  }
-  /**
-   * Gets a list of Feature Services that are not views along with an enabled property that indicates
-   * if the service currently uses a spatial reference variable.
-   *
-   * @param templates A list of item templates from the solution
-   *
-   * @returns a list of feature service names and an enabled property to indicate
-   * if they currently use a spatial reference variable.
-   *
-   * @protected
-   */
-  _getFeatureServices(templates) {
-    const customizeableFeatureServices = this._getCustomizableFeatureServices(templates);
-    return customizeableFeatureServices.map((fs) => {
-      const name = fs.item.title || fs.item.name;
-      const wkid = getProp(fs, "properties.service.spatialReference.wkid");
-      return { name, enabled: wkid.toString().startsWith("{{params.wkid||") };
-    });
-  }
-  /**
-   * Capture the key item details for a given group template
-   *
-   * @param template one of the templates from the current solution
-   * @param templates full list of templates
-   *
-   * @returns a list of IItemShare objects
-   *
-   * @protected
-   */
-  _getItemsSharedWithThisGroup(template, templates) {
-    return templates.reduce((prev, cur) => {
-      if (cur.itemId !== template.itemId && cur.type !== "Group") {
-        prev.push({
-          id: cur.itemId,
-          title: cur.item.name || cur.item.title,
-          isShared: (cur.groups || []).indexOf(template.itemId) > -1,
-          shareItem: (cur.groups || []).indexOf(template.itemId) > -1,
-          type: cur.type,
-          typeKeywords: cur.item.typeKeywords
-        });
-      }
-      return prev;
-    }, []);
-  }
-  /**
-   * Generate storage file paths from the solution template
-   *
-   * @param solutionId the id of the current solution
-   * @param template the current template from the solution
-   * @param portal Portal where file is to be found
-   *
-   * @returns a list of resource file infos
-   *
-   * @protected
-   */
-  _getResourceFilePaths(solutionId, template, portal) {
-    const resourceFilePaths = generateStorageFilePaths(portal, solutionId, template.resources, SolutionTemplateFormatVersion);
-    return resourceFilePaths.map((fp) => {
-      fp.updateType = EUpdateType.None;
-      return fp;
-    });
-  }
-  /**
-   * Generates a resource name from a storage file path.
-   *
-   * @param templateItemId The id of the template item whose resource this is; used as a prefix in the resource name
-   * @param resourcePath Resource file infos
-   *
-   * @returns The resource name to use when attaching a resource to the item.
-   *
-   * @protected
-   */
-  _getResourceStorageName(templateItemId, resourcePath) {
-    /* Converts
-      {
-        "url": "https://myorg.maps.arcgis.com/sharing/rest/content/items/ca924c6db7d247b9a31fa30532fb5913/resources/79036430a6274e17ae915d0278b8569c_info_metadata/metadata.xml",
-        "type": 2,
-        "folder": "",
-        "filename": "metadata.xml",
-        "updateType": 3
-      }
-      to
-      ca924c6db7d247b9a31fa30532fb5913_info_metadata/metadata.xml
-    */
-    let prefix = templateItemId;
-    switch (resourcePath.type) {
-      case EFileType.Data:
-        prefix = `${prefix}_info_data`;
-        break;
-      case EFileType.Info:
-        prefix = `${prefix}_info`;
-        break;
-      case EFileType.Metadata:
-        prefix = `${prefix}_info_metadata`;
-        break;
-      case EFileType.Resource:
-        break;
-      case EFileType.Thumbnail:
-        prefix = `${prefix}_info_thumbnail`;
-        break;
-    }
-    let filenameToUse = resourcePath.filename;
-    if (resourcePath.type == EFileType.Data && filenameToUse && !isSupportedFileType(filenameToUse)) {
-      filenameToUse = filenameToUse + ".zip";
-      prefix += "z";
-    }
-    const filename = resourcePath.folder ? resourcePath.folder + "/" + filenameToUse : filenameToUse;
-    return prefix + "/" + filename;
-  }
-  /**
-   * Extracts basic spatial reference information that is used to determine if a custom spatial reference parameter will
-   * be exposed while deploying this solution and if so what feature services will support it and what will the default wkid be
-   *
-   * @param services a list of objects with service name and enabled property (indicates if they currently use a spatial reference var)
-   * @param data the data object of a solution item
-   *
-   * @returns an object that stores if a custom spatial reference parameter is enabled/disabled,
-   * a list of services and if they are enabled/disabled, and the default wkid
-   *
-   * @protected
-   */
-  _getSpatialReferenceInfo(services, defaultWkid) {
-    const defaultServices = {};
-    services.forEach(service => {
-      defaultServices[service.name] = service.enabled;
-    });
-    return {
-      enabled: defaultWkid !== undefined,
-      services: defaultServices,
-      spatialReference: defaultWkid ? defaultWkid : undefined
-    };
-  }
-  /**
-   * Create and store template items for the editor.
-   *
-   * @param solutionItemId Id of the solution represented in the store
-   * @param templates A list of item templates from the solution
-   * @param authentication Credentials for fetching information to be loaded into the store
-   *
-   * @returns a promise that resolves when the templates are ready
-   *
-   * @protected
-   */
-  async _prepareSolutionItemsForEditing(solutionItemId, templates, authentication) {
-    const thumbnailPromises = [];
-    // Augment the template with paths to resources and group information, if relevant
-    templates.forEach((t) => {
-      t.resourceFilePaths = this._getResourceFilePaths(solutionItemId, t, authentication.portal);
-      thumbnailPromises.push(t.resourceFilePaths.length > 0 ?
-        getThumbnailFromStorageItem(authentication, t.resourceFilePaths) :
-        Promise.resolve());
-      t.groupDetails = t.type === "Group" ? this._getItemsSharedWithThisGroup(t, templates) : [];
-    });
-    // Augment the template with its thumbnail file
-    const thumbnails = await Promise.all(thumbnailPromises);
-    templates.forEach((t, i) => {
-      t.thumbnail = thumbnails[i] ? thumbnails[i] : undefined;
-    });
-    return Promise.resolve();
-  }
-  /**
-   * Prepares template items for sending to AGO by updating the resources held by the solution item.
-   *
-   * @param solutionItemId Id of the solution represented in the store
-   * @param templates A list of item templates from the solution
-   * @param authentication Credentials for fetching information to be loaded into the store
-   *
-   * @returns a promise that resolves when the templates are ready
-   *
-   * @protected
-   */
-  async _prepareSolutionItemsForStorage(solutionItemId, templates, authentication) {
-    const resourceAdds = [];
-    // Update the resources and remove the augmentation from a template
-    const pendingTasks = [];
-    templates.forEach((t) => {
-      // Run through the resourceFilePaths for the item seeking modifications to be made to the solution item's
-      // collection of resources; queue them for batching
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      t.resourceFilePaths.forEach(async (path) => {
-        const storageName = this._getResourceStorageName(t.itemId, path);
-        switch (path.updateType) {
-          case EUpdateType.Add:
-            const { prefix, suffix } = this._splitFilename(storageName);
-            t.resources.push(storageName);
-            resourceAdds.push({
-              itemId: t.itemId,
-              file: path.blob,
-              folder: prefix,
-              filename: suffix
-            });
-            break;
-          case EUpdateType.Update:
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            pendingTasks.push(new Promise(async (resolve) => {
-              try {
-                await updateItemResourceFile(solutionItemId, storageName, path.blob, authentication);
-              }
-              catch (err) {
-                console.log("Unable to update " + storageName + " for item " + t.itemId + ": " + JSON.stringify(err));
-              }
-              resolve();
-            }));
-            break;
-          case EUpdateType.Remove:
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            pendingTasks.push(new Promise(async (resolve) => {
-              try {
-                await removeItemResourceFile(solutionItemId, storageName, authentication);
-                t.resources = t.resources.filter((path) => path !== storageName);
-              }
-              catch (err) {
-                console.log("Unable to remove " + storageName + " for item " + t.itemId + ": " + JSON.stringify(err));
-              }
-              resolve();
-            }));
-            break;
-        }
-        return Promise.resolve();
-      });
-      delete t.resourceFilePaths;
-      delete t.thumbnail;
-      delete t.groupDetails;
-    });
-    // Update the resources
-    return Promise.all(pendingTasks)
-      .then(async () => {
-      if (resourceAdds.length > 0) {
-        await copyFilesToStorageItem(resourceAdds, solutionItemId, authentication);
-      }
-      return Promise.resolve();
-    });
-  }
-  /**
-   * Stores basic spatial reference information that is used to determine if a custom spatial reference parameter will
-   * be exposed while deploying this solution and if so what feature services will support it and what will the default wkid be
-   *
-   * @param spatialReferenceInfo The configuration settings for a custom spatial reference
-   * @param templates The templates in the current solution, which will be updated in place if
-   * `spatialReferenceInfo.enabled` is true
-   *
-   * @returns The new default wkid
-   *
-   * @protected
-   */
-  _setSpatialReferenceInfo(spatialReferenceInfo, templates) {
-    const customizingPrefix = "{{params.wkid||";
-    const customizeableFeatureServices = this._getCustomizableFeatureServices(templates);
-    if (spatialReferenceInfo.enabled) {
-      // Enable or disable this feature in each service
-      customizeableFeatureServices.forEach((fs) => {
-        const name = fs.item.title || fs.item.name;
-        let wkid;
-        if (spatialReferenceInfo.services[name]) { // enabled
-          wkid = `{{params.wkid||${spatialReferenceInfo.spatialReference}}}`;
-          setCreateProp(fs, "properties.service.spatialReference.wkid", wkid);
-        }
-        else { // disabled
-          wkid = getProp(fs, "properties.service.spatialReference.wkid");
-          // Remove customizing prefix if present
-          if (wkid.toString().startsWith(customizingPrefix)) {
-            wkid = wkid.toString().substring(customizingPrefix.length, wkid.length - 2);
-            setCreateProp(fs, "properties.service.spatialReference.wkid", wkid);
-          }
-        }
-      });
-      return spatialReferenceInfo.spatialReference;
-    }
-    else {
-      // Disable this feature in each service
-      customizeableFeatureServices.forEach((fs) => {
-        const wkid = getProp(fs, "properties.service.spatialReference.wkid");
-        // Remove customizing prefix if present
-        if (wkid.toString().startsWith(customizingPrefix)) {
-          setCreateProp(fs, "properties.service.spatialReference.wkid", wkid.toString().substring(customizingPrefix.length, wkid.length - 2));
-        }
-      });
-      return undefined;
-    }
-  }
-  /**
-   * Splits a pathed filename into a last term and a prefix; e.g., "a/b/c" returns "c" with a prefix of "a/b".
-   *
-   * @param filename Filename with optional path
-   *
-   * @returns An object consisting of a `prefix` (undefined if `filename` does not contain a path) and a `suffix`--the
-   * filename at the end of a path
-   *
-   * @protected
-   */
-  _splitFilename(filename) {
-    const filenameParts = filename.split("/");
-    return {
-      prefix: filenameParts.length > 1 ? filenameParts.slice(0, filenameParts.length - 1).join("/") : undefined,
-      suffix: filenameParts[filenameParts.length - 1]
-    };
-  }
-}
-const state = SolutionStore.Store;
-
-export { EFileType as E, getProp as g, state as s };
+export { EFileType as E, SolutionTemplateFormatVersion as S, jszip_min as j };