@esri/hub-common 9.25.6 → 9.26.1

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.25.5 - Fri Apr 01 2022 14:27:54 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.26.0 - Wed Apr 06 2022 16:02:42 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -6731,6 +6731,33 @@
         }
         return result;
     };
+    /**
+     * @private
+     *
+     * Contains fallback logic for determining a content's extent.
+     *
+     * The fallback priority is as follows:
+     * 1) item's extent (if valid bbox)
+     * 2) extent enrichment from the hub api (if coordinates are valid bbox)
+     * 3) layer's extent (if spatial reference is 4326)
+     *
+     * If none of these conditions are met, undefined is returned.
+     *
+     * @param item
+     * @param layer
+     * @param extentEnrichment
+     * @returns the correct extent in a bbox format, or undefined
+     */
+    var determineExtent = function (item, extentEnrichment, layer) {
+        var itemExtent = isBBox(item.extent) ? item.extent : undefined;
+        var extentEnrichmentCoordinates = isBBox(extentEnrichment === null || extentEnrichment === void 0 ? void 0 : extentEnrichment.coordinates)
+            ? extentEnrichment.coordinates
+            : undefined;
+        var layerExtent = getProp(layer, "extent.spatialReference.wkid") === 4326
+            ? extentToBBox(layer.extent)
+            : undefined;
+        return itemExtent || extentEnrichmentCoordinates || layerExtent;
+    };
 
     var STANDARD_LICENSES = [
         {
@@ -7062,17 +7089,18 @@
         var layer = layers && layers.length === 1 ? layers[0] : undefined;
         return layer && layer.capabilities.includes("Query") ? layer : undefined;
     };
-    var shouldUseLayerInfo = function (layer, layers, url) {
-        return (layer &&
+    var shouldUseLayerInfo = function (item, layer, layers, requestOptions) {
+        return (!isProxiedCSV(item, requestOptions) &&
+            layer &&
             layers &&
             layers.length > 1 &&
             // we use item info instead of layer info for single layer items
-            !getLayerIdFromUrl(url));
+            !getLayerIdFromUrl(item.url));
     };
     // this logic adapted from hub-indexer's determineName(), see
     // https://github.com/ArcGIS/hub-indexer/blob/8f4dd6f928124c1f35dd02bc11bd996191ee1160/packages/duke/compose/common.js#L7-L34
-    var getContentName = function (item, layer, layers) {
-        return ((shouldUseLayerInfo(layer, layers, item.url)
+    var getContentName = function (item, layer, layers, requestOptions) {
+        return ((shouldUseLayerInfo(item, layer, layers, requestOptions)
             ? layer.name
             : item.title || item.name) || "").replace(/_/g, " ");
     };
@@ -7320,7 +7348,9 @@
     var getProxyUrl = function (item, requestOptions) {
         var result;
         if (isProxiedCSV(item, requestOptions)) {
-            result = getHubApiUrl(requestOptions) + "/datasets/" + item.id + "_0/FeatureServer/0";
+            // Sometimes hubApiUrl includes /api/v3, sometimes it doesn't
+            var baseUrl = getHubApiUrl(requestOptions).replace("/api/v3", "");
+            result = baseUrl + "/datasets/" + item.id + "_0/FeatureServer/0";
         }
         return result;
     };
@@ -7339,7 +7369,7 @@
      * @param {string} type - item's type
      * @returns {boolean}
      */
-    var isFeatureService = function (type) {
+    var isFeatureService$1 = function (type) {
         return type && type.toLowerCase() === "feature service";
     };
     /**
@@ -7387,7 +7417,7 @@
         // the Singlelayer typeKeyword, which I think is set when you create the item in AGO
         // but have not verified that, nor that we should alway return '0' in that case
         return (getLayerIdFromUrl(item.url) ||
-            (isFeatureService(item.type) &&
+            (isFeatureService$1(item.type) &&
                 item.typeKeywords &&
                 includes(item.typeKeywords, "Singlelayer") &&
                 "0"));
@@ -7449,7 +7479,7 @@
                 ? // find the explicitly set layer id
                     layers.find(function (_layer) { return _layer.id === _layerId; })
                 : // for feature servers with a single layer always show the layer
-                    isFeatureService(item.type) && getOnlyQueryLayer(layers)));
+                    isFeatureService$1(item.type) && getOnlyQueryLayer(layers)));
     };
     /**
      * determine if a layer is a layer view
@@ -7460,6 +7490,18 @@
     var isLayerView = function (layer) {
         return layer.isView;
     };
+    var determineHubId = function (item, layer, requestOptions) {
+        // Proxied CSVs are one offs in that we don't index the proxied layer,
+        // so we cannot append _0. Return item id instead.
+        if (isProxiedCSV(item, requestOptions)) {
+            return item.id;
+        }
+        return canUseHubApiForItem(item, requestOptions)
+            ? layer
+                ? item.id + "_" + layer.id
+                : getItemHubId(item)
+            : undefined;
+    };
     /**
      * Compose a new content object out of an item, enrichments, and context
      * @param item
@@ -7472,15 +7514,12 @@
         // set common variables that we will use in the derived properties below
         var layer = getItemLayer(item, layers, options === null || options === void 0 ? void 0 : options.layerId);
         // NOTE: we only set hubId for public items in online
-        var hubId = canUseHubApiForItem(item, requestOptions)
-            ? layer
-                ? item.id + "_" + layer.id
-                : getItemHubId(item)
-            : undefined;
+        var hubId = determineHubId(item, layer, requestOptions);
         var identifier = slug || hubId || item.id;
         // whether or not we should show layer info for name, description, etc
-        var name = getContentName(item, layer, layers);
-        var _layerDescription = shouldUseLayerInfo(layer, layers, item.url) && layer.description;
+        var name = getContentName(item, layer, layers, requestOptions);
+        var _layerDescription = shouldUseLayerInfo(item, layer, layers, requestOptions) &&
+            layer.description;
         // so much depends on type
         var type = layer
             ? // use layer type (Feature Layer, Table, etc) for layer content
@@ -7559,15 +7598,8 @@
                     control: item.itemControl || "view",
                 };
             },
-            // TODO: do we want to add dataset extent logic as a getter here?
             get extent() {
-                return !isBBox(item.extent) && extent && isBBox(extent.coordinates)
-                    ? // we fall back to the extent derived by the Hub API
-                        // which prefers layer or service extents and ultimately
-                        // falls back to the org's extent
-                        extent.coordinates
-                    : // prefer item extent
-                        item.extent;
+                return determineExtent(item, extent, layer);
             },
             // would require us to do client-side projection of server/layer extent
             get boundary() {
@@ -7744,7 +7776,7 @@
      * @returns slug without context
      */
     function removeContextFromSlug(slug, context) {
-        if (context && slug.match(context + "::")) {
+        if (context && slug.match("^" + context + "::")) {
             return slug.split(context + "::")[1];
         }
         else {
@@ -9095,6 +9127,10 @@
                 case 0: return [4 /*yield*/, getItem(itemId, options)];
                 case 1:
                     item = _a.sent();
+                    // The Hub Application expects the item url of proxied CSVs to point to the
+                    // proxying feature service. Stabbing it on here maintains that consistency
+                    // and also helps us fetch and calculate the correct reference layer
+                    item.url = getProxyUrl(item, options) || item.url;
                     enrichmentsToFetch = (options === null || options === void 0 ? void 0 : options.enrichments) || getContentEnrichments(item);
                     return [4 /*yield*/, fetchItemEnrichments(item, enrichmentsToFetch, options)];
                 case 2:
@@ -13239,6 +13275,1216 @@
         }
     }
 
+    /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    /**
+     * ENUM which defines File extensions.
+     */
+    exports.FileExtension = void 0;
+    (function (FileExtension) {
+        FileExtension["aptx"] = "aptx";
+        FileExtension["bpk"] = "bpk";
+        FileExtension["csv"] = "csv";
+        FileExtension["eaz"] = "eaz";
+        FileExtension["esriaddin"] = "esriaddin";
+        FileExtension["esriaddinx"] = "esriaddinx";
+        FileExtension["doc"] = "doc";
+        FileExtension["docx"] = "docx";
+        FileExtension["dlpk"] = "dlpk";
+        FileExtension["featurecollection"] = "featurecollection";
+        FileExtension["geojson"] = "geojson";
+        FileExtension["gcpk"] = "gcpk";
+        FileExtension["gpk"] = "gpk";
+        FileExtension["gpkg"] = "gpkg";
+        FileExtension["gpkx"] = "gpkx";
+        FileExtension["insightswbk"] = "insightswbk";
+        FileExtension["ipynb"] = "ipynb";
+        FileExtension["jpg"] = "jpg";
+        FileExtension["jpeg"] = "jpeg";
+        FileExtension["json"] = "json";
+        FileExtension["key"] = "key";
+        FileExtension["kml"] = "kml";
+        FileExtension["kmz"] = "kmz";
+        FileExtension["lpk"] = "lpk";
+        FileExtension["lpkx"] = "lpkx";
+        FileExtension["lyr"] = "lyr";
+        FileExtension["lyrx"] = "lyrx";
+        FileExtension["mapx"] = "mapx";
+        FileExtension["mmpk"] = "mmpk";
+        FileExtension["mpk"] = "mpk";
+        FileExtension["mpkx"] = "mpkx";
+        FileExtension["msd"] = "msd";
+        FileExtension["mspk"] = "mspk";
+        FileExtension["mxd"] = "mxd";
+        FileExtension["ncfg"] = "ncfg";
+        FileExtension["nmc"] = "nmc";
+        FileExtension["nmf"] = "nmf";
+        FileExtension["numbers"] = "numbers";
+        FileExtension["pages"] = "pages";
+        FileExtension["pagx"] = "pagx";
+        FileExtension["parquet"] = "parquet";
+        FileExtension["pdf"] = "pdf";
+        FileExtension["pmf"] = "pmf";
+        FileExtension["png"] = "png";
+        FileExtension["ppkx"] = "ppkx";
+        FileExtension["ppt"] = "ppt";
+        FileExtension["pptx"] = "pptx";
+        FileExtension["proconfigx"] = "proconfigx";
+        FileExtension["rpk"] = "rpk";
+        FileExtension["rptx"] = "rptx";
+        FileExtension["sd"] = "sd";
+        FileExtension["slpk"] = "slpk";
+        FileExtension["spk"] = "spk";
+        FileExtension["stylx"] = "stylx";
+        FileExtension["surveyaddin"] = "surveyaddin";
+        FileExtension["sxd"] = "sxd";
+        FileExtension["tif"] = "tif";
+        FileExtension["tiff"] = "tiff";
+        FileExtension["tpk"] = "tpk";
+        FileExtension["tpkx"] = "tpkx";
+        FileExtension["vsd"] = "vsd";
+        FileExtension["vtpk"] = "vtpk";
+        FileExtension["wmpk"] = "wmpk";
+        FileExtension["wpk"] = "wpk";
+        FileExtension["xls"] = "xls";
+        FileExtension["xml"] = "xml";
+        FileExtension["xlsx"] = "xlsx";
+        FileExtension["zip"] = "zip";
+        FileExtension["3dd"] = "3dd";
+        FileExtension["3vr"] = "3vr";
+        FileExtension["3ws"] = "3ws";
+        FileExtension["rft.json"] = "rft.json";
+        FileExtension["rft.xml"] = "rft.xml";
+    })(exports.FileExtension || (exports.FileExtension = {}));
+    /**
+     * ENUM which defines human readable Item Type names
+     */
+    exports.ItemType = void 0;
+    (function (ItemType) {
+        ItemType["360 VR Experience"] = "360 VR Experience";
+        ItemType["Apache Parquet"] = "Apache Parquet";
+        ItemType["AppBuilder Widget Package"] = "AppBuilder Widget Package";
+        ItemType["Desktop Add In"] = "Desktop Add In";
+        ItemType["Explorer Add In"] = "Explorer Add In";
+        ItemType["Explorer Map"] = "Explorer Map";
+        ItemType["Explorer Layer"] = "Explorer Layer";
+        ItemType["Windows Mobile Package"] = "Windows Mobile Package";
+        ItemType["ArcGIS Pro Add In"] = "ArcGIS Pro Add In";
+        ItemType["ArcGIS Pro Configuration"] = "ArcGIS Pro Configuration";
+        ItemType["Globe Document"] = "Globe Document";
+        ItemType["Map Document"] = "Map Document";
+        ItemType["ArcPad Package"] = "ArcPad Package";
+        ItemType["Published Map"] = "Published Map";
+        ItemType["Scene Document"] = "Scene Document";
+        ItemType["CityEngine Web Scene"] = "CityEngine Web Scene";
+        ItemType["Code Sample"] = "Code Sample";
+        ItemType["CSV Collection"] = "CSV Collection";
+        ItemType["CSV"] = "CSV";
+        ItemType["CAD Drawing"] = "CAD Drawing";
+        ItemType["Deep Learning Package"] = "Deep Learning Package";
+        ItemType["Desktop Application"] = "Desktop Application";
+        ItemType["Desktop Application Template"] = "Desktop Application Template";
+        ItemType["Desktop Style"] = "Desktop Style";
+        ItemType["Earth Configuration"] = "Earth Configuration";
+        ItemType["Feature Collection"] = "Feature Collection";
+        ItemType["File Geodatabase"] = "File Geodatabase";
+        ItemType["GeoJson"] = "GeoJson";
+        ItemType["Geoprocessing Package"] = "Geoprocessing Package";
+        ItemType["GeoPackage"] = "GeoPackage";
+        ItemType["Geoprocessing Sample"] = "Geoprocessing Sample";
+        ItemType["GML"] = "GML";
+        ItemType["Image Collection"] = "Image Collection";
+        ItemType["Image"] = "Image";
+        ItemType["iWork Keynote"] = "iWork Keynote";
+        ItemType["iWork Numbers"] = "iWork Numbers";
+        ItemType["iWork Pages"] = "iWork Pages";
+        ItemType["KML Collection"] = "KML Collection";
+        ItemType["KML"] = "KML";
+        ItemType["Layer"] = "Layer";
+        ItemType["Layer Package"] = "Layer Package";
+        ItemType["Layout"] = "Layout";
+        ItemType["Locator Package"] = "Locator Package";
+        ItemType["Map Package"] = "Map Package";
+        ItemType["Map Template"] = "Map Template";
+        ItemType["Microsoft Excel"] = "Microsoft Excel";
+        ItemType["Microsoft Powerpoint"] = "Microsoft Powerpoint";
+        ItemType["Visio Document"] = "Visio Document";
+        ItemType["Microsoft Word"] = "Microsoft Word";
+        ItemType["Mobile Basemap Package"] = "Mobile Basemap Package";
+        ItemType["Mobile Map Package"] = "Mobile Map Package";
+        ItemType["Mobile Scene Package"] = "Mobile Scene Package";
+        ItemType["Notebook"] = "Notebook";
+        ItemType["PDF"] = "PDF";
+        ItemType["Pro Map"] = "Pro Map";
+        ItemType["Pro Report"] = "Pro Report";
+        ItemType["Project Package"] = "Project Package";
+        ItemType["Project Template"] = "Project Template";
+        ItemType["Raster function template"] = "Raster function template";
+        ItemType["Rule Package"] = "Rule Package";
+        ItemType["Scene Package"] = "Scene Package";
+        ItemType["Service Definition"] = "Service Definition";
+        ItemType["Shapefile"] = "Shapefile";
+        ItemType["Survey123 Add In"] = "Survey123 Add In";
+        ItemType["Tile Package"] = "Tile Package";
+        ItemType["Vector Tile Package"] = "Vector Tile Package";
+        ItemType["Workflow Manager Package"] = "Workflow Manager Package";
+        ItemType["Document Link"] = "Document Link";
+        ItemType["Feature Service"] = "Feature Service";
+        ItemType["Geocoding Service"] = "Geocoding Service";
+        ItemType["Geodata Service"] = "Geodata Service";
+        ItemType["Geometry Service"] = "Geometry Service";
+        ItemType["Geoprocessing Service"] = "Geoprocessing Service";
+        ItemType["Geoenrichment Service"] = "Geoenrichment Service";
+        ItemType["Globe Service"] = "Globe Service";
+        ItemType["Image Service"] = "Image Service";
+        ItemType["Map Service"] = "Map Service";
+        ItemType["Network Analysis Service"] = "Network Analysis Service";
+        ItemType["Vector Tile Service"] = "Vector Tile Service";
+        ItemType["WFS"] = "WFS";
+        ItemType["WMS"] = "WMS";
+        ItemType["WMTS"] = "WMTS";
+        ItemType["OGCFeatureServer"] = "OGCFeatureServer";
+        ItemType["Scene Service"] = "Scene Service";
+        ItemType["Stream Service"] = "Stream Service";
+        ItemType["Workflow Manager Service"] = "Workflow Manager Service";
+        ItemType["Web Mapping Application"] = "Web Mapping Application";
+        ItemType["Mobile Application"] = "Mobile Application";
+        ItemType["AppBuilder Extension"] = "AppBuilder Extension";
+        ItemType["Google Drive"] = "Google Drive";
+        ItemType["Dropbox"] = "Dropbox";
+        ItemType["OneDrive"] = "OneDrive";
+        ItemType["StoryMap"] = "StoryMap";
+        ItemType["Dashboard"] = "Dashboard";
+        ItemType["Hub Initiative"] = "Hub Initiative";
+        ItemType["Hub Site Application"] = "Hub Site Application";
+        ItemType["Web Experience"] = "Web Experience";
+        ItemType["Insights Workbook Package"] = "Insights Workbook Package";
+        ItemType["Application"] = "Application";
+        ItemType["ArcGIS Explorer Application Configuration"] = "ArcGIS Explorer Application Configuration";
+        ItemType["ArcMap Document"] = "ArcMap Document";
+        ItemType["Layer File"] = "Layer File";
+        ItemType["ogcFeature"] = "ogcFeature";
+        ItemType["FeatureServer"] = "Feature Service";
+        ItemType["GeocodeServer"] = "GeocodeServer";
+        ItemType["GeoDataServer"] = "GeoDataServer";
+        ItemType["GeometryServer"] = "GeometryServer";
+        ItemType["GeoenrichmentServer"] = "GeoenrichmentServer";
+        ItemType["GPServer"] = "GPServer";
+        ItemType["GlobeServer"] = "GlobeServer";
+        ItemType["ImageServer"] = "ImageServer";
+        ItemType["MapServer"] = "MapServer";
+        ItemType["NAServer"] = "NAServer";
+        ItemType["ElevationServer"] = "ElevationServer";
+        ItemType["VectorTileServer"] = "VectorTileServer";
+        ItemType["Scene Server"] = "Scene Server";
+        ItemType["StreamServer"] = "StreamServer";
+        ItemType["WMServer"] = "WMServer";
+        ItemType["TiledImageServer"] = "TiledImageServer";
+    })(exports.ItemType || (exports.ItemType = {}));
+    /**
+     * Maps human readable file names to extensions IE Image === jpg, png, etc
+     */
+    var addCreateItemTypes = {
+        "360 VR Experience": {
+            fileExt: [exports.FileExtension["3dd"]],
+            type: exports.ItemType["360 VR Experience"],
+            typeKeywords: [],
+        },
+        "Apache Parquet": {
+            fileExt: [exports.FileExtension.parquet],
+            type: exports.ItemType["Apache Parquet"],
+            typeKeywords: [],
+        },
+        "AppBuilder Widget Package": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["AppBuilder Widget Package"],
+            typeKeywords: [],
+        },
+        "Desktop Add In": {
+            fileExt: [exports.FileExtension.esriaddin],
+            type: exports.ItemType["Desktop Add In"],
+            typeKeywords: [
+                "Tool",
+                "Add In",
+                "Desktop Add In",
+                "ArcGIS Desktop",
+                "ArcMap",
+                "ArcGlobe",
+                "ArcScene",
+                "esriaddin",
+            ],
+        },
+        "Explorer Add In": {
+            fileExt: [exports.FileExtension.eaz],
+            type: exports.ItemType["Explorer Add In"],
+            typeKeywords: [
+                "Tool",
+                "Add In",
+                "Explorer Add In",
+                "ArcGIS Explorer",
+                "eaz",
+            ],
+        },
+        "Explorer Map": {
+            fileExt: [exports.FileExtension.nmf],
+            type: exports.ItemType["Explorer Map"],
+            typeKeywords: [
+                "Map",
+                "Explorer Map",
+                "Explorer Document",
+                "2D",
+                "3D",
+                "ArcGIS Explorer",
+                "nmf",
+            ],
+        },
+        "ArcGIS Explorer Application Configuration": {
+            fileExt: [exports.FileExtension.ncfg],
+            type: exports.ItemType["Explorer Map"],
+            typeKeywords: [
+                "Map",
+                "Explorer Map",
+                "Explorer Mapping Application",
+                "2D",
+                "3D",
+                "ArcGIS Explorer",
+            ],
+        },
+        "Explorer Layer": {
+            fileExt: [exports.FileExtension.nmc],
+            type: exports.ItemType["Explorer Layer"],
+            typeKeywords: ["Data", "Layer", "Explorer Layer", "ArcGIS Explorer", "nmc"],
+        },
+        "Windows Mobile Package": {
+            fileExt: [exports.FileExtension.wmpk],
+            type: exports.ItemType["Windows Mobile Package"],
+            typeKeywords: [],
+        },
+        "ArcGIS Pro Add In": {
+            fileExt: [exports.FileExtension.esriaddinx],
+            type: exports.ItemType["ArcGIS Pro Add In"],
+            typeKeywords: ["Tool", "Add In", "Pro Add In", "esriaddinx"],
+        },
+        "ArcGIS Pro Configuration": {
+            fileExt: [exports.FileExtension.proconfigx],
+            type: exports.ItemType["ArcGIS Pro Configuration"],
+            typeKeywords: [],
+        },
+        "Globe Document": {
+            fileExt: [exports.FileExtension["3dd"]],
+            type: exports.ItemType["Globe Document"],
+            typeKeywords: [
+                "Map",
+                "Globe Document",
+                "3D",
+                "ArcGlobe",
+                "ArcGIS Server",
+                "3dd",
+            ],
+        },
+        "Map Document": {
+            fileExt: [exports.FileExtension.msd],
+            type: exports.ItemType["Map Document"],
+            typeKeywords: [
+                "Map Document",
+                "Map",
+                "2D",
+                "ArcMap",
+                "ArcGIS Server",
+                "msd",
+            ],
+        },
+        "ArcMap Document": {
+            fileExt: [exports.FileExtension.mxd],
+            type: exports.ItemType["Map Document"],
+            typeKeywords: ["Map Document", "Map", "2D", "ArcMap", "ArcGIS Server"],
+        },
+        "ArcPad Package": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["ArcPad Package"],
+            typeKeywords: ["Map", "Layer", "Data"],
+        },
+        "Published Map": {
+            fileExt: [exports.FileExtension.pmf],
+            type: exports.ItemType["Published Map"],
+            typeKeywords: [
+                "Map",
+                "Published Map",
+                "2D",
+                "ArcReader",
+                "ArcMap",
+                "ArcGIS Server",
+                "pmf",
+            ],
+        },
+        "Scene Document": {
+            fileExt: [exports.FileExtension.sxd],
+            type: exports.ItemType["Scene Document"],
+            typeKeywords: ["Map", "Scene Document", "3D", "ArcScene", "sxd"],
+        },
+        "CityEngine Web Scene": {
+            fileExt: [exports.FileExtension["3ws"]],
+            type: exports.ItemType["CityEngine Web Scene"],
+            typeKeywords: ["3D", "Map", "Scene", "Web"],
+        },
+        "Code Sample": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["Code Sample"],
+            typeKeywords: ["Code", "Sample"],
+        },
+        "CSV Collection": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["CSV Collection"],
+            typeKeywords: [],
+        },
+        CSV: {
+            fileExt: [exports.FileExtension.csv],
+            type: exports.ItemType.CSV,
+            typeKeywords: ["CSV"],
+        },
+        "CAD Drawing": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["CAD Drawing"],
+            typeKeywords: [],
+        },
+        "Deep Learning Package": {
+            fileExt: [exports.FileExtension.zip, exports.FileExtension.dlpk],
+            type: exports.ItemType["Deep Learning Package"],
+            typeKeywords: ["Deep Learning", "Raster"],
+        },
+        "Desktop Application": {
+            type: exports.ItemType["Desktop Application"],
+            typeKeywords: ["Desktop Application"],
+        },
+        "Desktop Application Template": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["Desktop Application Template"],
+            typeKeywords: ["application", "template", "ArcGIS desktop"],
+        },
+        "Desktop Style": {
+            fileExt: [exports.FileExtension.stylx],
+            type: exports.ItemType["Desktop Style"],
+            typeKeywords: ["ArcGIS Pro", "Symbology", "Style", "Symbols"],
+        },
+        "Earth Configuration": {
+            fileExt: [exports.FileExtension.xml],
+            type: exports.ItemType["Earth Configuration"],
+            typeKeywords: ["ArcGIS Earth", "Earth", "Earth Configuration"],
+        },
+        "Feature Collection": {
+            type: exports.ItemType["Feature Collection"],
+            fileExt: [exports.FileExtension.featurecollection],
+            typeKeywords: [],
+        },
+        "File Geodatabase": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["File Geodatabase"],
+            typeKeywords: [],
+        },
+        GeoJson: {
+            fileExt: [exports.FileExtension.geojson, exports.FileExtension.json],
+            type: exports.ItemType.GeoJson,
+            typeKeywords: [
+                "Coordinates Type",
+                "CRS",
+                "Feature",
+                "FeatureCollection",
+                "GeoJSON",
+                "Geometry",
+                "GeometryCollection",
+            ],
+        },
+        "Geoprocessing Package": {
+            fileExt: [exports.FileExtension.gpk, exports.FileExtension.gpkx],
+            type: exports.ItemType["Geoprocessing Package"],
+            typeKeywords: [
+                "ArcGIS Desktop",
+                "ArcGlobe",
+                "ArcMap",
+                "ArcScene",
+                "Geoprocessing Package",
+                "gpk",
+                "Model",
+                "Result",
+                "Script",
+                "Sharing",
+                "Tool",
+                "Toolbox",
+            ],
+        },
+        GeoPackage: {
+            fileExt: [exports.FileExtension.gpkg],
+            type: exports.ItemType.GeoPackage,
+            typeKeywords: ["Data", "GeoPackage", "gpkg"],
+        },
+        "Geoprocessing Sample": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["Geoprocessing Sample"],
+            typeKeywords: ["tool", "geoprocessing", "sample"],
+        },
+        GML: {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType.GML,
+            typeKeywords: [],
+        },
+        "Image Collection": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["Image Collection"],
+            typeKeywords: [],
+        },
+        Image: {
+            fileExt: [
+                exports.FileExtension.jpg,
+                exports.FileExtension.jpeg,
+                exports.FileExtension.png,
+                exports.FileExtension.tif,
+                exports.FileExtension.tiff,
+            ],
+            type: exports.ItemType.Image,
+            typeKeywords: ["Data", "Image"],
+        },
+        "iWork Keynote": {
+            fileExt: [exports.FileExtension.key],
+            type: exports.ItemType["iWork Keynote"],
+            typeKeywords: ["Data", "Document", "Mac"],
+        },
+        "iWork Numbers": {
+            fileExt: [exports.FileExtension.numbers],
+            type: exports.ItemType["iWork Numbers"],
+            typeKeywords: ["Data", "Document", "Mac"],
+        },
+        "iWork Pages": {
+            fileExt: [exports.FileExtension.pages],
+            type: exports.ItemType["iWork Pages"],
+            typeKeywords: ["Data", "Document", "Mac"],
+        },
+        "KML Collection": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["KML Collection"],
+            typeKeywords: [],
+        },
+        KML: {
+            type: exports.ItemType.KML,
+            fileExt: [exports.FileExtension.kml, exports.FileExtension.kmz],
+            typeKeywords: ["Data", "Map", "kml"],
+        },
+        Layer: {
+            fileExt: [exports.FileExtension.lyr],
+            type: exports.ItemType.Layer,
+            typeKeywords: [
+                "Data",
+                "Layer",
+                "ArcMap",
+                "ArcGlobe",
+                "ArcGIS Explorer",
+                "lyr",
+            ],
+        },
+        "Layer File": {
+            fileExt: [exports.FileExtension.lyrx],
+            type: exports.ItemType.Layer,
+            typeKeywords: ["ArcGIS Pro", "Layer", "Layer File"],
+        },
+        "Layer Package": {
+            fileExt: [exports.FileExtension.lpk, exports.FileExtension.lpkx],
+            type: exports.ItemType["Layer Package"],
+            typeKeywords: [],
+        },
+        Layout: {
+            fileExt: [exports.FileExtension.pagx],
+            type: exports.ItemType.Layout,
+            typeKeywords: ["ArcGIS Pro", "Layout", "Layout File", "pagx"],
+        },
+        "Locator Package": {
+            fileExt: [exports.FileExtension.gcpk],
+            type: exports.ItemType["Locator Package"],
+            typeKeywords: [],
+        },
+        "Map Package": {
+            fileExt: [exports.FileExtension.mpk, exports.FileExtension.mpkx],
+            type: exports.ItemType["Map Package"],
+            typeKeywords: [],
+        },
+        "Map Template": {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType["Map Template"],
+            typeKeywords: ["map", "ArcMap", "template", "ArcGIS desktop"],
+        },
+        "Microsoft Excel": {
+            fileExt: [exports.FileExtension.xls, exports.FileExtension.xlsx],
+            type: exports.ItemType["Microsoft Excel"],
+            typeKeywords: ["Data", "Document", "Microsoft Excel"],
+        },
+        "Microsoft Powerpoint": {
+            fileExt: [exports.FileExtension.ppt, exports.FileExtension.pptx],
+            type: exports.ItemType["Microsoft Powerpoint"],
+            typeKeywords: ["Data", "Document", "Microsoft Powerpoint"],
+        },
+        "Visio Document": {
+            fileExt: [exports.FileExtension.vsd],
+            type: exports.ItemType["Visio Document"],
+            typeKeywords: ["Data", "Document", "Visio Document"],
+        },
+        "Microsoft Word": {
+            fileExt: [exports.FileExtension.doc, exports.FileExtension.docx],
+            type: exports.ItemType["Microsoft Word"],
+            typeKeywords: ["Data", "Document"],
+        },
+        "Mobile Basemap Package": {
+            fileExt: [exports.FileExtension.bpk],
+            type: exports.ItemType["Mobile Basemap Package"],
+            typeKeywords: [],
+        },
+        "Mobile Map Package": {
+            fileExt: [exports.FileExtension.mmpk],
+            type: exports.ItemType["Mobile Map Package"],
+            typeKeywords: [],
+        },
+        "Mobile Scene Package": {
+            fileExt: [exports.FileExtension.mspk],
+            type: exports.ItemType["Mobile Scene Package"],
+            typeKeywords: [],
+        },
+        Notebook: {
+            fileExt: [exports.FileExtension.ipynb],
+            type: exports.ItemType.Notebook,
+            typeKeywords: ["Notebook", "Python"],
+        },
+        PDF: {
+            fileExt: [exports.FileExtension.pdf],
+            type: exports.ItemType.PDF,
+            typeKeywords: ["Data", "Document", "PDF"],
+        },
+        "Pro Map": {
+            fileExt: [exports.FileExtension.mapx],
+            type: exports.ItemType["Pro Map"],
+            typeKeywords: ["ArcGIS Pro", "Map", "Map File", "mapx"],
+        },
+        "Pro Report": {
+            fileExt: [exports.FileExtension.rptx],
+            type: exports.ItemType["Pro Report"],
+            typeKeywords: [],
+        },
+        "Project Package": {
+            fileExt: [exports.FileExtension.ppkx],
+            type: exports.ItemType["Project Package"],
+            typeKeywords: [],
+        },
+        "Project Template": {
+            fileExt: [exports.FileExtension.aptx],
+            type: exports.ItemType["Project Template"],
+            typeKeywords: [],
+        },
+        "Raster function template": {
+            fileExt: [exports.FileExtension["rft.json"], exports.FileExtension["rft.xml"]],
+            type: exports.ItemType["Raster function template"],
+            typeKeywords: [
+                "Raster",
+                "Functions",
+                "Processing",
+                "rft",
+                "srf",
+                "function template",
+                "templates",
+                "ArcGIS Pro",
+            ],
+        },
+        "Rule Package": {
+            fileExt: [exports.FileExtension.rpk],
+            type: exports.ItemType["Rule Package"],
+            typeKeywords: [],
+        },
+        "Scene Package": {
+            fileExt: [exports.FileExtension.slpk, exports.FileExtension.spk],
+            type: exports.ItemType["Scene Package"],
+            typeKeywords: [],
+        },
+        "Service Definition": {
+            fileExt: [exports.FileExtension.sd],
+            type: exports.ItemType["Service Definition"],
+            typeKeywords: ["Data", "Service", "Service Definition"],
+        },
+        Shapefile: {
+            fileExt: [exports.FileExtension.zip],
+            type: exports.ItemType.Shapefile,
+            typeKeywords: ["Data", "Layer", "shapefile"],
+        },
+        "Survey123 Add In": {
+            fileExt: [exports.FileExtension.surveyaddin],
+            type: exports.ItemType["Survey123 Add In"],
+            typeKeywords: ["Add In", "Survey123 Add In", "Tool"],
+        },
+        "Tile Package": {
+            fileExt: [exports.FileExtension.tpk, exports.FileExtension.tpkx],
+            type: exports.ItemType["Tile Package"],
+            typeKeywords: [],
+        },
+        "Vector Tile Package": {
+            fileExt: [exports.FileExtension.vtpk],
+            type: exports.ItemType["Vector Tile Package"],
+            typeKeywords: [],
+        },
+        "Workflow Manager Package": {
+            fileExt: [exports.FileExtension.wpk],
+            type: exports.ItemType["Workflow Manager Package"],
+            typeKeywords: [],
+        },
+        "Document Link": {
+            type: exports.ItemType["Document Link"],
+            typeKeywords: ["Data", "Document"],
+        },
+        "Feature Service": {
+            type: exports.ItemType["Feature Service"],
+            typeKeywords: [
+                "ArcGIS Server",
+                "Data",
+                "Feature Access",
+                "Feature Service",
+                "Service",
+                "Singlelayer",
+                "Hosted Service",
+            ],
+        },
+        GeocodeServer: {
+            type: exports.ItemType["Geocoding Service"],
+            typeKeywords: [
+                "ArcGIS Server",
+                "Geocoding Service",
+                "Locator Service",
+                "Service",
+                "Tool",
+                "Service Proxy",
+            ],
+        },
+        GeoDataServer: {
+            type: exports.ItemType["Geodata Service"],
+            typeKeywords: ["Data", "Service", "Geodata Service", "ArcGIS Server"],
+        },
+        GeometryServer: {
+            type: exports.ItemType["Geometry Service"],
+            typeKeywords: ["Tool", "Service", "Geometry Service", "ArcGIS Server"],
+        },
+        GeoenrichmentServer: {
+            type: exports.ItemType["Geoenrichment Service"],
+            typeKeywords: ["Geoenrichment Service", "ArcGIS Server"],
+        },
+        GPServer: {
+            type: exports.ItemType["Geoprocessing Service"],
+            typeKeywords: ["Tool", "Service", "Geoprocessing Service", "ArcGIS Server"],
+        },
+        GlobeServer: {
+            type: exports.ItemType["Globe Service"],
+            typeKeywords: ["Data", "Service", "Globe Service", "ArcGIS Server"],
+        },
+        ImageServer: {
+            type: exports.ItemType["Image Service"],
+            typeKeywords: ["Data", "Service", "Image Service", "ArcGIS Server"],
+        },
+        MapServer: {
+            type: exports.ItemType["Map Service"],
+            typeKeywords: ["Data", "Service", "Map Service", "ArcGIS Server"],
+        },
+        NAServer: {
+            type: exports.ItemType["Network Analysis Service"],
+            typeKeywords: [
+                "Tool",
+                "Service",
+                "Network Analysis Service",
+                "ArcGIS Server",
+            ],
+        },
+        ElevationServer: {
+            type: exports.ItemType["Image Service"],
+            typeKeywords: ["Elevation 3D Layer"],
+        },
+        VectorTileServer: {
+            type: exports.ItemType["Vector Tile Service"],
+            typeKeywords: [],
+        },
+        WFS: {
+            type: exports.ItemType.WFS,
+            typeKeywords: ["Data", "Service", "Web Feature Service", "OGC"],
+        },
+        WMS: {
+            type: exports.ItemType.WMS,
+            typeKeywords: ["Data", "Service", "Web Map Service", "OGC"],
+        },
+        WMTS: {
+            type: exports.ItemType.WMTS,
+            typeKeywords: ["Data", "Service", "OGC"],
+        },
+        ogcFeature: {
+            type: exports.ItemType.OGCFeatureServer,
+            typeKeywords: [
+                "Data",
+                "Service",
+                "Feature Service",
+                "OGC",
+                "OGC Feature Service",
+            ],
+        },
+        SceneServer: {
+            type: exports.ItemType["Scene Service"],
+            typeKeywords: ["Scene Service"],
+        },
+        StreamServer: {
+            type: exports.ItemType["Stream Service"],
+            typeKeywords: ["Data", "Service", "Stream Service", "ArcGIS Server"],
+        },
+        WMServer: {
+            type: exports.ItemType["Workflow Manager Service"],
+            typeKeywords: [
+                "Workflow Manager",
+                "ArcGIS Server",
+                "WMServer",
+                "Workflow",
+                "JTX",
+                "Job Tracking",
+            ],
+        },
+        TiledImageServer: {
+            type: exports.ItemType["Image Service"],
+            typeKeywords: ["Tiled Imagery"],
+        },
+        "Web Mapping Application": {
+            type: exports.ItemType["Web Mapping Application"],
+            typeKeywords: [
+                "JavaScript",
+                "Map",
+                "Mapping Site",
+                "Online Map",
+                "Ready To Use",
+                "Web AppBuilder",
+                "Web Map (+ WAB2D or WAB3D)",
+            ],
+        },
+        "Mobile Application": {
+            type: exports.ItemType["Mobile Application"],
+            typeKeywords: ["ArcGIS Mobile Map", "Mobile Application"],
+        },
+        "AppBuilder Extension": {
+            type: exports.ItemType["AppBuilder Extension"],
+            typeKeywords: ["Widget", "App Builder"],
+        },
+        "Google Drive": {
+            type: exports.ItemType["Google Drive"],
+            typeKeywords: ["CSV", "Shapefile", "GeoJSON", "Excel", "FileGeodatabase"],
+        },
+        Dropbox: {
+            type: exports.ItemType.Dropbox,
+            typeKeywords: ["CSV", "Shapefile", "GeoJSON", "Excel", "FileGeodatabase"],
+        },
+        OneDrive: {
+            type: exports.ItemType.OneDrive,
+            typeKeywords: ["CSV", "Shapefile", "GeoJSON", "Excel", "FileGeodatabase"],
+        },
+        "Map Service": {
+            type: exports.ItemType["Map Service"],
+            typeKeywords: [
+                "ArcGIS Server",
+                "Data",
+                "Map Service",
+                "Service",
+                "Hosted Service",
+            ],
+        },
+        StoryMap: {
+            type: exports.ItemType.StoryMap,
+            typeKeywords: [
+                "arcgis-storymaps",
+                "StoryMap",
+                "Web Application (smstatusdraft or smsstatuspublished)",
+            ],
+        },
+        Dashboard: {
+            type: exports.ItemType.Dashboard,
+            typeKeywords: ["Dashboard", "Operations Dashboard"],
+        },
+        "Hub Initiative": {
+            type: exports.ItemType["Hub Initiative"],
+            typeKeywords: ["Hub", "hubInitiative", "OpenData"],
+        },
+        "Hub Site Application": {
+            type: exports.ItemType["Hub Site Application"],
+            typeKeywords: [
+                "Hub",
+                "hubSite",
+                "hubSolution",
+                "JavaScript",
+                "Map",
+                "Mapping Site",
+                "Online Map",
+                "OpenData",
+                "Ready To Use",
+                "selfConfigured",
+                "Web Map",
+                "Registered App",
+            ],
+        },
+        "Web Experience": {
+            type: exports.ItemType["Web Experience"],
+            typeKeywords: [
+                "EXB Experience",
+                "JavaScript",
+                "Ready To Use Web Application",
+                "Web Experience",
+                "Web Mapping Application",
+                "Web Page",
+                "Web Site",
+            ],
+        },
+        "Insights Workbook Package": {
+            type: exports.ItemType["Insights Workbook Package"],
+            fileExt: [exports.FileExtension.insightswbk],
+            typeKeywords: ["Insights", "Insights Workbook Package"],
+        },
+    };
+
+    var FEATURE_SERVICE_URL_REGEX = /(feature)server(\/|\/(\d+))?$/i;
+    var SERVICE_URL_REGEX = /\/[a-zA-Z]+server(\/|\/(\d+))?$/i;
+    /**
+     * Feature service / Doc Links Should not have data urls. Let"s exclude them from that.
+     *
+     * @export
+     * @param {string} itemType What type of item is it?
+     * @return {*}  {boolean}
+     */
+    function shouldHaveDataUrl(itemType) {
+        // Specifically we want to avoid FS / DL from having a data url.
+        return !["Feature Service", "Document Link"].includes(itemType);
+    }
+    /**
+     * Get the file name out of a url. Will return either the
+     * hostname, or the pathname if it exists
+     *
+     * @export
+     * @param {string} url Url to get a file name out of
+     * @return {*}  {string}
+     */
+    function getFileName(url) {
+        var filename;
+        try {
+            var parsed = new URL(url);
+            // If the URL pathname exists, return its last segment,
+            // otherwise return the hostname
+            filename =
+                parsed.pathname !== "/"
+                    ? parsed.pathname.split("/").pop()
+                    : parsed.hostname;
+        }
+        catch (e) {
+            throw new Error("Error getting file name from data url");
+        }
+        return filename;
+    }
+    /**
+     * Is this a valid url?
+     *
+     * @param {string} url Url to validate
+     * @return {*}  {boolean}
+     */
+    function isUrl(url) {
+        // Use try / catch as a simple string "test" will cause new URL() to throw an error.
+        try {
+            var result = new URL(url);
+            // Cast to bool.
+            return !!result;
+        }
+        catch (e) {
+            Logger.error("Error parsing data url");
+            return false;
+        }
+    }
+    /**
+     * Tests if url string is a feature service / layer.
+     *
+     * @param {string} url URL to test
+     * @return {*}  {boolean}
+     */
+    function isFeatureService(url) {
+        return FEATURE_SERVICE_URL_REGEX.test(url);
+    }
+    /**
+     * Tests if url string is a service (map, feature, image, etc)
+     *
+     * @param {string} url Url to test
+     * @return {*}  {boolean}
+     */
+    function isService(url) {
+        return SERVICE_URL_REGEX.test(url);
+    }
+    /**
+     * Is the service a feature service AND is it a layer specifically
+     *
+     * @param {string} url
+     * @return {*}  {boolean}
+     */
+    function isFeatureLayer(url) {
+        var results = url.match(FEATURE_SERVICE_URL_REGEX);
+        return results && !!results[3];
+    }
+    /**
+     * Gets item title from url as a fall back
+     *
+     * @param {string} url item url
+     * @return {*}  {string}
+     */
+    function getFeatureServiceTitle(url) {
+        return url.match(/\/services\/(.+)\/(feature|map|image)server/i)[1];
+    }
+    /**
+     * Gets item info out of a feature layer item.
+     *
+     * @export
+     * @param {string} url Item URL
+     * @param {{
+     *     name: string,
+     *     description: string,
+     *     extent: any
+     *   }} body Item body.
+     * @return {*}  {{
+     *   title: string,
+     *   description: string,
+     *   extent: any,
+     *   url: string
+     * }}
+     */
+    function getFeatureLayerItem(url, body) {
+        return {
+            title: body.name,
+            description: body.description,
+            extent: body.extent,
+            url: url,
+        };
+    }
+    /**
+     * Gets item info out of a feature service response (which is not a specific layer)
+     *
+     * @export
+     * @param {*} url
+     * @param {*} body
+     * @return {*}
+     */
+    function getFeatureServiceItem(url, body) {
+        var description = body.serviceDescription || body.description;
+        var title = getFeatureServiceTitle(url);
+        var extent = body.fullExtent || body.initialExtent;
+        return { title: title, description: description, extent: extent, url: url };
+    }
+    /**
+     * Ping a non FS url and return response status && headers
+     *
+     * @export
+     * @param {string} url Non FS URL
+     * @return {*}  {Promise<{ ok: boolean, headers: Headers }>}
+     */
+    function pingUrl(url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fetch(url, { method: "HEAD" })];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, {
+                                ok: response.ok,
+                                headers: response.headers,
+                            }];
+                }
+            });
+        });
+    }
+    /**
+     * Ping a FS URL and handle matters such as "hidden" success failures.
+     *
+     * @export
+     * @param {string} url
+     * @return {*}  {Promise<{ ok: boolean, item?: any }>}
+     */
+    function pingFeatureService(url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var parsed, response, body, getItem, item;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        parsed = new URL(url);
+                        parsed.searchParams.set("f", "json");
+                        return [4 /*yield*/, fetch(parsed.href)];
+                    case 1:
+                        response = _a.sent();
+                        if (!response.ok) {
+                            return [2 /*return*/, { ok: false }];
+                        }
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        body = _a.sent();
+                        // Exit if the request returns an error
+                        if (body.error) {
+                            return [2 /*return*/, { ok: false }];
+                        }
+                        getItem = isFeatureLayer(url)
+                            ? getFeatureLayerItem
+                            : getFeatureServiceItem;
+                        item = getItem(url, body);
+                        return [2 /*return*/, {
+                                ok: true,
+                                item: item,
+                            }];
+                }
+            });
+        });
+    }
+    function detectDataTypeFromHeader(headers) {
+        var contentType = headers.get("Content-Type");
+        var dataType;
+        if (!contentType) {
+            return;
+        }
+        // Only get the "media-type"
+        contentType = contentType.split(";").shift();
+        if (contentType === "text/csv") {
+            dataType = exports.ItemType.CSV;
+        }
+        else if (contentType === "application/vnd.ms-excel" ||
+            contentType ===
+                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") {
+            dataType = exports.ItemType["Microsoft Excel"];
+        }
+        else if (contentType === "application/pdf") {
+            dataType = exports.ItemType.PDF;
+        }
+        else if (contentType === "image/jpeg" ||
+            contentType === "image/jpg" ||
+            contentType === "image/png") {
+            dataType = exports.ItemType.Image;
+        }
+        else if (contentType === "application/geo+json") {
+            dataType = exports.ItemType.GeoJson;
+        }
+        return dataType;
+    }
+    function detectDataTypeFromExtension(url) {
+        var contentType = url.toLowerCase().split(".").pop();
+        var dataType;
+        if (contentType === "csv") {
+            dataType = exports.ItemType.CSV;
+        }
+        else if (contentType === "xls" || contentType === "xlsx") {
+            dataType = exports.ItemType["Microsoft Excel"];
+        }
+        else if (contentType === "pdf") {
+            dataType = exports.ItemType.PDF;
+        }
+        else if (contentType === "jpeg" ||
+            contentType === "jpg" ||
+            contentType === "png") {
+            dataType = exports.ItemType.Image;
+        }
+        else if (contentType === "geojson") {
+            dataType = exports.ItemType.GeoJson;
+        }
+        return dataType;
+    }
+
+    /**
+     * Takes in a URL and validates it based on valid url, type of item, etc
+     *
+     * @export
+     * @param {string} url
+     * @return {*}  {Promise<any>}
+     */
+    function validateUrl(url) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isFeatureServiceUrl, isServiceUrl, type, item, pingResult, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // If URL doesn't pass then exit out immediately.
+                        if (!isUrl(url)) {
+                            return [2 /*return*/, {
+                                    pass: false,
+                                    error: "invalidFormat",
+                                }];
+                        }
+                        isFeatureServiceUrl = isFeatureService(url);
+                        isServiceUrl = isService(url);
+                        if (isServiceUrl && !isFeatureServiceUrl) {
+                            return [2 /*return*/, {
+                                    pass: false,
+                                    error: "invalidFormat",
+                                }];
+                        }
+                        pingResult = {};
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, , 7]);
+                        if (!isFeatureServiceUrl) return [3 /*break*/, 3];
+                        return [4 /*yield*/, pingFeatureService(url)];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, pingUrl(url)];
+                    case 4:
+                        _a = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        pingResult = _a;
+                        // return an error if the response is not okay
+                        if (!pingResult.ok) {
+                            return [2 /*return*/, {
+                                    pass: false,
+                                    error: "invalidUrl",
+                                }];
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        _b.sent();
+                        // TODO: This is tricky. The fetch() API rejects when a network error
+                        // happens. This error can be a CORS error, or a 404 error, or a timeout
+                        // error. While an error like 404 does suggest a bad URL, the CORS occurs
+                        // because this is a front-end request and the file is likely accessible by
+                        // the server. Unfortunately, the error doesn't have any information about
+                        // underline failure type. For now, the network failure is ignored, so the
+                        // user can paste a URL from any domain and avoid the CORS issue.
+                        Logger.error("error requesting url");
+                        return [3 /*break*/, 7];
+                    case 7:
+                        // Use the metadata from the ping response if exists, otherwise guess the file
+                        // name from the URL
+                        if (pingResult.item) {
+                            item = pingResult.item;
+                        }
+                        else {
+                            item = { title: getFileName(url), url: url };
+                        }
+                        if (pingResult.headers) {
+                            type = detectDataTypeFromHeader(pingResult.headers);
+                        }
+                        if (isFeatureServiceUrl) {
+                            type = exports.ItemType["Feature Service"];
+                        }
+                        else if (!type) {
+                            // Guess the data type from the extension
+                            type = detectDataTypeFromExtension(url);
+                        }
+                        if (type) {
+                            item.type = type;
+                        }
+                        if (item.type && shouldHaveDataUrl(item.type)) {
+                            item.dataUrl = item.url;
+                        }
+                        return [2 /*return*/, {
+                                pass: true,
+                                // The type may or may not be true
+                                type: type,
+                                // fetched / calculated item
+                                item: item,
+                            }];
+                }
+            });
+        });
+    }
+
     /**
      * Search the Hub API
      *
@@ -15605,6 +16851,7 @@
     exports._unprotectAndRemoveGroup = _unprotectAndRemoveGroup;
     exports._unprotectAndRemoveItem = _unprotectAndRemoveItem;
     exports.addContextToSlug = addContextToSlug;
+    exports.addCreateItemTypes = addCreateItemTypes;
     exports.addDays = addDays;
     exports.addDomain = addDomain;
     exports.addSiteDomains = addSiteDomains;
@@ -15763,7 +17010,7 @@
     exports.isDomainUsedElsewhere = isDomainUsedElsewhere;
     exports.isDownloadable = isDownloadable;
     exports.isExtentCoordinateArray = isExtentCoordinateArray;
-    exports.isFeatureService = isFeatureService;
+    exports.isFeatureService = isFeatureService$1;
     exports.isFieldworkerView = isFieldworkerView;
     exports.isGuid = isGuid;
     exports.isLayerView = isLayerView;
@@ -15837,6 +17084,7 @@
     exports.upgradeProtocol = upgradeProtocol;
     exports.upgradeSiteSchema = upgradeSiteSchema;
     exports.uploadResourcesFromUrl = uploadResourcesFromUrl;
+    exports.validateUrl = validateUrl;
     exports.valueToMatchOptions = valueToMatchOptions;
     exports.without = without;
     exports.withoutByProp = withoutByProp;