@esri/hub-common 9.29.0 → 9.31.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.28.0 - Thu Apr 21 2022 15:27:55 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.30.1 - Thu May 12 2022 14:13:55 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -3509,6 +3509,29 @@
         var url = getItemBaseUrl(id, requestOptions) + "/groups";
         return request(url, requestOptions);
     }
+    /**
+     * ```js
+     * import { getItemStatus } from "@esri/arcgis-rest-portal";
+     * //
+     * getItemStatus({
+     *   id: "30e5fe3149c34df1ba922e6f5bbf808f",
+     *   authentication
+     * })
+     *   .then(response)
+     * ```
+     * Inquire about status when publishing an item, adding an item in async mode, or adding with a multipart upload. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/status.htm) for more information.
+     *
+     * @param id - The Id of the item to get status for.
+     * @param requestOptions - Options for the request
+     * @returns A Promise to get the item status.
+     */
+    function getItemStatus(requestOptions) {
+        return determineOwner(requestOptions).then(function (owner) {
+            var url = getPortalUrl$1(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/status";
+            var options = appendCustomParams(requestOptions, ["jobId", "jobType"], { params: __assign({}, requestOptions.params) });
+            return request(url, options);
+        });
+    }
     /**
      * ```
      * import { getItemInfo } from "@esri/arcgis-rest-portal";
@@ -3611,6 +3634,27 @@
 
     /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
+    function getSharingUrl(requestOptions) {
+        var username = requestOptions.authentication.username;
+        var owner = requestOptions.owner || username;
+        return getPortalUrl$1(requestOptions) + "/content/users/" + encodeURIComponent(owner) + "/items/" + requestOptions.id + "/share";
+    }
+    function isItemOwner(requestOptions) {
+        var username = requestOptions.authentication.username;
+        var owner = requestOptions.owner || username;
+        return owner === username;
+    }
+    /**
+     * Check it the user is a full org_admin
+     * @param requestOptions
+     * @returns Promise resolving in a boolean indicating if the user is an ArcGIS Organization administrator
+     */
+    function isOrgAdmin(requestOptions) {
+        var session = requestOptions.authentication;
+        return session.getUser(requestOptions).then(function (user) {
+            return user && user.role === "org_admin" && !user.roleId;
+        });
+    }
     /**
      * Get the User Membership for a particular group. Use this if all you have is the groupId.
      * If you have the group object, check the `userMembership.memberType` property instead of calling this method.
@@ -4105,6 +4149,83 @@
         return genericSearch(search, "item");
     }
 
+    /* Copyright (c) 2017-2019 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * ```js
+     * import { addItemPart } from "@esri/arcgis-rest-portal";
+     * //
+     * addItemPart({
+     *   id: "30e5fe3149c34df1ba922e6f5bbf808f",
+     *   file: data,
+     *   partNum: 1,
+     *   authentication
+     * })
+     *   .then(response)
+     * ```
+     * Add Item Part allows the caller to upload a file part when doing an add or update item operation in multipart mode. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/add-item-part.htm) for more information.
+     *
+     * @param requestOptions - Options for the request
+     * @returns A Promise to add the item part status.
+     */
+    function addItemPart(requestOptions) {
+        var partNum = requestOptions.partNum;
+        if (!Number.isInteger(partNum) || partNum < 1 || partNum > 10000) {
+            return Promise.reject(new Error('The part number must be an integer between 1 to 10000, inclusive.'));
+        }
+        return determineOwner(requestOptions).then(function (owner) {
+            // AGO adds the "partNum" parameter in the query string, not in the body
+            var url = getPortalUrl$1(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/addPart?partNum=" + partNum;
+            var options = appendCustomParams(requestOptions, ["file"], { params: __assign({}, requestOptions.params) });
+            return request(url, options);
+        });
+    }
+    /**
+     * ```js
+     * import { commitItemUpload } from "@esri/arcgis-rest-portal";
+     * //
+     * commitItemUpload({
+     *   id: "30e5fe3149c34df1ba922e6f5bbf808f",
+     *   authentication
+     * })
+     *   .then(response)
+     * ```
+     * Commit is called once all parts are uploaded during a multipart Add Item or Update Item operation. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/commit.htm) for more information.
+     *
+     * @param requestOptions - Options for the request
+     * @returns A Promise to get the commit result.
+     */
+    function commitItemUpload(requestOptions) {
+        return determineOwner(requestOptions).then(function (owner) {
+            var url = getPortalUrl$1(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/commit";
+            var options = appendCustomParams(requestOptions, [], {
+                params: __assign(__assign({}, requestOptions.params), serializeItem(requestOptions.item))
+            });
+            return request(url, options);
+        });
+    }
+    /**
+     * ```js
+     * import { cancelItemUpload } from "@esri/arcgis-rest-portal";
+     * //
+     * cancelItemUpload({
+     *   id: "30e5fe3149c34df1ba922e6f5bbf808f",
+     *   authentication
+     * })
+     *   .then(response)
+     * ```
+     * Cancels a multipart upload on an item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/cancel.htm) for more information.
+     *
+     * @param requestOptions - Options for the request
+     * @returns A Promise to get the commit result.
+     */
+    function cancelItemUpload(requestOptions) {
+        return determineOwner(requestOptions).then(function (owner) {
+            var url = getPortalUrl$1(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.id + "/cancel";
+            return request(url, requestOptions);
+        });
+    }
+
     /* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     function chunk(array, size) {
@@ -4520,6 +4641,61 @@
         return genericSearch(search, "user");
     }
 
+    /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * ```js
+     * import { setItemAccess } from "@esri/arcgis-rest-portal";
+     * //
+     * setItemAccess({
+     *   id: "abc123",
+     *   access: "public", // 'org' || 'private'
+     *   authentication: session
+     * })
+     * ```
+     * Change who is able to access an item.
+     *
+     * @param requestOptions - Options for the request.
+     * @returns A Promise that will resolve with the data from the response.
+     */
+    function setItemAccess(requestOptions) {
+        var url = getSharingUrl(requestOptions);
+        if (isItemOwner(requestOptions)) {
+            // if the user owns the item, proceed
+            return updateItemAccess(url, requestOptions);
+        }
+        else {
+            // otherwise we need to check to see if they are an organization admin
+            return isOrgAdmin(requestOptions).then(function (admin) {
+                if (admin) {
+                    return updateItemAccess(url, requestOptions);
+                }
+                else {
+                    // if neither, updating the sharing isnt possible
+                    throw Error("This item can not be shared by " + requestOptions.authentication.username + ". They are neither the item owner nor an organization admin.");
+                }
+            });
+        }
+    }
+    function updateItemAccess(url, requestOptions) {
+        requestOptions.params = __assign({ org: false, everyone: false }, requestOptions.params);
+        // if the user wants to make the item private, it needs to be unshared from any/all groups as well
+        if (requestOptions.access === "private") {
+            requestOptions.params.groups = " ";
+        }
+        if (requestOptions.access === "org") {
+            requestOptions.params.org = true;
+        }
+        // if sharing with everyone, share with the entire organization as well.
+        if (requestOptions.access === "public") {
+            // this is how the ArcGIS Online Home app sets public access
+            // setting org = true instead of account = true will cancel out all sharing
+            requestOptions.params.account = true;
+            requestOptions.params.everyone = true;
+        }
+        return request(url, requestOptions);
+    }
+
     /**
      * ```js
      * import { isItemSharedWithGroup } from "@esri/arcgis-rest-portal";
@@ -6371,7 +6547,7 @@
         var family;
         // override default behavior for the rows that are highlighted in yellow here:
         // https://esriis.sharepoint.com/:x:/r/sites/ArcGISHub/_layouts/15/Doc.aspx?sourcedoc=%7BADA1C9DC-4F6C-4DE4-92C6-693EF9571CFA%7D&file=Hub%20Routes.xlsx&nav=MTBfe0VENEREQzI4LUZFMDctNEI0Ri04NjcyLThCQUE2MTA0MEZGRn1fezIwMTIwMEJFLTA4MEQtNEExRC05QzA4LTE5MTAzOUQwMEE1RH0&action=default&mobileredirect=true&cid=df1c874b-c367-4cea-bc13-7bebfad3f2ac
-        switch ((type || "").toLowerCase()) {
+        switch (type.toLowerCase()) {
             case "image service":
                 family = "dataset";
                 break;
@@ -6522,6 +6698,8 @@
                 // deployed solutions go to the generic content route
                 hubUrl = "/content/" + identifier;
             }
+            // TODO: I think this is a bug. The line below should be w/in else
+            // in order to avoid overwriting the above for deployed solutions, right?
             // others go to the solution about route
             hubUrl = "/templates/" + identifier + "/about";
         }
@@ -7200,7 +7378,7 @@
      */
     var getContentTypeIcon = function (contentType) {
         var _a;
-        var type = camelize(contentType || "");
+        var type = camelize(contentType);
         var iconMap = {
             appbuilderExtension: "file",
             appbuilderWidgetPackage: "widgets-source",
@@ -8794,7 +8972,7 @@
     var enrichServer = function (input) {
         var data = input.data, stack = input.stack, requestOptions = input.requestOptions;
         var opId = stack.start("enrichServer");
-        var url = data.item.url;
+        var url = parseServiceUrl(data.item.url);
         var options = __assign(__assign({}, requestOptions), { url: url });
         return getService(options)
             .then(function (server) {
@@ -9603,11 +9781,12 @@
         return isProxied ? "CSV" : camelize(contentType || "");
     };
     /**
-     * returns a new content that has the specified hubId and updated identifier
+     * DEPRECATED returns a new content that has the specified hubId and updated identifier
      * @param content orignal content
      * @param hubId new hubId
      * @returns new content
      */
+    /* istanbul ignore next DEPRECATED and no longer in use */
     var setContentHubId = function (content, hubId) {
         var id = content.id, slug = content.slug;
         // get the identifier which is based on hubId
@@ -9620,7 +9799,7 @@
         });
     };
     /**
-     * Calculates the relative and absolute urls for a given content on a specific site
+     * DEPRECATED: Calculates the relative and absolute urls for a given content on a specific site
      *
      * @param content
      * @param siteModel
@@ -9665,6 +9844,10 @@
      * instead of throwing INVALID_CHARACTER_ERR we return null.
      */
     function atob(data) {
+      if (arguments.length === 0) {
+        throw new TypeError("1 argument required, but only 0 present.");
+      }
+
       // Web IDL requires DOMStrings to just be converted using ECMAScript
       // ToString, which in our case amounts to using a template literal.
       data = `${data}`;
@@ -9761,6 +9944,10 @@
      * RFC 4648.
      */
     function btoa(s) {
+      if (arguments.length === 0) {
+        throw new TypeError("1 argument required, but only 0 present.");
+      }
+
       let i;
       // String conversion as required by Web IDL.
       s = `${s}`;
@@ -11592,6 +11779,216 @@
         return request(url, options);
     }
 
+    /**
+     * Takes a file, file owner, and file AGO item id along with a size limit
+     * Then chunks the file up based on that file limit.
+     * The chunks are added to addItemPart calls and added to a queue array.
+     *
+     * @export
+     * @param {*} file File to be uploaded
+     * @param {string} owner file owner
+     * @param {string} id file ID from AGO
+     * @param {number} sizeLimit How large should the chunks be?
+     * @param {IUserRequestOptions} requestOptions
+     * @return {*}  {IBatch}
+     */
+    function _prepareUploadRequests(file, owner, id, sizeLimit, requestOptions) {
+        var queue = [];
+        // part number starts from 1
+        var partIndex = 1;
+        var sizeIndex = 0;
+        // Slice the file data and create an upload request for each part
+        while (sizeIndex < file.size) {
+            queue.push(__assign({ file: file.slice(sizeIndex, sizeIndex + sizeLimit, file.type), owner: owner,
+                id: id, partNum: partIndex }, requestOptions));
+            partIndex += 1;
+            sizeIndex += sizeLimit;
+        }
+        return queue.reverse();
+    }
+
+    /**
+     * Creates an item in online from a local file/item.
+     * Upload is multithreaded as the item is chunked up.
+     *
+     * @export
+     * @param {IItemAdd} item Item to be uploaded into online.
+     * @param {IUserRequestOptions} requestOptions
+     * @return {*}  {Promise<string>} Newly created item id
+     */
+    function createItemFromFile(item, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var file, createResult, itemId, sizeLimit, uploadQueue, e_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        file = cloneObject$1(item.file);
+                        //  and remove the file object so
+                        // that it won't trigger the direct upload at the createContent request
+                        delete item.file;
+                        return [4 /*yield*/, createItem(__assign({ item: item, filename: file.name, async: true, multipart: true, overwrite: true }, requestOptions))];
+                    case 1:
+                        createResult = _a.sent();
+                        itemId = createResult.id;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 7]);
+                        sizeLimit = 6 * 1000 * 1000;
+                        uploadQueue = _prepareUploadRequests(file, item.owner, itemId, sizeLimit, requestOptions);
+                        // execute up to 5 concurrent requests
+                        return [4 /*yield*/, batch(uploadQueue, 
+                            // We are doing this to catch individual response failures
+                            // and throwing them to stop further xhr's
+                            function (opts) { return __awaiter(_this, void 0, void 0, function () {
+                                var resp;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, addItemPart(opts)];
+                                        case 1:
+                                            resp = _a.sent();
+                                            // If the response did not return with success then throw an error
+                                            if (!resp.success) {
+                                                throw new Error("addItemPart failed");
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }, 5)];
+                    case 3:
+                        // execute up to 5 concurrent requests
+                        _a.sent();
+                        // Commit is called once all parts are uploaded during a multipart add item or update item operation.
+                        return [4 /*yield*/, commitItemUpload(__assign({ id: itemId, item: item, owner: item.owner }, requestOptions))];
+                    case 4:
+                        // Commit is called once all parts are uploaded during a multipart add item or update item operation.
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        e_1 = _a.sent();
+                        // If an error is thrown then cancel item upload
+                        return [4 /*yield*/, cancelItemUpload(__assign({ id: itemId, owner: item.owner }, requestOptions))];
+                    case 6:
+                        // If an error is thrown then cancel item upload
+                        _a.sent();
+                        throw e_1;
+                    case 7: return [2 /*return*/, createResult];
+                }
+            });
+        });
+    }
+
+    /**
+     * Create AGO item from a URL
+     *
+     * @export
+     * @param {IItemAdd} item Item to be uploaded into online.
+     * @param {IUserRequestOptions} requestOptions
+     * @return {*}  {Promise<string>} Newly created item ID
+     */
+    function createItemFromUrl(item, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var createResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, createItem(__assign({ item: item, owner: item.owner, file: item.file, dataUrl: item.dataUrl, text: item.text, multipart: item.multipart, async: item.async }, requestOptions))];
+                    case 1:
+                        createResult = _a.sent();
+                        // return the newly created item id
+                        return [2 /*return*/, createResult];
+                }
+            });
+        });
+    }
+
+    function delay(milliseconds) {
+        return new Promise(function (resolve) { return setTimeout(resolve, milliseconds); });
+    }
+    /**
+     * Helper function which takes an itemId and checks the status
+     * of the item every 2 seconds until it is either complete or failed.
+     *
+     * @export
+     * @param {string} itemId AGO item id
+     * @param {IUserRequestOptions} requestOptions
+     */
+    function _waitForItemReady(itemId, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var statusResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, delay(2000)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, getItemStatus(__assign({ id: itemId }, requestOptions))];
+                    case 2:
+                        statusResult = _a.sent();
+                        if (statusResult.status === "failed") {
+                            throw new Error(statusResult.statusMessage);
+                        }
+                        _a.label = 3;
+                    case 3:
+                        if (statusResult.status !== "completed") return [3 /*break*/, 0];
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+
+    /**
+     * Creates an item in online from either url or file.
+     * Once created we wait for the item to be ready (or throw an error if creation failed)
+     * If access is not private then we make a call to update that.
+     *
+     * @export
+     * @param {ICreateItemFromUrlOrFileOptions} createItemFromUrlOrFileOptions Input params (item, groups?, requestoptions)
+     * @return {*}  {Promise<string>} AGO item id
+     */
+    function createItemFromUrlOrFile(createItemFromUrlOrFileOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var item, groups, userRequestOptions, shouldWaitForItemReady, createdItem, failSafeShare_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        item = createItemFromUrlOrFileOptions.item, groups = createItemFromUrlOrFileOptions.groups, userRequestOptions = __rest(createItemFromUrlOrFileOptions, ["item", "groups"]);
+                        shouldWaitForItemReady = item.dataUrl || item.file;
+                        if (!item.file) return [3 /*break*/, 2];
+                        return [4 /*yield*/, createItemFromFile(item, userRequestOptions)];
+                    case 1:
+                        createdItem = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, createItemFromUrl(item, userRequestOptions)];
+                    case 3:
+                        createdItem = _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        if (!shouldWaitForItemReady) return [3 /*break*/, 6];
+                        return [4 /*yield*/, _waitForItemReady(createdItem.id, userRequestOptions)];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        if (!(item.access !== "private")) return [3 /*break*/, 8];
+                        return [4 /*yield*/, setItemAccess(__assign({ id: createdItem.id, owner: item.owner, access: item.access }, userRequestOptions))];
+                    case 7:
+                        _a.sent();
+                        _a.label = 8;
+                    case 8:
+                        if (!(groups === null || groups === void 0 ? void 0 : groups.length)) return [3 /*break*/, 10];
+                        failSafeShare_1 = failSafe(shareItemWithGroup);
+                        return [4 /*yield*/, Promise.all(groups.map(function (group) {
+                                return failSafeShare_1(__assign({ id: createdItem.id, owner: item.owner, groupId: group.id, confirmItemControl: isUpdateGroup(group) }, userRequestOptions));
+                            }))];
+                    case 9:
+                        _a.sent();
+                        _a.label = 10;
+                    case 10: return [2 /*return*/, createdItem];
+                }
+            });
+        });
+    }
+
     /* Copyright (c) 2018-2021 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     /**
@@ -17134,6 +17531,9 @@
     exports.convertUrlsToAnchorTags = convertUrlsToAnchorTags;
     exports.createExtent = createExtent;
     exports.createId = createId;
+    exports.createItemFromFile = createItemFromFile;
+    exports.createItemFromUrl = createItemFromUrl;
+    exports.createItemFromUrlOrFile = createItemFromUrlOrFile;
     exports.createModel = createModel;
     exports.createOperationPipeline = createOperationPipeline;
     exports.createProject = createProject;