@esri/hub-common 9.41.0 → 9.43.0

package/dist/types/search/filter-utils.d.ts

@@ -1,5 +1,5 @@
 import { ISearchOptions } from "@esri/arcgis-rest-portal";
-import { IFilterGroup, FilterType } from "./types";
+import { Filter, IFilterGroup, FilterType } from "./types";
 /**
  * Expand a Filter into it's more expressive structure so it can be
  * serialized deterministically.
@@ -16,3 +16,15 @@ export declare function expandFilter<T>(filter: T): T;
  * @returns
  */
 export declare function serializeFilterGroupsForPortal(filterGroups: Array<IFilterGroup<FilterType>>): ISearchOptions;
+/**
+ * Determine if a Filter is "empty"
+ * @param filter
+ * @returns
+ */
+export declare function isEmptyFilter(filter: Filter<FilterType>): boolean;
+/**
+ * Determine if a filterGroup is "empty"
+ * @param filterGroup
+ * @returns
+ */
+export declare function isEmptyFilterGroup(filterGroup: IFilterGroup<FilterType>): boolean;

package/dist/types/search/types/types.d.ts

@@ -161,6 +161,7 @@ export interface IGroupFilterDefinition {
     orgid?: string | string[] | IMatchOptions;
     owner?: string | string[] | IMatchOptions;
     searchUserAccess?: "groupMember";
+    searchUserName?: string;
     tags?: string | string[] | IMatchOptions;
     term?: string;
     title?: string | string[] | IMatchOptions;

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.40.0 - Fri Jun 10 2022 19:52:59 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.42.0 - Wed Jun 15 2022 18:33:31 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;
     };
 
@@ -13535,7 +13549,7 @@
      * @param join
      * @returns
      */
-    function mergeSearchOptions(so1, so2, join) {
+    function mergeSearchOptions$1(so1, so2, join) {
         // TODO: Remove with _searchContent
         Logger.warn("DEPRECATION: mergeSearchOptions will be removed. Work with IFilterGroups<\"group\"> and hubSearch() instead");
         var result = cloneObject$1(so1);
@@ -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];
     }
     /**
@@ -14131,12 +14145,12 @@
                 // from hitting the else
                 /* istanbul ignore else */
                 if (typeof entry === "object") {
-                    acc = mergeSearchOptions(acc, convertContentFilterToSearchOptions(entry), "OR");
+                    acc = mergeSearchOptions$1(acc, convertContentFilterToSearchOptions(entry), "OR");
                 }
                 return acc;
             }, { q: "", filter: "" });
             // merge with searchOptions using AND
-            searchOptions = mergeSearchOptions(searchOptions, subFilterOptions, "AND");
+            searchOptions = mergeSearchOptions$1(searchOptions, subFilterOptions, "AND");
         }
         // term is always last, and pre-pended on searchOptions.q
         if (filter.term) {
@@ -14164,11 +14178,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions may go into either q or filter
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
             }
         });
         return result;
@@ -14299,11 +14313,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions fields
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
             }
         });
         // searchUserAccess is also a top-level property
@@ -14439,11 +14453,11 @@
             var key = _a[0], value = _a[1];
             // MatchOptions fields
             if (!specialProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeMatchOptions$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeMatchOptions$1(key, value), "AND");
             }
             // Dates only go into q
             if (dateProps.includes(key)) {
-                result = mergeSearchOptions(result, serializeDateRange$1(key, value), "AND");
+                result = mergeSearchOptions$1(result, serializeDateRange$1(key, value), "AND");
             }
         });
         // disabled is also a top-level property
@@ -14659,6 +14673,8 @@
      *
      * **Note** Authentication is required
      *
+     * Trivial comment to force a release
+     *
      * Note: in the future, there may be options to search via
      * a Hub specific API
      * @param filter
