@esri/hub-common 9.47.0 → 10.0.0-next.1

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.46.1 - Tue Jul 19 2022 15:08:51 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.49.0 - Thu Jul 21 2022 17:19:07 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -10011,6 +10011,37 @@
         return getPortal(orgId, __assign(__assign({}, options), { portal: basePortalUrl }));
     };
 
+    /**
+     * Generic function to fetch org limits
+     * @param orgId
+     * @param limitsType
+     * @param limitName
+     * @param options
+     * @returns
+     */
+    function fetchOrgLimits(orgId, limitsType, limitName, options) {
+        var portal = options.authentication.portal;
+        var url = portal + "/portals/" + orgId + "/limits?limitsType=" + limitsType + "&limitName=" + limitName + "&f=json";
+        return request(url, options);
+    }
+    /**
+     * Fetch the maximum number of groups a user can create in an org
+     * @param orgId
+     * @param options
+     * @returns
+     */
+    function fetchMaxNumUserGroupsLimit(orgId, options) {
+        return fetchOrgLimits(orgId, "Groups", "MaxNumUserGroups", options)
+            .then(function (response) {
+            return response.limitValue;
+        })
+            .catch(function (_) {
+            // it's possible that the org doesn't have this property set, and
+            // the api will return a 500 error. So we just return the default value
+            return 512;
+        });
+    }
+
     /**
      * Parse metadataxml into json object
      * @param metadataXml
@@ -13862,76 +13893,6 @@
             },
         ],
     };
-    /**
-     * @private
-     * Convert portal search response to facets
-     * Note: Only applicable to an item search
-     * @param response
-     * @returns
-     */
-    // TODO: Remove with _searchContent
-    function convertPortalResponseToFacets(response, operation) {
-        if (operation === void 0) { operation = "OR"; }
-        // delegate to a more future-friendly version
-        return convertPortalItemResponseToFacets(response, operation, "filter");
-    }
-    /**
-     * @private
-     * Convert portal search response to facets
-     * Note: Only applicable to an item search
-     * @param response
-     * @returns
-     */
-    function convertPortalItemResponseToFacets(response, operation, optionProp // TODO: Remove with _searchContent and use `filters`
-    ) {
-        var _a;
-        if (operation === void 0) { operation = "OR"; }
-        if (optionProp === void 0) { optionProp = "filters"; }
-        // TODO: move into portalSearchItems
-        var result = [];
-        if ((_a = response.aggregations) === null || _a === void 0 ? void 0 : _a.counts) {
-            response.aggregations.counts.forEach(function (entry) {
-                var facet = {
-                    label: entry.fieldName,
-                    key: entry.fieldName,
-                    aggField: entry.fieldName,
-                    display: "multi-select",
-                };
-                var options = [];
-                entry.fieldValues.forEach(function (fv) {
-                    var filter = {
-                        filterType: "item",
-                    };
-                    // construct the filter based on the operation
-                    var matchKey = operation === "OR" ? "any" : "all";
-                    var filterMatchOption = {};
-                    filterMatchOption[matchKey] = [fv.value];
-                    filter[entry.fieldName] = filterMatchOption;
-                    // construct the FacetOption
-                    var fo = {
-                        label: fv.value + " (" + fv.count + ")",
-                        key: fv.value,
-                        count: fv.count,
-                        selected: false,
-                    };
-                    // Temporary to ensure the old fn can delegate to this
-                    // but we can still return the correct structure
-                    // TODO: Remove with _searchContent
-                    /* istanbul ignore next */
-                    if (optionProp === "filter") {
-                        fo.filter = filter;
-                    }
-                    else {
-                        fo.filters = [filter];
-                    }
-                    options.push(fo);
-                });
-                facet.options = options;
-                result.push(facet);
-            });
-        }
-        return result;
-    }
     /**
      * Merge `Filter<"content">` objects
      *
@@ -14527,7 +14488,6 @@
                     searchPromise = Promise.resolve({
                         total: 0,
                         results: [],
-                        facets: [],
                         hasNext: false,
                         next: function () {
                             // tslint:disable-next-line
@@ -14571,12 +14531,9 @@
             }
             // add thumbnailUrl
             content = content.map(thumbnailify);
-            // convert aggregations into facets
-            var facets = convertPortalResponseToFacets(resp);
             return {
                 total: resp.total,
                 results: content,
-                facets: facets,
                 hasNext: hasNext,
                 next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$3),
             };
@@ -14756,234 +14713,68 @@
         });
     }
 
+    var CATALOG_SCHEMA_VERSION = 1.0;
     /**
-     * @private
-     * Apply the sortState to SortOptions
-     *
-     * @param sortOptions
-     * @param sortState
-     * @returns
-     */
-    function applySortState(sortOptions, sortState) {
-        var updated = cloneObject$1(sortOptions);
-        if (sortState) {
-            var _a = sortState.split("|"), label = _a[0], attribute = _a[1], order = _a[2];
-            updated.label = label;
-            updated.attribute = attribute;
-            updated.order = order;
-        }
-        return updated;
-    }
-    /**
-     * @private
-     * Apply FacetState to a Facet
-     * @param facet
-     * @param state
-     * @returns
-     */
-    function applyFacetState(facet, state) {
-        var updated = cloneObject$1(facet);
-        switch (facet.display) {
-            case "single-select":
-                updated = applySingleSelectFacetState(facet, state);
-                break;
-            case "multi-select":
-                updated = applyMultiSelectFacetState(facet, state);
-                break;
-        }
-        return updated;
-    }
-    /**
-     * @private
-     * Apply the Facet State onto a single-select facet
-     *
-     * Intentionally mutates the facet.
-     * @param facet
-     * @param state
+     * Apply schema upgrades to Catalog objects
+     * @param catalog
      * @returns
      */
