@esri/hub-common 9.42.0 → 9.43.2

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.41.1 - Tue Jun 14 2022 18:27:39 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.43.1 - Wed Jun 22 2022 18:24:40 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -10340,7 +10340,8 @@
         var opts = cloneObject$1(requestOptions);
         opts.params = __assign(__assign({}, opts.params), { 
             // TODO: we should fetch errors too
-            "fields[datasets]": "slug,boundary,extent,searchDescription,statistics" });
+            // TODO: stop fetching recordCount at next breaking change
+            "fields[datasets]": "slug,boundary,extent,recordCount,searchDescription,statistics" });
         if (slug) {
             opts.params["filter[slug]"] = slug;
         }
@@ -10350,13 +10351,14 @@
     var getDatasetEnrichments = function (dataset) {
         var _a = parseDatasetId(dataset.id), itemId = _a.itemId, layerIdString = _a.layerId;
         var layerId = layerIdString && parseInt(layerIdString, 10);
-        var _b = dataset.attributes, slug = _b.slug, boundary = _b.boundary, extent = _b.extent, searchDescription = _b.searchDescription, statistics = _b.statistics;
+        var _b = dataset.attributes, slug = _b.slug, boundary = _b.boundary, extent = _b.extent, recordCount = _b.recordCount, searchDescription = _b.searchDescription, statistics = _b.statistics;
         return {
             itemId: itemId,
             layerId: layerId,
             slug: slug,
             boundary: boundary,
             extent: extent,
+            recordCount: recordCount,
             searchDescription: searchDescription,
             statistics: statistics,
         };
@@ -10577,7 +10579,7 @@
      * ```
      */
     var fetchContent = function (identifier, options) { return __awaiter(void 0, void 0, void 0, function () {
-        var content, _a, layer, type, _b, _c;
+        var content, _a, layer, type, canQuery, _b, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -10593,14 +10595,15 @@
                 case 4:
                     content = _a;
                     layer = content.layer, type = content.type;
+                    canQuery = !!layer && hasFeatures(type);
                     _b = content;
-                    if (!(!!layer && hasFeatures(type))) return [3 /*break*/, 6];
+                    if (!(canQuery && (isNil(content.recordCount) || content.viewDefinition))) return [3 /*break*/, 6];
                     return [4 /*yield*/, fetchContentRecordCount(content, options)];
                 case 5:
                     _c = _d.sent();
                     return [3 /*break*/, 7];
                 case 6:
-                    _c = undefined;
+                    _c = content.recordCount;
                     _d.label = 7;
                 case 7:
                     _b.recordCount = _c;
@@ -11821,18 +11824,9 @@
      * 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
-     * }}
+     * @param url Item URL
+     * @param body Item body.
+     * @return Item info (title, description, extent, url)
      */
     function getFeatureLayerItem(url, body) {
         return {
@@ -14044,7 +14038,7 @@
                     if (isWellKnownType(entry)) {
                         // working with dynamic objects in typescript requires some assertions
                         var key = entry;
-                        clone.subFilters = clone.subFilters.concat(lookupTypeFilters(key));
+                        clone.subFilters = clone.subFilters.concat(lookupTypeFilters$1(key));
                     }
                     else {
                         acc.push(entry);
@@ -14054,7 +14048,7 @@
             }
             else if (isWellKnownType(clone.type)) {
                 var key = clone.type;
-                clone.subFilters = clone.subFilters.concat(lookupTypeFilters(key));
+                clone.subFilters = clone.subFilters.concat(lookupTypeFilters$1(key));
                 delete clone.type;
             }
             else ;
@@ -14077,7 +14071,7 @@
         }
         return result;
     }
-    function lookupTypeFilters(key) {
+    function lookupTypeFilters$1(key) {
         return ContentFilterExpansions[key];
     }
     /**
@@ -14673,6 +14667,8 @@
      *
      * **Note** Authentication is required
      *
+     * Another trivial comment to force a release
+     *
      * Note: in the future, there may be options to search via
      * a Hub specific API
      * @param filter
@@ -15166,6 +15162,36 @@
         }
         return q;
     }
+    /**
+     * Determine if a Filter is "empty"
+     * @param filter
+     * @returns
+     */
+    function isEmptyFilter(filter) {
+        // if it has one property, filterType, it's empty
+        return (Object.keys(filter).length === 1 && filter.hasOwnProperty("filterType"));
+    }
+    /**
+     * Determine if a filterGroup is "empty"
+     * @param filterGroup
+     * @returns
+     */
+    function isEmptyFilterGroup(filterGroup) {
+        // if filters array is empty
+        if (filterGroup.filters.length === 0) {
+            return true;
+        }
+        else {
+            // if all filters are empty
+            var result = filterGroup.filters.reduce(function (acc, entry) {
+                if (acc) {
+                    acc = isEmptyFilter(entry);
+                }
+                return acc;
+            }, true);
+            return result;
+        }
+    }
 
     /**
      * Generic Hub Error with an Error stack as well
@@ -17826,12 +17852,13 @@
     function portalSearchItems(filterGroups, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var expandedGroups, so, props;
+            var replaced, expandedGroups, so, props;
             return __generator(this, function (_b) {
                 if (!options.requestOptions) {
                     throw new HubError$1("hubSearch", "requestOptions: IHubRequestOptions is required.");
                 }
-                expandedGroups = filterGroups.map(function (fg) {
+                replaced = applyWellKnownItemFilters(filterGroups);
+                expandedGroups = replaced.map(function (fg) {
                     fg.filters = fg.filters.map(expandFilter);
                     return fg;
                 });
@@ -17930,6 +17957,233 @@
             });
         });
     }
+    var WellKnownItemFilters = {
+        $application: [
+            {
+                filterType: "item",
+                type: {
+                    any: [
+                        "Web Mapping Application",
+                        "Application",
+                        "Insights",
+                        "Web Experience",
+                    ],
+                    not: ["Insights Theme", "Insights Model"],
+                },
+                typekeywords: {
+                    not: ["hubSite", "Story Map"],
+                },
+            },
+            {
+                filterType: "item",
+                type: "Web Mapping Experience",
+                typekeywords: "EXB Experience",
+            },
+        ],
+        $dashboard: [
+            {
+                filterType: "item",
+                type: {
+                    any: ["Dashboard"],
+                    not: ["Operation View"],
+                },
+                typekeywords: {
+                    not: ["Extension", "ArcGIS Operation View"],
+                },
+            },
+        ],
+        $dataset: [
+            {
+                filterType: "item",
+                type: {
+                    any: [
+                        "Scene Service",
+                        "Feature Collection",
+                        "Route Layer",
+                        "Layer",
+                        "Explorer Layer",
+                        "Tile Package",
+                        "Vector Tile Package",
+                        "Scene Package",
+                        "Layer Package",
+                        "Feature Service",
+                        "Stream Service",
+                        "Map Service",
+                        "Vector Tile Service",
+                        "Image Service",
+                        "WMS",
+                        "WFS",
+                        "WMTS",
+                        "KML",
+                        "KML Collection",
+                        "Globe Service",
+                        "CSV",
+                        "Shapefile",
+                        "GeoJson",
+                        "Service Definition",
+                        "File Geodatabase",
+                        "CAD Drawing",
+                        "Relational Database Connection",
+                    ],
+                    not: ["Web Mapping Application", "Geodata Service"],
+                },
+            },
+            {
+                filterType: "item",
+                typekeywords: ["OGC", "Geodata Service"],
+            },
+        ],
+        $document: [
+            {
+                filterType: "item",
+                type: [
+                    "PDF",
+                    "Microsoft Excel",
+                    "Microsoft Word",
+                    "Microsoft Powerpoint",
+                    "iWork Keynote",
+                    "iWork Pages",
+                    "iWork Numbers",
+                    "Visio Document",
+                    "Document Link",
+                ],
+            },
+        ],
+        $initiative: [
+            {
+                filterType: "item",
+                type: "Hub Initiative",
+            },
+        ],
+        $experience: [
+            {
+                filterType: "item",
+                type: "Web Experience",
+            },
+        ],
+        $feedback: [
+            {
+                filterType: "item",
+                type: "Form",
+            },
+        ],
+        $page: [
+            {
+                filterType: "item",
+                typekeywords: "hubPage",
+            },
+        ],
+        $site: [
+            {
+                filterType: "item",
+                type: ["Hub Site Application", "Site Application"],
+            },
+        ],
+        $storymap: [
+            {
+                filterType: "item",
+                type: "Storymap",
+            },
+            {
+                filterType: "item",
+                type: "Web Mapping Application",
+                typekeywords: "Story Map",
+            },
+        ],
+        $template: [
+            {
+                filterType: "item",
+                type: [
+                    "Web Mapping Application",
+                    "Hub Initiative",
+                    "Hub Initiative Template",
+                    "Solution",
+                ],
+                typekeywords: {
+                    any: ["hubInitiativeTemplate", "hubSolutionTemplate", "Template"],
+                    not: "Deployed",
+                },
+            },
+        ],
+        $webmap: [
+            {
+                filterType: "item",
+                type: {
+                    any: ["Web Map", "Web Scene"],
+                    not: "Web Mapping Application",
+                },
+            },
+        ],
+    };
+    /**
+     * @private
+     * Convert a Filter Group to expand well-known type filters
+     *
+     * The purpose of this function is to allow for the use of short-hand
+     * names for commonly used, complex queries.
+     *
+     * It works by looking for filters using the .type property, the value
+     * of which is a key in the WellKnownItemFilters hash. If found in the
+     * hash, the filters array of the active filterGroup is replaced with the
+     * filters specified in the hash.
+     *
+     * NOTE: Any other properties specified in a filter will be removed
+     *
+     * Only exported to enable extensive testing
+     * @param filterGroups
+     */
+    function applyWellKnownItemFilters(filterGroups) {
+        var clone = cloneObject$1(filterGroups);
+        // iterate the filterGroups
+        var result = clone.map(function (filterGroup) {
+            filterGroup.filters = filterGroup.filters.reduce(function (updated, filter) {
+                // check if the filter.type is a well-known type
+                if (isWellKnownTypeFilter(filter.type)) {
+                    // get the set of filters to replace the current filter with
+                    var typeFilters = lookupTypeFilters(filter.type);
+                    // Note: At this point we could try to "merge" in the other
+                    // props on the filter, into all the filters returned from
+                    // the well-known hash. The problem with this is that the
+                    // combination may yield unexpected results; For now, if a filter
+                    // includes `.type is keyof WellKnownItemFilters` we simply
+                    // replace the entire filter with the array of filters returne
+                    // from the hash
+                    updated = __spreadArrays(updated, typeFilters);
+                }
+                else {
+                    // filter does not have a well-known type entry so keep it
+                    updated.push(filter);
+                }
+                return updated;
+            }, []);
+            return filterGroup;
+        });
+        return result;
+    }
+    /**
+     * Is the argument a well-known type "key"
+     *
+     * Accepts `string`, `string[]` or `IMatchOptions`
+     * but only string values can possibly be keys
+     * on `WellKnownItemFilters`
+     * @param key
+     * @returns
+     */
+    function isWellKnownTypeFilter(key) {
+        var result = false;
+        if (typeof key === "string") {
+            result = key in WellKnownItemFilters;
+        }
+        return result;
+    }
+    /**
+     * Fetch the array of fitlers from the well-known hash
+     * @param key
+     * @returns
+     */
+    function lookupTypeFilters(key) {
+        return WellKnownItemFilters[key];
+    }
 
     // ##    ##  #######  ######## ########
     // ###   ## ##     ##    ##    ##
@@ -20229,6 +20483,8 @@
     exports.isDomainForLegacySite = isDomainForLegacySite;
     exports.isDomainUsedElsewhere = isDomainUsedElsewhere;
     exports.isDownloadable = isDownloadable;
+    exports.isEmptyFilter = isEmptyFilter;
+    exports.isEmptyFilterGroup = isEmptyFilterGroup;
     exports.isExtentCoordinateArray = isExtentCoordinateArray;
     exports.isFeatureService = isFeatureService$1;
     exports.isFieldworkerView = isFieldworkerView;