@@ -14971,7 +14987,13 @@
     function expandFilter(filter) {
         var result = {};
         var dateProps = ["created", "modified", "lastlogin"];
-        var copyProps = ["filterType", "term", "searchUserAccess", "isopendata"];
+        var copyProps = [
+            "filterType",
+            "term",
+            "searchUserAccess",
+            "isopendata",
+            "searchUserName",
+        ];
         var nonMatchOptionsFields = __spreadArrays(dateProps, copyProps);
         // Do the conversion
         Object.entries(filter).forEach(function (_a) {
@@ -15004,27 +15026,26 @@
      * @returns
      */
     function serializeFilterGroupsForPortal(filterGroups) {
-        var result = {
-            q: "",
-            filter: "",
-        };
-        result.q = filterGroups.map(serializeGroup).join(" AND ");
+        var groupSearchOptions = filterGroups.map(serializeGroup);
+        var result = mergeSearchOptions(groupSearchOptions, "AND");
         return result;
     }
     /**
      * Serialize the filters in a FitlerGroup into a Portal Query
-     * @param group
+     * @param filterGroup
      * @returns
      */
-    function serializeGroup(group) {
-        var operation = group.operation || "AND";
-        var filters = group.filters.map(expandFilter);
-        var q = filters.map(serializeFilter).join(" " + operation + " ");
-        // Wrap in parens if there is more than one filter
+    function serializeGroup(filterGroup) {
+        var operation = filterGroup.operation || "AND";
+        var filters = filterGroup.filters.map(expandFilter);
+        var filterSearchOptions = filters.map(serializeFilter);
+        // combine these searchOptions
+        var groupSearchOptions = mergeSearchOptions(filterSearchOptions, operation);
+        //
         if (filters.length > 1) {
-            q = "(" + q + ")";
+            groupSearchOptions.q = "(" + groupSearchOptions.q + ")";
         }
-        return q;
+        return groupSearchOptions;
     }
     /**
      * Serialize a Filter into a Portal Query
@@ -15034,36 +15055,64 @@
     function serializeFilter(filter) {
         var dateProps = ["created", "modified"];
         var boolProps = ["isopendata"];
+        var passThroughProps = ["searchUserAccess", "searchUserName"];
         var specialProps = __spreadArrays([
             "filterType",
-            "searchUserAccess",
             "term"
-        ], dateProps, boolProps);
+        ], dateProps, boolProps, passThroughProps);
+        var qCount = 0;
         // TODO: Look at using reduce vs .map and remove the `.filter`
-        var stringFilters = Object.entries(filter)
+        var opts = Object.entries(filter)
             .map(function (_a) {
             var key = _a[0], value = _a[1];
+            var so = { q: "" };
             if (!specialProps.includes(key)) {
-                return serializeMatchOptions(key, value);
+                qCount++;
+                so.q = serializeMatchOptions(key, value);
             }
             if (dateProps.includes(key)) {
-                return serializeDateRange(key, value);
+                qCount++;
+                so.q = serializeDateRange(key, value);
             }
             if (boolProps.includes(key)) {
-                return key + ":" + value;
+                qCount++;
+                so.q = key + ":" + value;
+            }
+            if (passThroughProps.includes(key)) {
+                so[key] = value;
             }
             if (key === "term") {
-                return value;
+                qCount++;
+                so.q = value;
             }
+            return so;
         })
             .filter(function (e) { return e !== undefined; });
-        // eslint-disable-next-line unicorn/prefer-ternary
-        if (stringFilters.length > 1) {
-            return "(" + stringFilters.join(" AND ") + ")";
-        }
-        else {
-            return stringFilters[0];
+        // merge up all the searchOptions
+        var searchOptions = mergeSearchOptions(opts, "AND");
+        if (qCount > 1) {
+            searchOptions.q = "(" + searchOptions.q + ")";
         }
+        return searchOptions;
+    }
+    function mergeSearchOptions(options, operation) {
+        var result = options.reduce(function (acc, entry) {
+            // walk the props
+            Object.entries(entry).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                // if prop exists
+                if (acc[key]) {
+                    // combine via operation
+                    acc[key] = acc[key] + " " + operation + " " + value;
+                }
+                else {
+                    // just copy the value
+                    acc[key] = value;
+                }
+            });
+            return acc;
+        }, { q: "" });
+        return result;
     }
     /**
      * Serialize MatchOptions into portal syntax
@@ -15119,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
@@ -17779,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;
                 });
@@ -17883,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];
+    }
 
     // ##    ##  #######  ######## ########
     // ###   ## ##     ##    ##    ##
@@ -20182,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;
@@ -20205,7 +20514,7 @@
     exports.mergeGroupFilters = mergeGroupFilters;
     exports.mergeMatchOptions = mergeMatchOptions;
     exports.mergeObjects = mergeObjects;
-    exports.mergeSearchOptions = mergeSearchOptions;
+    exports.mergeSearchOptions = mergeSearchOptions$1;
     exports.mergeUserFilters = mergeUserFilters;
     exports.normalizeItemType = normalizeItemType;
     exports.normalizeSolutionTemplateItem = normalizeSolutionTemplateItem;