-    function applySingleSelectFacetState(facet, state) {
-        var updated = cloneObject$1(facet);
-        updated.options = updated.options.map(function (o) {
-            o.selected = o.key === state[facet.key];
-            return o;
-        });
-        return updated;
-    }
-    /**
-     * @private
-     * Serialize single-select facet into IFacetState
-     * @param facet
-     * @returns
-     */
-    function serializeSingleSelectFacetState(facet) {
-        var state = {};
-        var selected = facet.options.find(function (o) { return o.selected; });
-        if (selected) {
-            state[facet.key] = selected.key;
+    function upgradeCatalogSchema(catalog) {
+        var clone = cloneObject$1(catalog);
+        if (getProp(clone, "schemaVersion") === CATALOG_SCHEMA_VERSION) {
+            return clone;
         }
         else {
-            state[facet.key] = null;
+            // apply migrations in order
+            clone = applyCatalogSchema(clone);
+            return clone;
         }
-        return state;
-    }
-    /**
-     * @private
-     * Apply the Facet State onto a multi-select Facet
-     *
-     * Intentionally mutates the facet.
-     * @param facet
-     * @param state
-     * @returns
-     */
-    function applyMultiSelectFacetState(facet, state) {
-        var _a;
-        var updated = cloneObject$1(facet);
-        var selectedKeys = ((_a = state[facet.key]) === null || _a === void 0 ? void 0 : _a.split(",")) || [];
-        updated.options = updated.options.map(function (o) {
-            o.selected = selectedKeys.includes(o.key);
-            return o;
-        });
-        return updated;
     }
     /**
-     * @private
-     * Serialize multi-select facet into IFacetState
-     * @param facet
+     * Apply the Catalog schema to the original, unversioned
+     * site catalog objects
+     * @param original
      * @returns
      */
-    function serializeMultiSelectFacetState(facet) {
-        var state = {};
-        var selected = facet.options.filter(function (o) { return o.selected; });
-        var value = selected.map(function (o) { return o.key; }).join(",");
-        if (value.length) {
-            state[facet.key] = value;
+    function applyCatalogSchema(original) {
+        if (getProp(original, "schemaVersion") > 1.0) {
+            return original;
         }
         else {
-            state[facet.key] = null;
-        }
-        return state;
-    }
-    /**
-     * @private
-     * Serialize the state of the SortOption into a key/value pair
-     *
-     * Called from the Sort component
-     * @param sort
-     * @returns
-     */
-    function serializeSortState(sort) {
-        return sort.label + "|" + sort.attribute + "|" + sort.order;
-    }
-    /**
-     * @private
-     * Serialize the state of a facet into a key/value pair
-     *
-     * Called from the various facet components
-     * @param facet
-     * @returns
-     */
-    function serializeFacetState(facet) {
-        var state = {};
-        switch (facet.display) {
-            case "single-select":
-                state = serializeSingleSelectFacetState(facet);
-                break;
-            case "multi-select":
-                state = serializeMultiSelectFacetState(facet);
-                break;
-        }
-        return state;
-    }
-
-    /**
-     * Apply ICollectionState to an ICollection
-     *
-     * Typically used in a Gallery or Catalog component to
-     * set the inital state, based on values deserialized
-     * from a query string
-     * @param collection
-     * @param state
-     * @returns
-     */
-    function applyCollectionState(collection, state) {
-        var updated = cloneObject$1(collection);
-        // Apply default query
-        if (state.query) {
-            updated.defaultQuery = state.query;
-        }
-        // Apply Sort State
-        updated.sortOption = applySortState(updated.sortOption, state.sort);
-        // Look for state props for the facets and apply them
-        updated.facets = updated.facets.map(function (facet) {
-            // see if there is a key for this facet on the state
-            if (Object.keys(state).includes(facet.key)) {
-                var facetState = {};
-                facetState[facet.key] = state[facet.key];
-                return applyFacetState(facet, facetState);
+            var catalog = {
+                schemaVersion: 1,
+                title: "Default Catalog",
+                scopes: {
+                    item: {
+                        targetEntity: "item",
+                        filters: [],
+                    },
+                },
+                collections: [],
+            };
+            var rawGroups = getProp(original, "groups");
+            var groups = [];
+            if (Array.isArray(rawGroups) && rawGroups.length) {
+                groups = rawGroups;
             }
-            else {
-                // Ensure all options are not selected
-                // because they were not included in the state
-                facet.options.forEach(function (opt) {
-                    opt.selected = false;
+            else if (typeof rawGroups === "string") {
+                groups = [rawGroups];
+            }
+            if (groups.length) {
+                catalog.scopes.item.filters.push({
+                    predicates: [{ group: groups }],
                 });
-                return facet;
             }
-        });
-        //
-        return updated;
-    }
-    /**
-     * Serialize the current state of a collection into a hash that
-     * can be converted into a query string
-     * @param collection
-     * @returns
-     */
-    function serializeCollectionState(collection) {
-        var state = {};
-        if (collection.defaultQuery) {
-            state.query = collection.defaultQuery;
-        }
-        if (collection.sortOption) {
-            state.sort = serializeSortState(collection.sortOption);
+            return catalog;
         }
-        var facetState = (collection.facets || []).reduce(function (s, facet) {
-            return __assign(__assign({}, s), serializeFacetState(facet));
-        }, {});
-        return __assign(__assign({}, state), facetState);
     }
-
     /**
-     * Convert the original site catalog structure into a formal ICatalog
+     * DEPRECATED: Use upgradeCatalogSchema(...)
      * @param original
      */
+    /* istanbul ignore next */
     function convertCatalog(original) {
-        var catalog = {
-            schemaVersion: 1,
-            title: "Default Catalog",
-            scopes: {
-                item: {
-                    targetEntity: "item",
-                    filters: [],
-                },
-            },
-            collections: [],
-        };
-        var rawGroups = getProp(original, "groups");
-        var groups = [];
-        if (Array.isArray(rawGroups) && rawGroups.length) {
-            groups = rawGroups;
-        }
-        else if (typeof rawGroups === "string") {
-            groups = [rawGroups];
-        }
-        if (groups.length) {
-            catalog.scopes.item.filters.push({
-                predicates: [{ group: groups }],
-            });
-        }
-        return catalog;
+        return upgradeCatalogSchema(original);
     }
 
     /**
@@ -18022,7 +17813,7 @@
      */
     function searchPortal$2(searchOptions) {
         return __awaiter(this, void 0, void 0, function () {
-            var resp, fn, results, facets, aggregations;
+            var resp, fn, results, aggregations;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, searchItems(searchOptions)];
@@ -18034,13 +17825,11 @@
                         return [4 /*yield*/, Promise.all(resp.results.map(fn))];
                     case 2:
                         results = _a.sent();
-                        facets = convertPortalItemResponseToFacets(resp);
                         aggregations = convertPortalAggregations(resp);
                         // Construct the return
                         return [2 /*return*/, {
                                 total: resp.total,
                                 results: results,
-                                facets: facets,
                                 aggregations: aggregations,
                                 hasNext: resp.nextStart > -1,
                                 next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$2),
@@ -18339,7 +18128,7 @@
     function hubSearchItems(filters, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var api, apiUrl, cleanFilters, searchRequest, aggs, session, opts, raw, json, token_1, us, tokenizeThubmnailUrl, conversion, results, facets, response, ex_1;
+            var api, apiUrl, cleanFilters, searchRequest, aggs, session, opts, raw, json, token_1, us, tokenizeThubmnailUrl, conversion, results, response, ex_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -18420,11 +18209,9 @@
                         return [4 /*yield*/, Promise.all(json.data.map(conversion))];
                     case 4:
                         results = _b.sent();
-                        facets = convertHubResponseToFacets(json);
                         response = {
                             total: json.meta.total,
                             results: results,
-                            facets: facets,
                             hasNext: json.meta.hasNext,
                             next: function () {
                                 // tslint:disable-next-line
@@ -18477,48 +18264,6 @@
         // TODO: Per-type plucking of props into the `meta` hash for use in the card components
         return Promise.resolve(result);
     }
-    /* istanbul ignore next */
-    function convertHubResponseToFacets(response, operation) {
-        var _a;
-        if (operation === void 0) { operation = "OR"; }
-        var result = [];
-        if ((_a = response.meta) === null || _a === void 0 ? void 0 : _a.aggregations) {
-            var meta = response.meta;
-            meta.aggregations.forEach(function (entry) {
-                // Dyanmic facets typically "AND" so we are refining
-                var facet = {
-                    label: entry.field,
-                    key: entry.field,
-                    aggField: entry.field,
-                    display: "multi-select",
-                    operation: operation,
-                };
-                var options = [];
-                entry.values.forEach(function (fv) {
-                    var filter = {
-                        filterType: "item",
-                    };
-                    // construct the filter based on the operation
-                    var matchKey = operation === "OR" ? "any" : "all";
-                    var filterMatchOption = {};
-                    filterMatchOption[matchKey] = [fv.value];
-                    filter[entry.field] = filterMatchOption;
-                    // construct the FacetOption
-                    var fo = {
-                        label: fv.value + " (" + fv.count + ")",
-                        key: fv.value,
-                        count: fv.count,
-                        selected: false,
-                        filters: [filter],
-                    };
-                    options.push(fo);
-                });
-                facet.options = options;
-                result.push(facet);
-            });
-        }
-        return result;
-    }
 
     /**
      * @private
@@ -18591,7 +18336,6 @@
                         return [2 /*return*/, {
                                 total: resp.total,
                                 results: results,
-                                facets: [],
                                 hasNext: resp.nextStart > -1,
                                 next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal$1),
                             }];
@@ -18692,7 +18436,6 @@
                         return [2 /*return*/, {
                                 total: resp.total,
                                 results: results,
-                                facets: [],
                                 hasNext: resp.nextStart > -1,
                                 next: getNextFunction(searchOptions, resp.nextStart, resp.total, searchPortal),
                             }];
@@ -18782,13 +18525,584 @@
                 };
                 fn = getProp(fnHash, apiType + "." + filterType);
                 if (!fn) {
-                    throw new HubError$1("hubSearch", "Search via \"" + filterType + "\" filter against \"" + apiType + "\" api is not implemented");
+                    throw new HubError$1("hubSearch", "Search via \"" + filterType + "\" filter against \"" + apiType + "\" api is not implemented. Please ensure \"targetEntity\" is defined on the query.");
                 }
                 return [2 /*return*/, fn(cloneObject$1(query), options)];
             });
         });
     }
 
+    /**
+     * Collection Class
+     *
+     * Abstracts searching a Collection
+     *
+     * For more information, check out the [Catalog & Collection Guide](/hub.js/guides/concepts/catalog-collection/)
+     */
+    var Collection = /** @class */ (function () {
+        function Collection(collection, context) {
+            this._collection = collection;
+            this._context = context;
+        }
+        /**
+         * Create an instance of a Collection from a JSON object
+         * @param collection
+         * @param context
+         * @returns
+         */
+        Collection.fromJson = function (collection, context) {
+            return new Collection(collection, context);
+        };
+        /**
+         * Return the JSON object backing the instance
+         * @returns
+         */
+        Collection.prototype.toJson = function () {
+            return cloneObject$1(this._collection);
+        };
+        Object.defineProperty(Collection.prototype, "label", {
+            // Getters
+            get: function () {
+                return this._collection.label;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "key", {
+            get: function () {
+                return this._collection.key;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "include", {
+            get: function () {
+                return this._collection.include || [];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "scope", {
+            get: function () {
+                return this._collection.scope;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "sortField", {
+            get: function () {
+                return this._collection.sortField || "title";
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "sortDirection", {
+            get: function () {
+                return this._collection.sortDirection || "asc";
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Collection.prototype, "targetEntity", {
+            get: function () {
+                return this._collection.targetEntity;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * Search the collection using a string or IQuery
+         * @param query
+         * @param options
+         * @returns
+         */
+        Collection.prototype.search = function (query, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var qry, opts;
+                return __generator(this, function (_a) {
+                    if (typeof query === "string") {
+                        // construct a query from that...
+                        qry = {
+                            targetEntity: this._collection.targetEntity,
+                            filters: [
+                                {
+                                    predicates: [
+                                        {
+                                            term: query,
+                                        },
+                                    ],
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        qry = query;
+                    }
+                    // TODO: What should happen when a Query is passed in that has a targetEntity that doesn't match the collection's targetEntity?
+                    // merge the passed in query w/ the scope
+                    qry.filters = __spreadArrays(qry.filters, this.scope.filters);
+                    opts = cloneObject$1(options);
+                    opts.requestOptions = this._context.hubRequestOptions;
+                    // inject default sort info if not specified
+                    opts.sortField = options.sortField || this.sortField;
+                    opts.sortOrder = options.sortOrder || this.sortDirection;
+                    // inject default includes if not specified
+                    opts.include = options.include || this.include;
+                    // execute the search and return results
+                    return [2 /*return*/, hubSearch(qry, opts)];
+                });
+            });
+        };
+        return Collection;
+    }());
+
+    /**
+     * Fetch a IHubCatalog from a backing item.
+     * This will apply schema upgrades to the structure
+     * @param identifier
+     * @param requestOptions
+     * @returns
+     */
+    function fetchCatalog(identifier, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var getPrms, url, fetched;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // identifier can be a guid or a url
+                        if (identifier.indexOf("http") === 0) {
+                            url = identifier;
+                            // get down the the hostname
+                            url = stripProtocol(url);
+                            // if url does not include a hash (i.e. it's not portal)
+                            // then we want to split on the first slash to get the hostname
+                            // lookupDomain will handle the enterprise base urls
+                            if (!url.includes("#")) {
+                                url = url.split("/")[0];
+                            }
+                            getPrms = lookupDomain(url, requestOptions)
+                                // get the item's data, and read the catalog out of it
+                                .then(function (_a) {
+                                var siteId = _a.siteId;
+                                return getItemData(siteId, requestOptions);
+                            })
+                                .then(function (data) {
+                                return upgradeCatalogSchema(data.catalog || {});
+                            });
+                        }
+                        else if (isGuid(identifier)) {
+                            // get the item's data, and read the catalog out of it
+                            getPrms = getItemData(identifier, requestOptions).then(function (data) {
+                                return upgradeCatalogSchema(data.catalog || {});
+                            });
+                        }
+                        else {
+                            throw new HubError$1("Catalog.create", "Identifier must be a url, guid");
+                        }
+                        return [4 /*yield*/, getPrms];
+                    case 1:
+                        fetched = _a.sent();
+                        return [2 /*return*/, fetched];
+                }
+            });
+        });
+    }
+
+    /**
+     * Catalog Class
+     *
+     * Abstracts working with Catalogs and fetching collections with
+     * the correct scope applied.
+     *
+     * For more information, check out the [Catalog & Collection Guide](/hub.js/guides/concepts/catalog-collection/)
+     */
+    var Catalog = /** @class */ (function () {
+        // internal - use static factory methods
+        function Catalog(catalog, context) {
+            this._catalog = catalog;
+            this._context = context;
+        }
+        /**
+         * Create a Collection instance from a Catalog json object, a site url or itemId
+         * '''js
+         * const catalog = await Catalog.create('https://site-org.hub.arcgis.com', context);
+         * '''
+         *
+         * @param identifier
+         * @param context
+         * @returns
+         */
+        Catalog.init = function (identifier, context) {
+            return __awaiter(this, void 0, void 0, function () {
+                var mgr, fetched;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!context) return [3 /*break*/, 2];
+                            return [4 /*yield*/, ArcGISContextManager.create()];
+                        case 1:
+                            mgr = _a.sent();
+                            context = mgr.context;
+                            _a.label = 2;
+                        case 2: return [4 /*yield*/, fetchCatalog(identifier, context.hubRequestOptions)];
+                        case 3:
+                            fetched = _a.sent();
+                            // return an instance
+                            return [2 /*return*/, new Catalog(fetched, context)];
+                    }
+                });
+            });
+        };
+        /**
+         * Create a Catalog instance from a Catalog Json object
+         * @param json
+         * @param context
+         * @returns
+         */
+        Catalog.fromJson = function (json, context) {
+            // ensure it's in the latest structure
+            var catalog = upgradeCatalogSchema(json);
+            return new Catalog(catalog, context);
+        };
+        /**
+         * Return the JSON object backing the instance
+         * @returns
+         */
+        Catalog.prototype.toJson = function () {
+            return cloneObject$1(this._catalog);
+        };
+        Object.defineProperty(Catalog.prototype, "schemaVersion", {
+            /**
+             * Return the schema version
+             */
+            get: function () {
+                return this._catalog.schemaVersion;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Catalog.prototype, "title", {
+            /**
+             * Title getter
+             */
+            get: function () {
+                return this._catalog.title;
+            },
+            /**
+             * Title setter
+             */
+            set: function (v) {
+                this._catalog.title = v;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Catalog.prototype, "scopes", {
+            /**
+             * Return the existing scopes hash
+             */
+            get: function () {
+                return this._catalog.scopes;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Catalog.prototype, "availableScopes", {
+            /**
+             * Return an array of the entity types available in this Catalog
+             */
+            get: function () {
+                return Object.keys(this.scopes);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * Get the scope's query for a particular entity type
+         * @param type
+         * @returns
+         */
+        Catalog.prototype.getScope = function (type) {
+            return this._catalog.scopes[type];
+        };
+        /**
+         * Set the scope for a specific entity type
+         * @param type
+         * @param query
+         */
+        Catalog.prototype.setScope = function (type, query) {
+            this._catalog.scopes[type] = query;
+        };
+        Object.defineProperty(Catalog.prototype, "collections", {
+            /**
+             * Get the collections array. Returns simple objects not Collection instances
+             */
+            get: function () {
+                return this._catalog.collections || [];
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Catalog.prototype, "collectionNames", {
+            /**
+             * Get the names of the collections
+             */
+            get: function () {
+                return mapBy("key", this.collections);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * Get a Collection instance by name
+         * @param name
+         * @returns
+         */
+        Catalog.prototype.getCollection = function (name) {
+            var json = this.collections.find(function (entry) { return entry.key === name; });
+            if (json) {
+                // clone it then merge in the associated scope filter
+                var clone = cloneObject$1(json);
+                var catalogScope = this.getScope(clone.scope.targetEntity);
+                if (catalogScope === null || catalogScope === void 0 ? void 0 : catalogScope.filters) {
+                    clone.scope.filters = __spreadArrays(clone.scope.filters, catalogScope.filters);
+                }
+                return Collection.fromJson(clone, this._context);
+            }
+            else {
+                throw new HubError$1("getCollection", "Collection \"" + name + "\" is not present in the Catalog");
+            }
+        };
+        /**
+         * Search for Items
+         * Will throw if the Catalog does not have a scope defined for items
+         * @param query
+         * @param options
+         * @returns
+         */
+        Catalog.prototype.searchItems = function (query, options) {
+            if (options === void 0) { options = {}; }
+            if (!this.getScope("item")) {
+                var result = this.getEmptyResult();
+                result.messages = [
+                    {
+                        code: "missingScope",
+                        message: "Catalog does not have a scope for items",
+                        data: {
+                            scope: "item",
+                        },
+                    },
+                ];
+                return Promise.resolve(result);
+            }
+            else {
+                // ensure it's an item search
+                options.targetEntity = "item";
+                return this.search(query, options);
+            }
+        };
+        /**
+         * Search for Groups
+         * Will throw if the Catalog does not have a scope defined for groups
+         * @param query
+         * @param options
+         * @returns
+         */
+        Catalog.prototype.searchGroups = function (query, options) {
+            if (options === void 0) { options = {}; }
+            if (!this.getScope("group")) {
+                var result = this.getEmptyResult();
+                result.messages = [
+                    {
+                        code: "missingScope",
+                        message: "Catalog does not have a scope for groups",
+                        data: {
+                            scope: "group",
+                        },
+                    },
+                ];
+                return Promise.resolve(result);
+            }
+            else {
+                // ensure it's an group search
+                options.targetEntity = "group";
+                return this.search(query, options);
+            }
+        };
+        /**
+         * Search for Users
+         * Will throw if the Catalog does not have a scope defined for users
+         * @param query
+         * @param options
+         * @returns
+         */
+        Catalog.prototype.searchUsers = function (query, options) {
+            if (options === void 0) { options = {}; }
+            if (!this.getScope("user")) {
+                var result = this.getEmptyResult();
+                result.messages = [
+                    {
+                        code: "missingScope",
+                        message: "Catalog does not have a scope for user",
+                        data: {
+                            scope: "user",
+                        },
+                    },
+                ];
+                return Promise.resolve(result);
+            }
+            else {
+                // ensure it's an group search
+                options.targetEntity = "user";
+                return this.search(query, options);
+            }
+        };
+        /**
+         * Execute a search against all the collections in the Catalog
+         * @param query
+         * @param options
+         * @returns
+         */
+        Catalog.prototype.searchCollections = function (query, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var qry, promiseKeys, promises, responses, hash, i;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            qry = {
+                                targetEntity: "item",
+                                filters: [
+                                    {
+                                        predicates: [
+                                            {
+                                                term: query,
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                            promiseKeys = [];
+                            promises = this.collectionNames.map(function (name) {
+                                var col = _this.getCollection(name);
+                                promiseKeys.push(name);
+                                qry.targetEntity = col.targetEntity;
+                                return col.search(qry, options);
+                            });
+                            return [4 /*yield*/, Promise.all(promises)];
+                        case 1:
+                            responses = _a.sent();
+                            hash = {};
+                            for (i = 0; i < promiseKeys.length; i++) {
+                                hash[promiseKeys[i]] = responses[i];
+                            }
+                            return [2 /*return*/, hash];
+                    }
+                });
+            });
+        };
+        /**
+         * Execute a search against all the scopes in the Catalog
+         * @param query
+         * @param options
+         * @returns
+         */
+        Catalog.prototype.searchScopes = function (query, options) {
+            if (options === void 0) { options = {}; }
+            return __awaiter(this, void 0, void 0, function () {
+                var qry, promiseKeys, promises, responses, hash, i;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            qry = {
+                                targetEntity: "item",
+                                filters: [
+                                    {
+                                        predicates: [
+                                            {
+                                                term: query,
+                                            },
+                                        ],
+                                    },
+                                ],
+                            };
+                            promiseKeys = [];
+                            promises = this.availableScopes.map(function (name) {
+                                promiseKeys.push(name);
+                                // make clones
+                                var qryClone = cloneObject$1(qry);
+                                var optsClone = cloneObject$1(options);
+                                // set the target entity
+                                qryClone.targetEntity = name;
+                                optsClone.targetEntity = name;
+                                // return the search promise
+                                return _this.search(qryClone, optsClone);
+                            });
+                            return [4 /*yield*/, Promise.all(promises)];
+                        case 1:
+                            responses = _a.sent();
+                            hash = {};
+                            for (i = 0; i < promiseKeys.length; i++) {
+                                hash[promiseKeys[i]] = responses[i];
+                            }
+                            return [2 /*return*/, hash];
+                    }
+                });
+            });
+        };
+        /**
+         * Execute a search against the Catalog as a whole
+         * @param query
+         * @param targetEntity
+         * @returns
+         */
+        Catalog.prototype.search = function (query, options) {
+            var targetEntity = options.targetEntity;
+            var qry;
+            if (typeof query === "string") {
+                qry = {
+                    targetEntity: targetEntity,
+                    filters: [
+                        {
+                            predicates: [
+                                {
+                                    term: query,
+                                },
+                            ],
+                        },
+                    ],
+                };
+            }
+            else {
+                qry = cloneObject$1(query);
+            }
+            // Now merge in catalog scope level filters
+            qry.filters = __spreadArrays(qry.filters, this.getScope(targetEntity).filters);
+            var opts = cloneObject$1(options);
+            // An Catalog instance always uses the context so we remove/replace any passed in auth
+            delete opts.authentication;
+            opts.requestOptions = this._context.hubRequestOptions;
+            return hubSearch(qry, opts);
+        };
+        /**
+         * Construct an empty result. Returned when a search is performed against an entity type that
+         * does not have a scope defined.
+         * @returns
+         */
+        Catalog.prototype.getEmptyResult = function () {
+            return {
+                results: [],
+                total: 0,
+                hasNext: false,
+                next: null,
+            };
+        };
+        return Catalog;
+    }());
+
     /**
      * Enrich a generic search result
      * @param group
@@ -20399,6 +20713,8 @@
 
     exports.ArcGISContext = ArcGISContext;
     exports.ArcGISContextManager = ArcGISContextManager;
+    exports.Catalog = Catalog;
+    exports.Collection = Collection;
     exports.DEFAULT_THEME = DEFAULT_THEME;
     exports.ENTERPRISE_SITE_ITEM_TYPE = ENTERPRISE_SITE_ITEM_TYPE;
     exports.GLOBAL_EXTENT = GLOBAL_EXTENT;
@@ -20460,7 +20776,6 @@
     exports.addSiteDomains = addSiteDomains;
     exports.addSolutionResourceUrlToAssets = addSolutionResourceUrlToAssets;
     exports.addUsersToGroup = addUsersToGroup;
-    exports.applyCollectionState = applyCollectionState;
     exports.applyPropertiesToItems = applyPropertiesToItems;
     exports.arrayToObject = arrayToObject;
     exports.atob = abab.atob;
@@ -20491,8 +20806,6 @@
     exports.convertContentFilterToSearchOptions = convertContentFilterToSearchOptions;
     exports.convertItemToProject = convertItemToProject;
     exports.convertItemToSite = convertItemToSite;
-    exports.convertPortalItemResponseToFacets = convertPortalItemResponseToFacets;
-    exports.convertPortalResponseToFacets = convertPortalResponseToFacets;
     exports.convertSolutionTemplateResourcesToAssets = convertSolutionTemplateResourcesToAssets;
     exports.convertToWellKnownLocale = convertToWellKnownLocale;
     exports.convertUrlsToAnchorTags = convertUrlsToAnchorTags;
@@ -20545,8 +20858,10 @@
     exports.fetchContent = fetchContent;
     exports.fetchHubTranslation = fetchHubTranslation;
     exports.fetchImageAsBlob = fetchImageAsBlob;
+    exports.fetchMaxNumUserGroupsLimit = fetchMaxNumUserGroupsLimit;
     exports.fetchModelFromItem = fetchModelFromItem;
     exports.fetchOrg = fetchOrg;
+    exports.fetchOrgLimits = fetchOrgLimits;
     exports.fetchProject = fetchProject;
     exports.fetchSite = fetchSite;
     exports.fetchSiteModel = fetchSiteModel;
@@ -20680,7 +20995,6 @@
     exports.saveSession = saveSession;
     exports.searchProjects = searchProjects;
     exports.searchSites = searchSites;
-    exports.serializeCollectionState = serializeCollectionState;
     exports.serializeContentFilterForPortal = serializeContentFilterForPortal;
     exports.serializeDateRange = serializeDateRange$1;
     exports.serializeGroupFilterForPortal = serializeGroupFilterForPortal;
@@ -20708,6 +21022,7 @@
     exports.updateModel = updateModel;
     exports.updateProject = updateProject;
     exports.updateSite = updateSite;
+    exports.upgradeCatalogSchema = upgradeCatalogSchema;
     exports.upgradeProtocol = upgradeProtocol;
     exports.upgradeSiteSchema = upgradeSiteSchema;
     exports.uploadResourcesFromUrl = uploadResourcesFromUrl;