@esri/hub-common 9.41.1 → 9.43.1

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.41.0 - Mon Jun 13 2022 14:36:13 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.43.0 - Wed Jun 15 2022 19:01:13 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -6449,6 +6449,7 @@
     (function (PublisherSource) {
         PublisherSource["CitationContact"] = "metadata.resource.citation.contact";
         PublisherSource["ResourceContact"] = "metadata.resource.contact";
+        PublisherSource["MetadataContact"] = "metadata.contact";
         PublisherSource["ItemOwner"] = "item.owner";
         PublisherSource["None"] = "none";
     })(exports.PublisherSource || (exports.PublisherSource = {}));
@@ -7082,7 +7083,8 @@
             organizationSource: exports.PublisherSource.None,
         };
         var citationContact = extractFirstContact(metadata, "metadata.dataIdInfo.idCitation.citRespParty");
-        var resourceContact = extractFirstContact(metadata, "metadata.mdContact");
+        var resourceContact = extractFirstContact(metadata, "metadata.dataIdInfo.idPoC");
+        var metadataContact = extractFirstContact(metadata, "metadata.mdContact");
         // Determine publisher name properties
         var ownerFullName = getProp(ownerUser, "fullName");
         if (citationContact.individualName) {
@@ -7093,6 +7095,10 @@
             result.name = resourceContact.individualName;
             result.nameSource = exports.PublisherSource.ResourceContact;
         }
+        else if (metadataContact.individualName) {
+            result.name = metadataContact.individualName;
+            result.nameSource = exports.PublisherSource.MetadataContact;
+        }
         else if (ownerFullName) {
             result.name = ownerFullName;
             result.username = ownerUser.username;
@@ -7108,11 +7114,19 @@
             result.organization = resourceContact.organizationName;
             result.organizationSource = exports.PublisherSource.ResourceContact;
         }
+        else if (metadataContact.organizationName) {
+            result.organization = metadataContact.organizationName;
+            result.organizationSource = exports.PublisherSource.MetadataContact;
+        }
         else if (orgName) {
             result.organization = orgName;
             result.orgId = getItemOrgId(item, ownerUser);
             result.organizationSource = exports.PublisherSource.ItemOwner;
         }
+        // We assume the item belongs to external org if no org info is available and the item is private
+        result.isExternal =
+            result.organizationSource === exports.PublisherSource.None &&
+                item.access !== "public";
         return result;
     };
 
@@ -14030,7 +14044,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);
@@ -14040,7 +14054,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 ;
@@ -14063,7 +14077,7 @@
         }
         return result;
     }
-    function lookupTypeFilters(key) {
+    function lookupTypeFilters$1(key) {
         return ContentFilterExpansions[key];
     }
     /**
@@ -14659,6 +14673,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
@@ -15152,6 +15168,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
@@ -17812,12 +17858,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;
                 });
@@ -17916,6 +17963,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];
+    }
 
     // ##    ##  #######  ######## ########
     // ###   ## ##     ##    ##    ##
@@ -20215,6 +20489,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;