@esri/hub-common 9.17.1 → 9.20.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.17.0 - Thu Feb 17 2022 19:38:03 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.19.0 - Fri Feb 25 2022 14:52:42 GMT+0000 (Coordinated Universal Time)
  * Copyright (c) 2022 Environmental Systems Research Institute, Inc.
  * Apache-2.0
  */
@@ -5850,6 +5850,27 @@
         "Workflow Manager Package",
     ];
     var site$1 = ["Hub Site Application", "Site Application"];
+    /**
+     * ```js
+     * import { getCollection } from "@esri/hub-common";
+     * //
+     * getCollection('Feature Layer')
+     * > 'dataset'
+     * ```
+     * Get the Hub collection for a given item type
+     * @param itemType The ArcGIS [item type](https://developers.arcgis.com/rest/users-groups-and-items/items-and-item-types.htm).
+     * @returns the Hub collection of a given item type.
+     */
+    var getCollection = function (type) {
+        if (!type) {
+            return;
+        }
+        var lowerCaseType = type.toLocaleLowerCase();
+        return Object.keys(collections).find(function (key) {
+            var collectionTypes = collections[key];
+            return collectionTypes.some(function (t) { return t.toLocaleLowerCase() === lowerCaseType; });
+        });
+    };
     // TODO: remove this at the next breaking change
     // it's only here to support deprecated categories
     var collections = {
@@ -6084,6 +6105,252 @@
         };
     };
 
+    // private helper functions
+    function collectionToFamily(collection) {
+        var overrides = {
+            other: "content",
+            solution: "template",
+        };
+        return overrides[collection] || collection;
+    }
+    /**
+     * return the Hub family given an item's type
+     * @param type item type
+     * @returns Hub family
+     */
+    function getFamily(type) {
+        var family;
+        // override default behavior for the rows that are highlighted in yellow here:
+        // https://esriis.sharepoint.com/:x:/r/sites/ArcGISHub/_layouts/15/Doc.aspx?sourcedoc=%7BADA1C9DC-4F6C-4DE4-92C6-693EF9571CFA%7D&file=Hub%20Routes.xlsx&nav=MTBfe0VENEREQzI4LUZFMDctNEI0Ri04NjcyLThCQUE2MTA0MEZGRn1fezIwMTIwMEJFLTA4MEQtNEExRC05QzA4LTE5MTAzOUQwMEE1RH0&action=default&mobileredirect=true&cid=df1c874b-c367-4cea-bc13-7bebfad3f2ac
+        switch ((type || "").toLowerCase()) {
+            case "image service":
+                family = "dataset";
+                break;
+            case "feature service":
+            case "raster layer":
+                // TODO: check if feature service has > 1 layer first?
+                family = "map";
+                break;
+            case "microsoft excel":
+                family = "document";
+                break;
+            case "cad drawing":
+            case "feature collection template":
+            case "report template":
+                family = "content";
+                break;
+            default:
+                // by default derive from collection
+                family = collectionToFamily(getCollection(type));
+        }
+        return family;
+    }
+
+    // TODO: this needs to be able to handle "automatic"
+    var getContentBoundary = function (item) {
+        var _a;
+        var extent = item.extent;
+        var isValidItemExtent = isBBox(extent);
+        // user specified provenance is stored in item.properties
+        var provenance = ((_a = item.properties) === null || _a === void 0 ? void 0 : _a.boundary) ||
+            // but we default to item if the item has an extent
+            (isValidItemExtent ? "item" : undefined);
+        var geometry;
+        switch (provenance) {
+            case "item":
+                geometry = isValidItemExtent ? bBoxToPolygon(extent) : null;
+                break;
+            case "none":
+                geometry = null;
+                break;
+            // TODO: handle other provenances
+        }
+        // TODO: derive and return center
+        return {
+            provenance: provenance,
+            geometry: geometry,
+        };
+    };
+    // when no request options are provided, the underlying
+    // request functions assume that we are online in production
+    // so we only want use enterprise logic if isPortal is explicitly defined
+    var isPortal = function (requestOptions) {
+        return requestOptions && requestOptions.isPortal;
+    };
+    /**
+     * Returns whether or not an item is a proxied csv
+     *
+     * @param item
+     * @param requestOptions Hub Request Options (including whether we're in portal)
+     * @returns
+     */
+    var isProxiedCSV = function (item, requestOptions) {
+        return !isPortal(requestOptions) &&
+            item.access === "public" &&
+            item.type === "CSV" &&
+            item.size <= 5000000;
+    };
+    var getHubRelativeUrl = function (type, identifier, typeKeywords) {
+        // solution types have their own logic
+        var contentUrl = getSolutionUrl(type, identifier, typeKeywords);
+        if (!contentUrl) {
+            var family = getFamily(type);
+            var familiesWithPluralizedRoute = [
+                "app",
+                "dataset",
+                "document",
+                "map",
+                "template",
+            ];
+            // default to the catchall content route
+            var path = "/content";
+            if (family === "feedback") {
+                // the exception
+                path = "/feedback/surveys";
+            }
+            else if (isPageType(type)) {
+                // pages are in the document family,
+                // but instead of showing the page's metadata on /documents/about
+                // but we render the page on the pages route
+                path = "/pages";
+            }
+            else if (familiesWithPluralizedRoute.indexOf(family) > -1) {
+                // the rule: route name is plural of family name
+                path = "/" + family + "s";
+            }
+            contentUrl = path + "/" + identifier;
+        }
+        return contentUrl;
+    };
+    var isPageType = function (type) {
+        return ["Hub Page", "Site Page"].includes(type);
+    };
+    var getSolutionUrl = function (type, identifier, typeKeywords) {
+        var hubUrl;
+        if (type === "Solution") {
+            // NOTE: as per the above spreadsheet,
+            // solution types are now in the Template family
+            // but we don't send them to the route for initiative templates
+            if ((typeKeywords === null || typeKeywords === void 0 ? void 0 : typeKeywords.indexOf("Deployed")) > 0) {
+                // deployed solutions go to the generic content route
+                hubUrl = "/content/" + identifier;
+            }
+            // others go to the solution about route
+            hubUrl = "/templates/" + identifier + "/about";
+        }
+        return hubUrl;
+    };
+    function getMetadataPath(identifier) {
+        // NOTE: i have verified that this will work regardless of the "Metadata Style" set on the org
+        var metadataPaths = {
+            updateFrequency: "metadata.dataIdInfo.resMaint.maintFreq.MaintFreqCd.@_value",
+            reviseDate: "metadata.dataIdInfo.idCitation.date.reviseDate",
+            pubDate: "metadata.dataIdInfo.idCitation.date.pubDate",
+            createDate: "metadata.dataIdInfo.idCitation.date.createDate",
+            metadataUpdateFrequency: "metadata.mdMaint.maintFreq.MaintFreqCd.@_value",
+            metadataUpdatedDate: "metadata.mdDateSt",
+        };
+        return metadataPaths[identifier];
+    }
+    function getValueFromMetadata(metadata, identifier) {
+        var path = getMetadataPath(identifier);
+        return path && getProp(metadata, path);
+    }
+    var DatePrecision;
+    (function (DatePrecision) {
+        DatePrecision["Year"] = "year";
+        DatePrecision["Month"] = "month";
+        DatePrecision["Day"] = "day";
+        DatePrecision["Time"] = "time";
+    })(DatePrecision || (DatePrecision = {}));
+    /**
+     * Parses an ISO8601 date string into a date and a precision.
+     * This is because a) if somone entered 2018, we want to respect that and not treat it as the same as 2018-01-01
+     * and b) you cannot naively call new Date with an ISO 8601 string that does not include time information
+     * For example, when I, here in mountain time, do new Date('2018').getFullYear() I get "2017".
+     * This is because when you do not provide time or timezone info, UTC is assumed, so new Date('2018') is 2018-01-01T00:00:00 in UTC
+     * which is actually 7 hours earlier here in mountain time.
+     *
+     * @param {string} isoString
+     * @return { date: Date, precision: DatePrecision }
+     */
+    function parseISODateString(isoString) {
+        isoString = "" + isoString;
+        var date;
+        var precision;
+        if (/^\d{4}$/.test(isoString)) {
+            // yyyy
+            date = new Date(+isoString, 0, 1);
+            precision = DatePrecision.Year;
+        }
+        else if (/^\d{4}-\d{1,2}$/.test(isoString)) {
+            // yyyy-mm
+            var parts = isoString.split("-");
+            date = new Date(+parts[0], +parts[1] - 1, 1);
+            precision = DatePrecision.Month;
+        }
+        else if (/^\d{4}-\d{1,2}-\d{1,2}$/.test(isoString)) {
+            // yyyy-mm-dd
+            var parts = isoString.split("-");
+            date = new Date(+parts[0], +parts[1] - 1, +parts[2]);
+            precision = DatePrecision.Day;
+        }
+        else if (!Number.isNaN(Date.parse(isoString))) {
+            // any other string parsable to a valid date
+            date = new Date(isoString);
+            precision = isoString.includes("T")
+                ? DatePrecision.Time
+                : DatePrecision.Day;
+        }
+        return date && precision && { date: date, precision: precision };
+    }
+    var getServerSpatialReference = function (server, layer) {
+        var _a;
+        var layerSpatialReference = (_a = layer === null || layer === void 0 ? void 0 : layer.extent) === null || _a === void 0 ? void 0 : _a.spatialReference;
+        return layerSpatialReference || (server === null || server === void 0 ? void 0 : server.spatialReference);
+    };
+    // NOTE: IItem has spatialRefernce: ISpatialReference, but
+    // the portal REST API returns spatialReference as as string
+    // that is always either WKID like "102100" or
+    // WKT like "NAD_1983_HARN_StatePlane_Hawaii_3_FIPS_5103_Feet"
+    // so we coerce those string into a ISpatialReference object
+    var getItemSpatialReference = function (item) {
+        var spatialReference = item.spatialReference;
+        if (!spatialReference || typeof spatialReference === "object") {
+            // no need to try and transform this into an ISpatialReference
+            return spatialReference;
+        }
+        // otherwise it _should_ be a string (if coming form the REST API)
+        // but we force it in case it was set to a number somewhere outside of TS
+        var spatialReferenceString = spatialReference + "";
+        var wkid = parseInt(spatialReferenceString, 10);
+        return isNaN(wkid)
+            ? // string is not a number, assume it is WKT
+                { wkt: spatialReferenceString }
+            : //
+                { wkid: wkid };
+    };
+
+    /* Copyright (c) 2017-2019 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    var serviceRegex = new RegExp(/.+(?:map|feature|image)server/i);
+    /**
+     * Return the service url. If not matched, returns what was passed in
+     */
+    function parseServiceUrl(url) {
+        var match = url.match(serviceRegex);
+        if (match) {
+            return match[0];
+        }
+        else {
+            return stripQueryString(url);
+        }
+    }
+    function stripQueryString(url) {
+        var stripped = url.split('?')[0];
+        return cleanUrl(stripped);
+    }
+
     var STANDARD_LICENSES = [
         {
             type: "CC0-1.0",
@@ -6380,116 +6647,313 @@
     }
 
     /**
-     * Use this module for functions that do not need to be used by consumers (yet),
-     * but may be shared between hub.js modules, and/or need to be tested
-     * to get 100% coverage w/o writing cumbersome tests of higher level functions.
-     *
-     * Consuming will not be able to import these functions.
-     *
-     * It's probably a good pattern to add functions here first and then
-     * move them to index.ts only when they are needed by a consumer.
+     * Get the fully qualified URL for an item's thumbnail
+     * @param item w/ id, thumbnail, and access
+     * @param portalUrlOrObject a portal base or API URL, a portal object, or request options containing either of those
+     * @param optionsOrToken options including width and/or token for the current user's session; will only be appended as a query parameter if the item's access is **not** `public`
+     * @returns URL to the item's thumbnail, defaults to `https://www.arcgis.com/sharing/rest/content/items/{item.id}/info/{item.thumbnail}`. Returns `null` if the item does not have a thumbnail assigned.
      */
+    function getItemThumbnailUrl(item, portalUrlOrObject, optionsOrToken) {
+        if (!item || !item.thumbnail) {
+            // TODO: handle image types by returning the image (item data) itself?
+            return null;
+        }
+        // tslint:disable-next-line prefer-const
+        var _a = optionsOrToken || {}, token = _a.token, width = _a.width;
+        // TODO: at the next breaking change drop support for passing token as string
+        if (!token && typeof optionsOrToken === "string") {
+            token = optionsOrToken;
+        }
+        var itemApiUrl = getItemApiUrl(item, portalUrlOrObject, token);
+        var _b = itemApiUrl.split("?"), baseUrl = _b[0], search = _b[1];
+        var searchParams = new URLSearchParams(search);
+        searchParams.delete("f");
+        if (width) {
+            searchParams.append("w", width + "");
+        }
+        var newSearch = searchParams.toString();
+        var url = baseUrl + "/info/" + item.thumbnail;
+        return newSearch ? url + "?" + newSearch : url;
+    }
+
+    // helper fns - move this to _internal if needed elsewhere
+    var getOnlyQueryLayer = function (layers) {
+        var layer = layers && layers.length === 1 && layers[0];
+        return layer && layer.capabilities.includes("Query") && layer;
+    };
+    var shouldUseLayerInfo = function (layer, layers, url) {
+        return (layer &&
+            layers &&
+            layers.length > 1 &&
+            // we use item info instead of layer info for single layer items
+            !getLayerIdFromUrl(url));
+    };
     /**
-     * Create a new content with updated extent and derived properties like boundary
-     * @param content original content
-     * @param extent new extent
-     * @returns a new content with the updated extent and boundary
-     */
-    var setContentExtent = function (content, extent) {
-        // update content's item and extent
-        var item = __assign(__assign({}, content.item), { extent: extent });
-        var updated = __assign(__assign({}, content), { item: item, extent: extent });
-        // derive boundary from content properties
-        var boundary = getContentBoundary(updated);
-        return __assign(__assign({}, updated), { boundary: boundary });
+     * The possible values for updateFrequency
+     *
+     * @enum {string}
+     */
+    exports.UpdateFrequency = void 0;
+    (function (UpdateFrequency) {
+        UpdateFrequency["Continual"] = "continual";
+        UpdateFrequency["Daily"] = "daily";
+        UpdateFrequency["Weekly"] = "weekly";
+        UpdateFrequency["Fortnightly"] = "fortnightly";
+        UpdateFrequency["Monthly"] = "monthly";
+        UpdateFrequency["Quarterly"] = "quarterly";
+        UpdateFrequency["Biannually"] = "biannually";
+        UpdateFrequency["Annually"] = "annually";
+        UpdateFrequency["AsNeeded"] = "as-needed";
+        UpdateFrequency["Irregular"] = "irregular";
+        UpdateFrequency["NotPlanned"] = "not-planned";
+        UpdateFrequency["Unknown"] = "unknown";
+        UpdateFrequency["Semimonthly"] = "semimonthly";
+    })(exports.UpdateFrequency || (exports.UpdateFrequency = {}));
+    var getUpdateFrequencyFromMetadata = function (metadata, identifier) {
+        var updateFrequencyMap = {
+            "001": exports.UpdateFrequency.Continual,
+            "002": exports.UpdateFrequency.Daily,
+            "003": exports.UpdateFrequency.Weekly,
+            "004": exports.UpdateFrequency.Fortnightly,
+            "005": exports.UpdateFrequency.Monthly,
+            "006": exports.UpdateFrequency.Quarterly,
+            "007": exports.UpdateFrequency.Biannually,
+            "008": exports.UpdateFrequency.Annually,
+            "009": exports.UpdateFrequency.AsNeeded,
+            "010": exports.UpdateFrequency.Irregular,
+            "011": exports.UpdateFrequency.NotPlanned,
+            "012": exports.UpdateFrequency.Unknown,
+            "013": exports.UpdateFrequency.Semimonthly,
+        };
+        return updateFrequencyMap[getValueFromMetadata(metadata, identifier || "updateFrequency")];
     };
-    var getContentBoundary = function (content) {
-        var _a;
-        var item = content.item;
-        var extent = item.extent;
-        var isValidItemExtent = isBBox(extent);
-        // user specified provenance is stored in item.properties
-        var provenance = ((_a = item.properties) === null || _a === void 0 ? void 0 : _a.boundary) ||
-            // but we default to item if the item has an extent
-            (isValidItemExtent ? "item" : undefined);
-        var geometry;
-        switch (provenance) {
-            case "item":
-                geometry = isValidItemExtent ? bBoxToPolygon(extent) : null;
-                break;
-            case "none":
-                geometry = null;
-                break;
-            // TODO: handle other provenances
-        }
-        // TODO: derive and return center
+    var getDateInfoFromMetadata = function (metadata, identifier) {
+        var metadataDateInfo = parseISODateString(getValueFromMetadata(metadata, identifier));
+        return (metadataDateInfo && __assign(__assign({}, metadataDateInfo), { source: "metadata." + getMetadataPath(identifier) }));
+    };
+    var getLastEditDateInfo = function (content, layerOrServer) {
+        var source = layerOrServer + ".editingInfo.lastEditDate";
+        var lastEditDate = getProp(content, source);
+        return (lastEditDate && {
+            date: new Date(lastEditDate),
+            source: source,
+            // NOTE: this default was taken from _enrichDates
+            precision: DatePrecision.Day,
+        });
+    };
+    var getItemDateInfo = function (item, createdOrModified) {
         return {
-            provenance: provenance,
-            geometry: geometry,
+            date: new Date(item[createdOrModified]),
+            // NOTE: this was set to Day in _enrichDates()
+            // but I wonder if it should be Time instead?
+            precision: DatePrecision.Day,
+            source: "item." + createdOrModified,
         };
     };
-    var MAX_SIZE = 5000000;
-    /**
-     * Returns whether or not an item is a proxied csv
-     *
-     * @param item
-     * @param requestOptions Hub Request Options (including whether we're in portal)
-     * @returns
-     */
-    var isProxiedCSV = function (item, requestOptions) {
-        return !requestOptions.isPortal &&
-            item.access === "public" &&
-            item.type === "CSV" &&
-            item.size <= MAX_SIZE;
+    var getUpdatedDateInfo = function (item, options) {
+        return (
+        // prefer metadata revise date
+        getDateInfoFromMetadata(options.metadata, "reviseDate") ||
+            // then layer last edit date
+            getLastEditDateInfo(options, "layer") ||
+            // then server last edit date
+            getLastEditDateInfo(options, "server") ||
+            // fall back to item modified date
+            getItemDateInfo(item, "modified"));
     };
-
-    // private helper functions
-    function collectionToFamily(collection) {
-        var overrides = {
-            other: "content",
-            solution: "template",
-        };
-        return overrides[collection] || collection;
-    }
-    var cache = {};
-    // TODO: remove this at next breaking version
+    var getPublishedDateInfo = function (item, metadata) {
+        return (
+        // prefer metadata publish date
+        getDateInfoFromMetadata(metadata, "pubDate") ||
+            // then metadata create date
+            getDateInfoFromMetadata(metadata, "createDate") ||
+            // fall back to item created date
+            getItemDateInfo(item, "created"));
+    };
+    var getMetadataUpdatedDateInfo = function (item, metadata) {
+        // prefer date from metadata
+        return (getDateInfoFromMetadata(metadata, "metadataUpdatedDate") ||
+            // default to when the item was last modified
+            getItemDateInfo(item, "modified"));
+    };
+    // public API
     /**
-     * ```js
-     * import { getCategory } from "@esri/hub-common";
-     * //
-     * getCategory('Feature Layer')
-     * > 'dataset'
-     * ```
-     * **DEPRECATED: Use getCollection() instead**
-     * returns the Hub category for a given item type
-     * @param itemType The ArcGIS [item type](https://developers.arcgis.com/rest/users-groups-and-items/items-and-item-types.htm).
-     * @returns the category of a given item type.
+     * DEPRECATED: Compute the content type icon based on the content type
+     * @param content type
+     * @returns content type icon
      */
-    function getCategory(itemType) {
-        if (itemType === void 0) { itemType = ""; }
-        /* tslint:disable no-console */
-        console.warn("DEPRECATED: Use getCollection() instead. getCategory will be removed at v10.0.0");
-        /* tslint:enable no-console */
-        var collection = getCollection(itemType);
-        // for backwards compatibility
-        return collection === "feedback" ? "app" : collection;
-    }
-    /**
-     * ```js
-     * import { getTypes } from "@esri/hub-common";
-     * //
-     * getTypes('site')
-     * > [ 'hub site application' ]
-     * ```
-     * To do.
-     * @param category The ArcGIS Hub category.
-     * @returns all the item types for the given category.
-     *
+    var getContentTypeIcon = function (contentType) {
+        var _a;
+        var type = camelize(contentType || "");
+        var iconMap = {
+            appbuilderExtension: "file",
+            appbuilderWidgetPackage: "widgets-source",
+            application: "web",
+            applicationConfiguration: "app-gear",
+            arcgisProMap: "desktop",
+            cadDrawing: "file-cad",
+            cityEngineWebScene: "urban-model",
+            codeAttachment: "file-code",
+            codeSample: "file-code",
+            colorSet: "palette",
+            contentCategorySet: "label",
+            csv: "file-csv",
+            cSV: "file-csv",
+            cSVCollection: "file-csv",
+            dashboard: "dashboard",
+            desktopApplication: "desktop",
+            documentLink: "link",
+            excaliburImageryProject: "file",
+            explorerMap: "file",
+            exportPackage: "file",
+            featureCollection: "data",
+            featureCollectionTemplate: "file",
+            featureLayer: "data",
+            featureService: "collection",
+            fileGeodatabase: "data",
+            form: "survey",
+            geocodingService: "file",
+            geodataService: "file",
+            geometryService: "file",
+            geopackage: "file",
+            geoprocessingService: "file",
+            globeLayer: "layers",
+            globeService: "file",
+            hubInitiative: "initiative",
+            hubInitiativeTemplate: "initiative-template",
+            hubPage: "browser",
+            hubSiteApplication: "web",
+            image: "file-image",
+            imageService: "data",
+            insightsModel: "file",
+            insightsPage: "graph-moving-average",
+            insightsTheme: "palette",
+            insightsWorkbook: "graph-moving-average",
+            iWorkPages: "file-text",
+            iWorkKeynote: "presentation",
+            iWorkNumbers: "file-report",
+            kML: "data",
+            kMLCollection: "data",
+            layer: "layers",
+            layerPackage: "layers",
+            layerTemplate: "file",
+            locatorPackage: "file",
+            mapArea: "file",
+            mapDocument: "map-contents",
+            mapImageLayer: "collection",
+            mapPackage: "file",
+            mapService: "collection",
+            microsoftExcel: "file-report",
+            microsoftPowerpoint: "presentation",
+            microsoftWord: "file-text",
+            mission: "file",
+            mobileMapPackage: "map-contents",
+            nativeApplication: "mobile",
+            nativeApplicationInstaller: "file",
+            nativeApplicationTemplate: "file",
+            mobileApplication: "mobile",
+            networkAnalysisService: "file",
+            notebook: "code",
+            orientedImageryCatalog: "file",
+            orthoMappingProject: "file",
+            orthoMappingTemplate: "file",
+            pDF: "file-pdf",
+            quickCaptureProject: "mobile",
+            rasterFunctionTemplate: "file",
+            rasterLayer: "map",
+            realTimeAnalytic: "file",
+            relationalDatabaseConnection: "file",
+            reportTemplate: "file",
+            sceneLayer: "data",
+            sceneService: "urban-model",
+            serviceDefinition: "file",
+            shapefile: "data",
+            solution: "puzzle-piece",
+            sqliteGeodatabase: "file",
+            statisticalDataCollection: "file",
+            storymap: "tour",
+            storyMap: "tour",
+            storymapTheme: "palette",
+            symbolSet: "file",
+            table: "table",
+            urbanModel: "urban-model",
+            vectorTilePackage: "file-shape",
+            vectorTileService: "map",
+            visioDocument: "conditional-rules",
+            webExperience: "apps",
+            webMap: "map",
+            webMappingApplication: "apps",
+            webScene: "urban-model",
+            wfs: "map",
+            wFS: "map",
+            wMS: "map",
+            wMTS: "map",
+            workflowManagerService: "file",
+            workforceProject: "list-check",
+        };
+        return (_a = iconMap[type]) !== null && _a !== void 0 ? _a : "file";
+    };
+    /**
+     * get portal URLs (home, API, data, and thumbnail) for an item
+     *
+     * @param item Item
+     * @param requestOptions Request options
+     * @returns a hash with the portal URLs
+     * @export
      */
-    function getTypes(category) {
-        if (category === void 0) { category = ""; }
-        return categories[category.toLowerCase()];
-    }
+    var getPortalUrls = function (item, requestOptions) {
+        var authentication = requestOptions.authentication;
+        var token = authentication && authentication.token;
+        // add properties that depend on portal
+        var portalHome = getItemHomeUrl(item.id, requestOptions);
+        // the URL of the item's Portal API end point
+        var portalApi = getItemApiUrl(item, requestOptions, token);
+        // the URL of the item's data API end point
+        var portalData = getItemDataUrl(item, requestOptions, token);
+        // the full URL of the thumbnail
+        var thumbnail = getItemThumbnailUrl(item, requestOptions, {
+            token: token,
+        });
+        return {
+            portalHome: portalHome,
+            portalApi: portalApi,
+            portalData: portalData,
+            thumbnail: thumbnail,
+        };
+    };
+    /**
+     * If an item is a proxied csv, returns the url for the proxying feature layer.
+     * If the item is not a proxied csv, returns undefined.
+     *
+     * @param item
+     * @param requestOptions Hub Request Options (including whether we're in portal)
+     * @returns
+     */
+    var getProxyUrl = function (item, requestOptions) {
+        var result;
+        if (isProxiedCSV(item, requestOptions)) {
+            result = getHubApiUrl(requestOptions) + "/datasets/" + item.id + "_0/FeatureServer/0";
+        }
+        return result;
+    };
+    /**
+     * parse layer id from a service URL
+     * @param {string} url
+     * @returns {string} layer id
+     */
+    var getLayerIdFromUrl = function (url) {
+        var endsWithNumberSegmentRegEx = /\/\d+$/;
+        var matched = url && url.match(endsWithNumberSegmentRegEx);
+        return matched && matched[0].slice(1);
+    };
+    /**
+     * Case-insensitive check if the type is "Feature Service"
+     * @param {string} type - item's type
+     * @returns {boolean}
+     */
+    var isFeatureService = function (type) {
+        return type && type.toLowerCase() === "feature service";
+    };
     /**
      * ```js
      * import { normalizeItemType } from "@esri/hub-common";
@@ -6526,103 +6990,341 @@
         return ret;
     }
     /**
-     * ```js
-     * import { getTypeCategories } from "@esri/hub-common";
-     * //
-     * getTypeCategories(item)
-     * > [ 'Hub Site Application' ]
+     * return the layerId if we can tell that item is a single layer service
+     * @param {*} item from AGO
+     * @returns {string} layer id
+     */
+    var getItemLayerId = function (item) {
+        // try to parse it from the URL, but failing that we check for
+        // the Singlelayer typeKeyword, which I think is set when you create the item in AGO
+        // but have not verified that, nor that we should alway return '0' in that case
+        return (getLayerIdFromUrl(item.url) ||
+            (isFeatureService(item.type) &&
+                item.typeKeywords &&
+                includes(item.typeKeywords, "Singlelayer") &&
+                "0"));
+    };
+    /**
+     * given an item, get the id to use w/ the Hub API
+     * @param item
+     * @returns Hub API id (hubId)
+     */
+    var getItemHubId = function (item) {
+        if (item.access !== "public") {
+            // the hub only indexes public items
+            return;
+        }
+        var id = item.id;
+        var layerId = getItemLayerId(item);
+        return layerId ? id + "_" + layerId : id;
+    };
+    /**
+     * Splits item category strings at slashes and discards the "Categories" keyword
+     *
+     * ```
+     * ["/Categories/Boundaries", "/Categories/Planning and cadastre/Property records", "/Categories/Structure"]
+     * ```
+     * Should end up being
+     * ```
+     * ["Boundaries", "Planning and cadastre", "Property records", "Structure"]
      * ```
-     * @param item Item object.
-     * @returns typeCategory of the input item.
      *
+     * @param categories - an array of strings
+     * @private
      */
-    function getTypeCategories(item) {
-        if (item === void 0) { item = {}; }
-        var type = normalizeItemType(item);
-        var category = getCategory(type);
-        if (category) {
-            // upper case first letter and return as element in array for backwards compatibility
-            var chars = Array.from(category);
-            chars[0] = chars[0].toUpperCase();
-            return [chars.join("")];
-        }
-        else {
-            return ["Other"];
-        }
+    function parseItemCategories(categories) {
+        if (!categories)
+            return categories;
+        var exclude = ["categories", ""];
+        var parsed = categories.map(function (cat) { return cat.split("/"); });
+        var flattened = parsed.reduce(function (acc, arr, _) { return __spreadArrays(acc, arr); }, []);
+        return flattened.filter(function (cat) { return !includes(exclude, cat.toLowerCase()); });
     }
+    /**
+     * Compose a new content object out of an item, enrichments, and context
+     * @param item
+     * @param options any enrichments, current state (selected layerId), or context (requestOptions)
+     * @returns new content object
+     */
+    var composeContent = function (item, options) {
+        // extract enrichments and context out of the options
+        var _a = options || {}, slug = _a.slug, requestOptions = _a.requestOptions, data = _a.data, metadata = _a.metadata, groupIds = _a.groupIds, ownerUser = _a.ownerUser, org = _a.org, errors = _a.errors, server = _a.server, layers = _a.layers, recordCount = _a.recordCount, boundary = _a.boundary, statistics = _a.statistics;
+        // set common variables that we will use in the derived properties below
+        // if item refers to a layer we always want to use that layer id
+        // otherwise use the layer id that was passed in (if any)
+        var _layerIdFromUrl = getLayerIdFromUrl(item.url);
+        var layerId = _layerIdFromUrl
+            ? parseInt(_layerIdFromUrl, 10)
+            : options === null || options === void 0 ? void 0 : options.layerId;
+        var layer = layers &&
+            (!isNil(layerId)
+                ? // find the explicitly set layer id
+                    layers.find(function (_layer) { return _layer.id === layerId; })
+                : // for feature servers with a single layer always show the layer
+                    isFeatureService(item.type) && getOnlyQueryLayer(layers));
+        // NOTE: we only set hubId for public items in online
+        var _canUseHubApi = !isPortal(requestOptions) && item.access === "public";
+        var hubId = _canUseHubApi
+            ? layer
+                ? item.id + "_" + layer.id
+                : getItemHubId(item)
+            : undefined;
+        var identifier = slug || hubId || item.id;
+        // whether or not we should show layer info for name, description, etc
+        var _shouldUseLayerInfo = shouldUseLayerInfo(layer, layers, item.url);
+        var name = _shouldUseLayerInfo ? layer.name : item.title;
+        var _layerDescription = _shouldUseLayerInfo && layer.description;
+        // so much depends on type
+        var type = layer
+            ? // use layer type (Feature Layer, Table, etc) for layer content
+                layer.type
+            : // otherwise use the normalized item type
+                normalizeItemType(item);
+        // all the urls
+        var urls = __assign({ relative: getHubRelativeUrl(type, identifier, item.typeKeywords) }, (requestOptions && getPortalUrls(item, requestOptions)));
+        var _proxyUrl = getProxyUrl(item, requestOptions);
+        // NOTE: I'd rather not compute these date values up front,
+        // but they are used by several getters below, so we do it here only once
+        var _updatedDateInfo = getUpdatedDateInfo(item, {
+            metadata: metadata,
+            layer: layer,
+            server: server,
+        });
+        var _publishedDateInfo = getPublishedDateInfo(item, metadata);
+        var _metadataUpdatedDateInfo = getMetadataUpdatedDateInfo(item, metadata);
+        // return all of the above composed into a content object
+        return __assign(__assign({ 
+            // a reference to underlying item
+            item: item }, item), { 
+            // item enrichments
+            slug: slug,
+            data: data,
+            metadata: metadata,
+            groupIds: groupIds,
+            ownerUser: ownerUser,
+            org: org, errors: errors || [], 
+            // server enrichments
+            server: server,
+            layers: layers,
+            recordCount: recordCount,
+            // enrichments from the Hub API (boundary is below)
+            statistics: statistics,
+            // derived properties
+            // NOTE: in the getters below you can **not** use `this`
+            // these are not meant to provide live updating computed props
+            // their purpose is to avoid computing all these values above
+            // especially where we want to defer computation of less used props
+            hubId: hubId,
+            identifier: identifier, get isProxied() {
+                return !!_proxyUrl;
+            }, layer: layer,
+            name: name, get title() {
+                return name;
+            },
+            get description() {
+                return _layerDescription || item.description;
+            }, type: type, get family() {
+                return getFamily(type);
+            }, get url() {
+                return _proxyUrl
+                    ? _proxyUrl
+                    : _shouldUseLayerInfo
+                        ? parseServiceUrl(item.url) + "/" + layer.id
+                        : item.url;
+            }, get categories() {
+                return parseItemCategories(item.categories);
+            },
+            get actionLinks() {
+                return item.properties && item.properties.links;
+            },
+            get hubActions() {
+                return item.properties && item.properties.actions;
+            },
+            get isDownloadable() {
+                return isDownloadable(item);
+            },
+            get structuredLicense() {
+                return getStructuredLicense(item.licenseInfo);
+            },
+            get permissions() {
+                return {
+                    visibility: item.access,
+                    control: item.itemControl || "view",
+                };
+            },
+            get boundary() {
+                // TODO: need to be able to handle automatic w/ additional enrichment
+                // that could for example fetch the concave hull from the Hub API or resources
+                return boundary || getContentBoundary(item);
+            },
+            get summary() {
+                return _layerDescription
+                    ? _layerDescription
+                    : // TODO: this should use the logic for the Hub API's searchDescription
+                        // see: https://github.com/ArcGIS/hub-indexer/blob/b352cfded8221a967ac80447879d493db6476d7a/packages/duke/compose/dataset.js#L238-L250
+                        // TODO: can we strip HTML from description, and do we need to trim it to a X chars?
+                        item.snippet || item.description;
+            }, urls: urls, get portalHomeUrl() {
+                return urls.portalHome;
+            },
+            get portalDataUrl() {
+                return urls.portalData;
+            },
+            get portalApiUrl() {
+                return urls.portalApi;
+            },
+            get thumbnailUrl() {
+                return urls.thumbnail;
+            },
+            /** The date the item was created */
+            get createdDate() {
+                return new Date(item.created);
+            }, createdDateSource: "item.created", get updatedDate() {
+                return _updatedDateInfo.date;
+            },
+            get updatedDateSource() {
+                return _updatedDateInfo.source;
+            },
+            get updatedDatePrecision() {
+                return _updatedDateInfo.precision;
+            },
+            get modified() {
+                return _updatedDateInfo.date.getTime();
+            },
+            get publishedDate() {
+                return _publishedDateInfo.date;
+            },
+            get publishedDateSource() {
+                return _publishedDateInfo.source;
+            },
+            get publishedDatePrecision() {
+                return _publishedDateInfo.precision;
+            },
+            get metadataUpdatedDate() {
+                return _metadataUpdatedDateInfo.date;
+            },
+            get metadataUpdatedDateSource() {
+                return _metadataUpdatedDateInfo.source;
+            },
+            get metadataUpdatedDatePrecision() {
+                return _metadataUpdatedDateInfo.precision;
+            },
+            get updateFrequency() {
+                return getUpdateFrequencyFromMetadata(metadata);
+            },
+            get metadataUpdateFrequency() {
+                return getUpdateFrequencyFromMetadata(metadata, "metadataUpdateFrequency");
+            },
+            // TODO: add the publisher logic outlined here:
+            // https://devtopia.esri.com/dc/hub/issues/2932#issuecomment-3276309
+            get publisher() {
+                return {
+                    name: item.owner,
+                    username: item.owner,
+                };
+            },
+            // TODO: is metrics in use?
+            get metrics() {
+                return item.properties && item.properties.metrics;
+            },
+            get spatialReference() {
+                // NOTE: I had to add || null just so packages/content/test/portal.test.ts would pass
+                // we can remove that when that package is deprecated
+                return (getItemSpatialReference(item) ||
+                    getServerSpatialReference(server, layer) ||
+                    null);
+            },
+            get orgId() {
+                // NOTE: it's undocumented, but the portal API will return orgId for items... sometimes
+                return org ? org.id : item.orgId;
+            },
+            // deprecated properties
+            // TODO: should we add these in legacy wrappers
+            // like itemToContent or datasetToContent instead?
+            get contentTypeIcon() {
+                /* tslint:disable no-console */
+                console.warn(
+                /* tslint:enable no-console */
+                "DEPRECATED: it is now the responsibility of the consuming package to determine the icon");
+                return getContentTypeIcon(type);
+            },
+            get license() {
+                /* tslint:disable no-console */
+                console.warn("DEPRECATED: use structuredLicense instead");
+                /* tslint:enable no-console */
+                return { name: "Custom License", description: item.accessInformation };
+            },
+            get hubType() {
+                /* tslint:disable no-console */
+                console.warn("DEPRECATED: use family instead");
+                /* tslint:enable no-console */
+                return getFamily(type);
+            } });
+    };
+
+    // TODO: remove this at next breaking version
     /**
      * ```js
-     * import { getCollection } from "@esri/hub-common";
+     * import { getCategory } from "@esri/hub-common";
      * //
-     * getCollection('Feature Layer')
+     * getCategory('Feature Layer')
      * > 'dataset'
      * ```
-     * Get the Hub collection for a given item type
+     * **DEPRECATED: Use getCollection() instead**
+     * returns the Hub category for a given item type
      * @param itemType The ArcGIS [item type](https://developers.arcgis.com/rest/users-groups-and-items/items-and-item-types.htm).
-     * @returns the Hub collection of a given item type.
+     * @returns the category of a given item type.
      */
-    function getCollection(itemType) {
+    function getCategory(itemType) {
         if (itemType === void 0) { itemType = ""; }
-        if (cache[itemType]) {
-            return cache[itemType];
-        }
-        for (var _i = 0, _a = Object.keys(collections); _i < _a.length; _i++) {
-            var collection = _a[_i];
-            for (var _b = 0, _c = collections[collection]; _b < _c.length; _b++) {
-                var type = _c[_b];
-                if (itemType.toLowerCase() === type.toLowerCase()) {
-                    cache[itemType] = collection;
-                    return collection;
-                }
-            }
-        }
+        /* tslint:disable no-console */
+        console.warn("DEPRECATED: Use getCollection() instead. getCategory will be removed at v10.0.0");
+        /* tslint:enable no-console */
+        var collection = getCollection(itemType);
+        // for backwards compatibility
+        return collection === "feedback" ? "app" : collection;
     }
     /**
-     * Case-insensitive check if the type is "Feature Service"
-     * @param {string} type - item's type
-     * @returns {boolean}
-     */
-    var isFeatureService = function (type) {
-        return type && type.toLowerCase() === "feature service";
-    };
-    /**
-     * parse layer id from a service URL
-     * @param {string} url
-     * @returns {string} layer id
-     */
-    var getLayerIdFromUrl = function (url) {
-        var endsWithNumberSegmentRegEx = /\/\d+$/;
-        var matched = url && url.match(endsWithNumberSegmentRegEx);
-        return matched && matched[0].slice(1);
-    };
-    /**
-     * return the layerId if we can tell that item is a single layer service
-     * @param {*} item from AGO
-     * @returns {string} layer id
-     */
-    var getItemLayerId = function (item) {
-        // try to parse it from the URL, but failing that we check for
-        // the Singlelayer typeKeyword, which I think is set when you create the item in AGO
-        // but have not verified that, nor that we should alway return '0' in that case
-        return (getLayerIdFromUrl(item.url) ||
-            (isFeatureService(item.type) &&
-                includes(item.typeKeywords, "Singlelayer") &&
-                "0"));
-    };
+     * ```js
+     * import { getTypes } from "@esri/hub-common";
+     * //
+     * getTypes('site')
+     * > [ 'hub site application' ]
+     * ```
+     * To do.
+     * @param category The ArcGIS Hub category.
+     * @returns all the item types for the given category.
+     *
+     */
+    function getTypes(category) {
+        if (category === void 0) { category = ""; }
+        return categories[category.toLowerCase()];
+    }
     /**
-     * given an item, get the id to use w/ the Hub API
-     * @param item
-     * @returns Hub API id (hubId)
+     * ```js
+     * import { getTypeCategories } from "@esri/hub-common";
+     * //
+     * getTypeCategories(item)
+     * > [ 'Hub Site Application' ]
+     * ```
+     * @param item Item object.
+     * @returns typeCategory of the input item.
+     *
      */
-    var getItemHubId = function (item) {
-        if (item.access !== "public") {
-            // the hub only indexes public items
-            return;
+    function getTypeCategories(item) {
+        if (item === void 0) { item = {}; }
+        var type = normalizeItemType(item);
+        var category = getCategory(type);
+        if (category) {
+            // upper case first letter and return as element in array for backwards compatibility
+            var chars = Array.from(category);
+            chars[0] = chars[0].toUpperCase();
+            return [chars.join("")];
         }
-        var id = item.id;
-        var layerId = getItemLayerId(item);
-        return layerId ? id + "_" + layerId : id;
-    };
+        else {
+            return ["Other"];
+        }
+    }
     /**
      * ```js
      * import { getContentIdentifier } from "@esri/hub-common";
@@ -6652,7 +7354,7 @@
         // site data instead. Because this one is the original one that was used
         // to create the page url (not mutable once created) and the slug (below)
         // generated by the hub-indexer could simply change with page name.
-        if (isPageContent(content)) {
+        if (isPageType(content.type)) {
             // check if the page is linked to the current site
             var pages = getProp(site, "data.values.pages") || [];
             // if so, return the page slug otherwise the page id
@@ -6736,60 +7438,6 @@
             return slug;
         }
     }
-    /**
-     * Splits item category strings at slashes and discards the "Categories" keyword
-     *
-     * ```
-     * ["/Categories/Boundaries", "/Categories/Planning and cadastre/Property records", "/Categories/Structure"]
-     * ```
-     * Should end up being
-     * ```
-     * ["Boundaries", "Planning and cadastre", "Property records", "Structure"]
-     * ```
-     *
-     * @param categories - an array of strings
-     * @private
-     */
-    function parseItemCategories(categories) {
-        if (!categories)
-            return categories;
-        var exclude = ["categories", ""];
-        var parsed = categories.map(function (cat) { return cat.split("/"); });
-        var flattened = parsed.reduce(function (acc, arr, _) { return __spreadArrays(acc, arr); }, []);
-        return flattened.filter(function (cat) { return !includes(exclude, cat.toLowerCase()); });
-    }
-    /**
-     * return the Hub family given an item's type
-     * @param type item type
-     * @returns Hub family
-     */
-    function getFamily(type) {
-        var family;
-        // override default behavior for the rows that are highlighted in yellow here:
-        // https://esriis.sharepoint.com/:x:/r/sites/ArcGISHub/_layouts/15/Doc.aspx?sourcedoc=%7BADA1C9DC-4F6C-4DE4-92C6-693EF9571CFA%7D&file=Hub%20Routes.xlsx&nav=MTBfe0VENEREQzI4LUZFMDctNEI0Ri04NjcyLThCQUE2MTA0MEZGRn1fezIwMTIwMEJFLTA4MEQtNEExRC05QzA4LTE5MTAzOUQwMEE1RH0&action=default&mobileredirect=true&cid=df1c874b-c367-4cea-bc13-7bebfad3f2ac
-        switch ((type || "").toLowerCase()) {
-            case "image service":
-                family = "dataset";
-                break;
-            case "feature service":
-            case "raster layer":
-                // TODO: check if feature service has > 1 layer first?
-                family = "map";
-                break;
-            case "microsoft excel":
-                family = "document";
-                break;
-            case "cad drawing":
-            case "feature collection template":
-            case "report template":
-                family = "content";
-                break;
-            default:
-                // by default derive from collection
-                family = collectionToFamily(getCollection(type));
-        }
-        return family;
-    }
     /**
      * DEPRECATED: Use getFamily() instead.
      *
@@ -6816,51 +7464,7 @@
      * @export
      */
     function itemToContent(item) {
-        var createdDate = new Date(item.created);
-        var createdDateSource = "item.created";
-        var properties = item.properties;
-        var content = Object.assign({}, item, {
-            identifier: item.id,
-            // no server errors when fetching the item directly
-            errors: [],
-            // store a reference to the item
-            item: item,
-            // NOTE: this will overwrite any existing item.name, which is
-            // The file name of the item for file types. Read-only.
-            // presumably there to use as the default file name when downloading
-            // we don't store item.name in the Hub API and we use name for title
-            name: item.title,
-            // TODO: hubType is no longer used, remove it at next breaking change
-            hubType: getItemHubType(item),
-            categories: parseItemCategories(item.categories),
-            itemCategories: item.categories,
-            // can we strip HTML from description, and do we need to trim it to a X chars?
-            summary: item.snippet || item.description,
-            publisher: {
-                name: item.owner,
-                username: item.owner,
-            },
-            permissions: {
-                visibility: item.access,
-                control: item.itemControl || "view",
-            },
-            // Hub app configuration metadata from item properties
-            actionLinks: properties && properties.links,
-            hubActions: properties && properties.actions,
-            metrics: properties && properties.metrics,
-            isDownloadable: isDownloadable(item),
-            // default boundary from item.extent
-            license: { name: "Custom License", description: item.accessInformation },
-            // dates and sources we will enrich these later...
-            createdDate: createdDate,
-            createdDateSource: createdDateSource,
-            publishedDate: createdDate,
-            publishedDateSource: createdDateSource,
-            updatedDate: new Date(item.modified),
-            updatedDateSource: "item.modified",
-            structuredLicense: getStructuredLicense(item.licenseInfo),
-        });
-        return setContentExtent(setContentType(content, item.type), item.extent);
+        return composeContent(item);
     }
     /**
      * Convert a Hub API dataset resource to Hub Content
@@ -6872,76 +7476,43 @@
     function datasetToContent(dataset) {
         // extract item from dataset, create content from the item
         var item = datasetToItem(dataset);
-        var content = itemToContent(item);
-        // We remove these because the indexer doesn't actually
-        // preserve the original item categories so this attribute is invalid
-        delete content.itemCategories;
-        // overwrite or add enrichments from Hub API
-        var hubId = dataset.id, attributes = dataset.attributes;
-        var 
-        // common enrichments
-        errors = attributes.errors, boundary = attributes.boundary, extent = attributes.extent, metadata = attributes.metadata, modified = attributes.modified, modifiedProvenance = attributes.modifiedProvenance, slug = attributes.slug, searchDescription = attributes.searchDescription, groupIds = attributes.groupIds, 
+        // extract enrichments from attributes
+        var _a = dataset.attributes, 
+        // item enrichments
+        errors = _a.errors, boundary = _a.boundary, metadata = _a.metadata, slug = _a.slug, groupIds = _a.groupIds, orgId = _a.orgId, orgName = _a.orgName, organization = _a.organization, orgExtent = _a.orgExtent, 
         // map and feature server enrichments
-        server = attributes.server, layers = attributes.layers, 
-        // NOTE: the Hub API also returns the following server properties
-        // but we should be able to get them from the above server object
-        // currentVersion, capabilities, tileInfo, serviceSpatialReference
-        // maxRecordCount, supportedQueryFormats, etc
-        // feature and raster layer enrichments
-        layer = attributes.layer, recordCount = attributes.recordCount, statistics = attributes.statistics, 
-        // NOTE: the Hub API also returns the following layer properties
-        // but we should be able to get them from the above layer object
-        // supportedQueryFormats, supportsAdvancedQueries, advancedQueryCapabilities, useStandardizedQueries
-        // geometryType, objectIdField, displayField, fields,
-        // org properties?
-        orgId = attributes.orgId, orgName = attributes.orgName, organization = attributes.organization, orgExtent = attributes.orgExtent, 
-        // NOTE: for layers and tables the Hub API returns the layer type
-        // ("Feature Layer", "Table", "Raster Layer") instead of the item type
-        type = attributes.type;
-        // NOTE: we could throw or return if there are errors
-        // to prevent type errors trying to read properties below
-        content.errors = errors;
-        // common enrichments
-        content.boundary = boundary;
-        if (!isBBox(item.extent) && extent && isBBox(extent.coordinates)) {
-            // we fall back to the extent derived by the API
-            // which prefers layer or service extents and ultimately
-            // falls back to the org's extent
-            content.extent = extent.coordinates;
-        }
-        // setting this to null signals to enrichMetadata to skip this
-        content.metadata = metadata || null;
-        if (content.modified !== modified) {
-            // capture the enriched modified date
-            // NOTE: the item modified date is still available on content.item.modified
-            content.modified = modified;
-            content.updatedDate = new Date(modified);
-            content.updatedDateSource = modifiedProvenance;
-        }
-        content.slug = slug;
+        server = _a.server, layers = _a.layers, layer = _a.layer, recordCount = _a.recordCount, statistics = _a.statistics, 
+        // additional attributes needed
+        searchDescription = _a.searchDescription;
+        // get the layerId from the layer
+        var layerId = layer && layer.id;
+        // re-assemble the org as an enrichment
+        var org = orgId && {
+            id: orgId,
+            name: orgName || organization,
+            extent: orgExtent,
+        };
+        // compose a content out of the above
+        var content = composeContent(item, {
+            layerId: layerId,
+            slug: slug,
+            errors: errors,
+            // setting this to null signals to enrichMetadata to skip this
+            metadata: metadata || null,
+            groupIds: groupIds,
+            org: org,
+            server: server,
+            layers: layers,
+            recordCount: recordCount,
+            boundary: boundary,
+            statistics: statistics,
+        });
+        // TODO: need to add searchDescription logic to composeContent()
         if (searchDescription) {
             // overwrite default summary (from snippet) w/ search description
             content.summary = searchDescription;
         }
-        content.groupIds = groupIds;
-        // server enrichments
-        content.server = server;
-        content.layers = layers;
-        // layer enrichments
-        content.layer = layer;
-        content.recordCount = recordCount;
-        content.statistics = statistics;
-        // org enrichments
-        if (orgId) {
-            content.org = {
-                id: orgId,
-                name: orgName || organization,
-                extent: orgExtent,
-            };
-        }
-        // return a content with updated hubId and type
-        // along w/ related properties like identifier, family, etc
-        return setContentType(setContentHubId(content, hubId), type);
+        return content;
     }
     /**
      * Convert a Hub API dataset resource to a portal item
@@ -7027,166 +7598,50 @@
             culture: culture,
             url: url,
             access: access,
-            size: size,
-            protected: isProtected,
-            proxyFilter: proxyFilter,
-            properties: properties,
-            appCategories: appCategories,
-            industries: industries,
-            languages: languages,
-            largeThumbnail: largeThumbnail,
-            banner: banner,
-            screenshots: screenshots,
-            listed: listed,
-            ownerFolder: ownerFolder,
-            commentsEnabled: commentsEnabled,
-            numComments: numComments,
-            numRatings: numRatings,
-            avgRating: avgRating,
-            numViews: numViews,
-            itemControl: itemControl,
-            scoreCompleteness: scoreCompleteness,
-        };
-    }
-    /**
-     * returns a new content that has the specified type and
-     * and updated related properties like, family, etc
-     * @param content orignal content
-     * @param type new type
-     * @returns new content
-     */
-    var setContentType = function (content, type) {
-        // get family and normalized type based on new type
-        var normalizedType = normalizeItemType(__assign(__assign({}, content.item), { type: type }));
-        var family = getFamily(normalizedType);
-        var contentTypeIcon = getContentTypeIcon(normalizedType);
-        var contentTypeLabel = getContentTypeLabel(normalizedType, content.isProxied);
-        var updated = __assign(__assign({}, content), { type: normalizedType, family: family,
-            // TODO: remove this at next breaking change now that it has been deprecated
-            normalizedType: normalizedType,
-            contentTypeIcon: contentTypeIcon,
-            contentTypeLabel: contentTypeLabel });
-        // update the relative URL to the content
-        // which is based on type and family
-        return appendContentUrls(updated, {
-            relative: getContentRelativeUrl(updated),
-        });
-    };
-    /**
-     * Compute the content type icon based on the content type
-     * @param content type
-     * @returns content type icon
-     */
-    var getContentTypeIcon = function (contentType) {
-        var _a;
-        var type = camelize(contentType || "");
-        var iconMap = {
-            appbuilderExtension: "file",
-            appbuilderWidgetPackage: "widgets-source",
-            application: "web",
-            applicationConfiguration: "app-gear",
-            arcgisProMap: "desktop",
-            cadDrawing: "file-cad",
-            cityEngineWebScene: "urban-model",
-            codeAttachment: "file-code",
-            codeSample: "file-code",
-            colorSet: "palette",
-            contentCategorySet: "label",
-            csv: "file-csv",
-            cSV: "file-csv",
-            cSVCollection: "file-csv",
-            dashboard: "dashboard",
-            desktopApplication: "desktop",
-            documentLink: "link",
-            excaliburImageryProject: "file",
-            explorerMap: "file",
-            exportPackage: "file",
-            featureCollection: "data",
-            featureCollectionTemplate: "file",
-            featureLayer: "data",
-            featureService: "collection",
-            fileGeodatabase: "data",
-            form: "survey",
-            geocodingService: "file",
-            geodataService: "file",
-            geometryService: "file",
-            geopackage: "file",
-            geoprocessingService: "file",
-            globeLayer: "layers",
-            globeService: "file",
-            hubInitiative: "initiative",
-            hubInitiativeTemplate: "initiative-template",
-            hubPage: "browser",
-            hubSiteApplication: "web",
-            image: "file-image",
-            imageService: "data",
-            insightsModel: "file",
-            insightsPage: "graph-moving-average",
-            insightsTheme: "palette",
-            insightsWorkbook: "graph-moving-average",
-            iWorkPages: "file-text",
-            iWorkKeynote: "presentation",
-            iWorkNumbers: "file-report",
-            kML: "data",
-            kMLCollection: "data",
-            layer: "layers",
-            layerPackage: "layers",
-            layerTemplate: "file",
-            locatorPackage: "file",
-            mapArea: "file",
-            mapDocument: "map-contents",
-            mapImageLayer: "collection",
-            mapPackage: "file",
-            mapService: "collection",
-            microsoftExcel: "file-report",
-            microsoftPowerpoint: "presentation",
-            microsoftWord: "file-text",
-            mission: "file",
-            mobileMapPackage: "map-contents",
-            nativeApplication: "mobile",
-            nativeApplicationInstaller: "file",
-            nativeApplicationTemplate: "file",
-            mobileApplication: "mobile",
-            networkAnalysisService: "file",
-            notebook: "code",
-            orientedImageryCatalog: "file",
-            orthoMappingProject: "file",
-            orthoMappingTemplate: "file",
-            pDF: "file-pdf",
-            quickCaptureProject: "mobile",
-            rasterFunctionTemplate: "file",
-            rasterLayer: "map",
-            realTimeAnalytic: "file",
-            relationalDatabaseConnection: "file",
-            reportTemplate: "file",
-            sceneLayer: "data",
-            sceneService: "urban-model",
-            serviceDefinition: "file",
-            shapefile: "data",
-            solution: "puzzle-piece",
-            sqliteGeodatabase: "file",
-            statisticalDataCollection: "file",
-            storymap: "tour",
-            storyMap: "tour",
-            storymapTheme: "palette",
-            symbolSet: "file",
-            table: "table",
-            urbanModel: "urban-model",
-            vectorTilePackage: "file-shape",
-            vectorTileService: "map",
-            visioDocument: "conditional-rules",
-            webExperience: "apps",
-            webMap: "map",
-            webMappingApplication: "apps",
-            webScene: "urban-model",
-            wfs: "map",
-            wFS: "map",
-            wMS: "map",
-            wMTS: "map",
-            workflowManagerService: "file",
-            workforceProject: "list-check",
+            size: size,
+            protected: isProtected,
+            proxyFilter: proxyFilter,
+            properties: properties,
+            appCategories: appCategories,
+            industries: industries,
+            languages: languages,
+            largeThumbnail: largeThumbnail,
+            banner: banner,
+            screenshots: screenshots,
+            listed: listed,
+            ownerFolder: ownerFolder,
+            commentsEnabled: commentsEnabled,
+            numComments: numComments,
+            numRatings: numRatings,
+            avgRating: avgRating,
+            numViews: numViews,
+            itemControl: itemControl,
+            scoreCompleteness: scoreCompleteness,
         };
-        return (_a = iconMap[type]) !== null && _a !== void 0 ? _a : "file";
+    }
+    /**
+     * returns a new content that has the specified type and
+     * and updated related properties like, family, etc
+     * @param content orignal content
+     * @param type new type
+     * @returns new content
+     */
+    var setContentType = function (content, type) {
+        // get family and normalized type based on new type
+        var normalizedType = normalizeItemType(__assign(__assign({}, content.item), { type: type }));
+        var family = getFamily(normalizedType);
+        var contentTypeIcon = getContentTypeIcon(normalizedType);
+        var contentTypeLabel = getContentTypeLabel(normalizedType, content.isProxied);
+        var updated = __assign(__assign({}, content), { type: normalizedType, family: family,
+            // TODO: remove this at next breaking change now that it has been deprecated
+            normalizedType: normalizedType,
+            contentTypeIcon: contentTypeIcon,
+            contentTypeLabel: contentTypeLabel });
+        // update the relative URL to the content
+        // which is based on type and family
+        return appendContentUrls(updated, {
+            relative: getContentRelativeUrl(updated),
+        });
     };
     /**
      * Compute the content type label
@@ -7252,78 +7707,7 @@
         return __assign(__assign({}, content), { urls: urls });
     };
     var getContentRelativeUrl = function (content, siteIdentifier) {
-        var family = content.family;
-        // prefer site specific identifier if passed in
-        var identifier = siteIdentifier || content.identifier;
-        // solution types have their own logic
-        var contentUrl = getSolutionUrl(content);
-        if (!contentUrl) {
-            var pluralizedFamilies = [
-                "app",
-                "dataset",
-                "document",
-                "map",
-                "template",
-            ];
-            // default to the catchall content route
-            var path = "/content";
-            if (content.family === "feedback") {
-                // exception
-                path = "/feedback/surveys";
-            }
-            else if (isPageContent(content)) {
-                // pages are in the document family,
-                // but instead of showing the page's metadata on /documents/about
-                // but we render the page on the pages route
-                path = "/pages";
-            }
-            else if (pluralizedFamilies.indexOf(family) > -1) {
-                // the rule
-                path = "/" + family + "s";
-            }
-            contentUrl = path + "/" + identifier;
-        }
-        return contentUrl;
-    };
-    var getSolutionUrl = function (content) {
-        var _a;
-        var hubUrl;
-        var type = content.type, identifier = content.identifier;
-        if (type === "Solution") {
-            // NOTE: as per the above spreadsheet,
-            // solution types are now in the Template family
-            // but we don't send them to the route for initiative templates
-            if (((_a = content.typeKeywords) === null || _a === void 0 ? void 0 : _a.indexOf("Deployed")) > 0) {
-                // deployed solutions go to the generic content route
-                hubUrl = "/content/" + identifier;
-            }
-            // others go to the solution about route
-            hubUrl = "/templates/" + identifier + "/about";
-        }
-        return hubUrl;
-    };
-    // page helpers
-    // TODO: we check both "Hub Page" and "Site Page" because we don't know whether the site is a portal or not
-    // In the future, the site object will have a site.isPortal() function that we can leverage
-    // instead of hardcoding the types here.
-    var isPageContent = function (content) {
-        return includes(["Hub Page", "Site Page"], content.type);
-    };
-    // proxied csv helpers
-    /**
-     * If an item is a proxied csv, returns the url for the proxying feature layer.
-     * If the item is not a proxied csv, returns undefined.
-     *
-     * @param item
-     * @param requestOptions Hub Request Options (including whether we're in portal)
-     * @returns
-     */
-    var getProxyUrl = function (item, requestOptions) {
-        var result;
-        if (isProxiedCSV(item, requestOptions)) {
-            result = requestOptions.hubApiUrl + "/datasets/" + item.id + "_0/FeatureServer/0";
-        }
-        return result;
+        return getHubRelativeUrl(content.type, siteIdentifier || content.identifier, content.typeKeywords);
     };
 
     /**
@@ -8275,6 +8659,28 @@
             return clone;
         });
     }
+    /**
+     * Given an Item, fetch the data json and return an IModel
+     * @param item
+     * @param requestOptions
+     * @returns
+     */
+    function fetchModelFromItem(item, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getItemData(item.id, requestOptions)];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, {
+                                item: item,
+                                data: data,
+                            }];
+                }
+            });
+        });
+    }
 
     /**
      * To streamline passing of either a model id or the model itself, we use this function
@@ -9049,19 +9455,43 @@
      * @returns
      */
     function getItemBySlug(slug, requestOptions) {
+        return findItemsBySlug({ slug: slug }, requestOptions).then(function (results) {
+            if (results.length) {
+                return results[0];
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    /**
+     * Find items by slug typeKeywords.
+     *
+     * Optional exclude parameter accepts the id of an item we expect to
+     * have this particular slug. This is used during update calls
+     * where we don't know if the slug specifically has been updated, but we
+     * don't want a false-postive from the item we are updating
+     *
+     * @param slug
+     * @param requestOptions
+     * @returns
+     */
+    function findItemsBySlug(slugInfo, requestOptions) {
         var opts = {
             q: "",
-            filter: "typekeywords:\"slug|" + slug + "\"",
+            filter: "typekeywords:\"slug|" + slugInfo.slug + "\"",
             authentication: requestOptions.authentication,
         };
+        // We need to check for other items w/ a slug during
+        // the update calls. For those scenarios we are interested
+        // in any _other_ items which may have a specific slug
+        // but not one specific item
+        if (slugInfo.exclude) {
+            opts.q = "NOT id:" + slugInfo.exclude;
+        }
         return searchItems(opts)
             .then(function (response) {
-            if (response.results.length) {
-                return response.results[0];
-            }
-            else {
-                return null;
-            }
+            return response.results;
         })
             .catch(function (e) {
             throw Error("Error in getItemBySlug " + e);
@@ -9079,20 +9509,20 @@
      * @param step
      * @returns
      */
-    function getUniqueSlug(slug, requestOptions, step) {
+    function getUniqueSlug(slugInfo, requestOptions, step) {
         if (step === void 0) { step = 0; }
-        var combined = slug;
+        var combinedSlug = slugInfo.slug;
         if (step) {
-            combined = slug + "-" + step;
+            combinedSlug = slugInfo.slug + "-" + step;
         }
-        return getItemBySlug(combined, requestOptions)
-            .then(function (result) {
-            if (result) {
+        return findItemsBySlug({ slug: combinedSlug, exclude: slugInfo.existingId }, requestOptions)
+            .then(function (results) {
+            if (results.length) {
                 step++;
-                return getUniqueSlug(slug, requestOptions, step);
+                return getUniqueSlug(slugInfo, requestOptions, step);
             }
             else {
-                return combined;
+                return combinedSlug;
             }
         })
             .catch(function (e) {
@@ -9143,6 +9573,48 @@
         return template;
     }
 
+    /**
+     * Upload a file to be used as the thumbnail for an item
+     * @param id
+     * @param file
+     * @param filename
+     * @param requestOptions
+     */
+    function setItemThumbnail(id, file, filename, requestOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var opts, response, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        opts = __assign({ item: {
+                                id: id,
+                            }, params: {
+                                thumbnail: file,
+                            }, filename: filename }, requestOptions);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, updateItem(opts)];
+                    case 2:
+                        response = _a.sent();
+                        if (!response.success) {
+                            throw new HubError("Set Project Thumbnail", "Unknown error setting thumbnail.");
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        if (err_1 instanceof Error) {
+                            throw new HubError("Set Project Thumbnail", err_1.message, err_1);
+                        }
+                        else {
+                            throw new HubError("Set Project Thumbnail", "Unknown error setting thumbnail.");
+                        }
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    }
+
     /**
      * Manage forward and backward property mappings to
      * streamline conversion between the Hub entities, and
@@ -9246,6 +9718,7 @@
         name: "No title provided",
         tags: [],
         typeKeywords: ["IHubProject", "HubProject"],
+        status: "inactive",
     };
     /**
      * Default values for a new HubProject Model
@@ -9257,7 +9730,7 @@
             description: "No Description Provided",
             snippet: "",
             tags: [],
-            typeKeywords: [],
+            typeKeywords: ["Hub Project"],
             properties: {
                 slug: "",
             },
@@ -9265,7 +9738,6 @@
         data: {
             display: "about",
             timeline: {},
-            org: {},
             status: "inactive",
             contacts: [],
             schemaVersion: 1,
@@ -9346,7 +9818,7 @@
                         }
                         // Ensure slug is  unique
                         _a = project;
-                        return [4 /*yield*/, getUniqueSlug(project.slug, requestOptions)];
+                        return [4 /*yield*/, getUniqueSlug({ slug: project.slug }, requestOptions)];
                     case 1:
                         // Ensure slug is  unique
                         _a.slug = _b.sent();
@@ -9376,15 +9848,11 @@
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        // verify that the slug is unique
-                        // TODO: if the slug has not changed, we don't want to do this because
-                        // the existing item will cause this to increment
+                        // verify that the slug is unique, excluding the current project
                         _a = project;
-                        return [4 /*yield*/, getUniqueSlug(project.slug, requestOptions)];
+                        return [4 /*yield*/, getUniqueSlug({ slug: project.slug, existingId: project.id }, requestOptions)];
                     case 1:
-                        // verify that the slug is unique
-                        // TODO: if the slug has not changed, we don't want to do this because
-                        // the existing item will cause this to increment
+                        // verify that the slug is unique, excluding the current project
                         _a.slug = _b.sent();
                         return [4 /*yield*/, getModel(project.id, requestOptions)];
                     case 2:
@@ -9407,7 +9875,7 @@
      * @param identifier item id or slug
      * @param requestOptions
      */
-    function getProject(identifier, requestOptions) {
+    function fetchProject(identifier, requestOptions) {
         var getPrms;
         if (isGuid(identifier)) {
             // get item by id
@@ -9415,12 +9883,20 @@
         }
         else {
             // search for item using filter=typekeywords:slug|identifier
+            // although we could leverage searchProjects with an appropriate filter
+            // getModelBySlug is a generalized function that works for any type
             getPrms = getModelBySlug(identifier, requestOptions);
         }
         return getPrms.then(function (model) {
             // transform the model into a HubProject
             var mapper = new PropertyMapper(getProjectPropertyMap());
             var project = mapper.modelToObject(model, {});
+            var token;
+            if (requestOptions.authentication) {
+                var us = requestOptions.authentication;
+                token = us.token;
+            }
+            project.thumbnailUrl = getItemThumbnailUrl(model.item, requestOptions, token);
             return project;
         });
     }
@@ -9448,13 +9924,88 @@
     // i.e. delegate to searchContent or just do an item search
     // and convert to IHubProject objects.
     //
-    // export async function searchProjects(
-    //   filter: Filter<"content">,
-    //   opts: IHubSearchOptions
-    // ): Promise<ISearchResponse<IHubProject>> {
-    //   return _searchContent(filter, opts).then((results) => {
-    //   })
-    // }
+    function searchProjects(filter, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var scopingFilter, projectFilter, expanded, so;
+            return __generator(this, function (_b) {
+                scopingFilter = {
+                    filterType: "content",
+                    typekeywords: {
+                        exact: ["HubProject"],
+                    },
+                };
+                projectFilter = mergeContentFilter([scopingFilter, filter]);
+                expanded = expandContentFilter(projectFilter);
+                so = serializeContentFilterForPortal(expanded);
+                // Aggregations
+                if ((_a = options.aggregations) === null || _a === void 0 ? void 0 : _a.length) {
+                    so.countFields = options.aggregations.join(",");
+                    so.countSize = 200;
+                }
+                // copy over various options
+                if (options.num) {
+                    so.num = options.num;
+                }
+                if (options.sortField) {
+                    so.sortField = options.sortField;
+                }
+                if (options.sortOrder) {
+                    so.sortOrder = options.sortOrder;
+                }
+                if (options.site) {
+                    so.site = cloneObject$1(options.site);
+                }
+                if (options.authentication) {
+                    so.authentication = options.authentication;
+                }
+                return [2 /*return*/, searchPortalProjects(so)];
+            });
+        });
+    }
+    /**
+     * Internal fn that takes
+     * @param searchOptions
+     * @returns
+     */
+    function searchPortalProjects(searchOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, hasNext, modelPromises, models, mapper, token, us, projects;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, searchItems(searchOptions)];
+                    case 1:
+                        response = _a.sent();
+                        hasNext = response.nextStart > -1;
+                        modelPromises = response.results.map(function (itm) {
+                            return fetchModelFromItem(itm, {
+                                authentication: searchOptions.authentication,
+                            });
+                        });
+                        return [4 /*yield*/, Promise.all(modelPromises)];
+                    case 2:
+                        models = _a.sent();
+                        mapper = new PropertyMapper(getProjectPropertyMap());
+                        if (searchOptions.authentication) {
+                            us = searchOptions.authentication;
+                            token = us.token;
+                        }
+                        projects = models.map(function (m) {
+                            var prj = mapper.modelToObject(m, {});
+                            prj.thumbnailUrl = getItemThumbnailUrl(m.item, { authentication: searchOptions.authentication }, token);
+                            return prj;
+                        });
+                        return [2 /*return*/, {
+                                total: response.total,
+                                results: projects,
+                                facets: [],
+                                hasNext: hasNext,
+                                next: getNextFunction(searchOptions, response.nextStart, response.total, searchPortalProjects),
+                            }];
+                }
+            });
+        });
+    }
 
     /**
      * Centralized functions used to manage IHubProject instances
@@ -9563,6 +10114,18 @@
                 });
             });
         };
+        // DEPRECATED IN FAVOR OF .fetch()
+        // TODO: REMOVE AT NEXT MAJOR
+        /* istanbul ignore next */
+        HubProjectManager.prototype.get = function (identifier, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    // tslint:disable-next-line
+                    console.warn("HubProjectManager.get is deprecated and will be removed. Use .fetch() instead.");
+                    return [2 /*return*/, this.fetch(identifier, requestOptions)];
+                });
+            });
+        };
         /**
          * Fetch a Project via id or it's slug
          *
@@ -9577,10 +10140,51 @@
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     if (requestOptions || this.context.requestOptions) {
-                        return [2 /*return*/, getProject(identifier, requestOptions || this.context.requestOptions)];
+                        return [2 /*return*/, fetchProject(identifier, requestOptions || this.context.requestOptions)];
                     }
                     else {
-                        throw new HubError("Get Project", "Can not retrieve context.requestOptions from Context Manager. HubProjectManager is configured incorrectly.");
+                        throw new HubError("Fetch Project", "Can not retrieve context.requestOptions from Context Manager. HubProjectManager is configured incorrectly.");
+                    }
+                });
+            });
+        };
+        /**
+         * Search for Projects
+         *
+         * @param filter
+         * @param options
+         */
+        HubProjectManager.prototype.search = function (filter, options) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    // if we were not passed auth, and we have a session, use it
+                    if (!options.authentication && this.context.session) {
+                        options.authentication = this.context.session;
+                    }
+                    return [2 /*return*/, searchProjects(filter, options)];
+                });
+            });
+        };
+        /**
+         * Set the thumbnail for the Project
+         * @param id
+         * @param file
+         * @param filename
+         * @param requestOptions
+         * @returns
+         */
+        HubProjectManager.prototype.updateThumbnail = function (project, file, filename, requestOptions) {
+            return __awaiter(this, void 0, void 0, function () {
+                var ro;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            ro = requestOptions || this.context.userRequestOptions;
+                            return [4 /*yield*/, setItemThumbnail(project.id, file, filename, ro)];
+                        case 1:
+                            _a.sent();
+                            // get the item so we have updated props and timestamps
+                            return [2 /*return*/, this.fetch(project.id, requestOptions)];
                     }
                 });
             });
@@ -9771,36 +10375,6 @@
         });
     }
 
-    /**
-     * Get the fully qualified URL for an item's thumbnail
-     * @param item w/ id, thumbnail, and access
-     * @param portalUrlOrObject a portal base or API URL, a portal object, or request options containing either of those
-     * @param optionsOrToken options including width and/or token for the current user's session; will only be appended as a query parameter if the item's access is **not** `public`
-     * @returns URL to the item's thumbnail, defaults to `https://www.arcgis.com/sharing/rest/content/items/{item.id}/info/{item.thumbnail}`. Returns `null` if the item does not have a thumbnail assigned.
-     */
-    function getItemThumbnailUrl(item, portalUrlOrObject, optionsOrToken) {
-        if (!item || !item.thumbnail) {
-            // TODO: handle image types by returning the image (item data) itself?
-            return null;
-        }
-        // tslint:disable-next-line prefer-const
-        var _a = optionsOrToken || {}, token = _a.token, width = _a.width;
-        // TODO: at the next breaking change drop support for passing token as string
-        if (!token && typeof optionsOrToken === "string") {
-            token = optionsOrToken;
-        }
-        var itemApiUrl = getItemApiUrl(item, portalUrlOrObject, token);
-        var _b = itemApiUrl.split("?"), baseUrl = _b[0], search = _b[1];
-        var searchParams = new URLSearchParams(search);
-        searchParams.delete("f");
-        if (width) {
-            searchParams.append("w", width + "");
-        }
-        var newSearch = searchParams.toString();
-        var url = baseUrl + "/info/" + item.thumbnail;
-        return newSearch ? url + "?" + newSearch : url;
-    }
-
     /**
      * Given an item, return an array of assets that includes
      * all the resources, as well as the thumbnail
@@ -11602,6 +12176,23 @@
         return fetch(url, { method: "DELETE", headers: headers, mode: "cors" }).then(_checkStatusAndParseJson);
     }
 
+    /**
+     * Remove all domain entries by site id.
+     * User must be a member of the org that owns the domain entry.
+     * @param {int} domainSiteId of the domain entries to remove
+     * @param {IHubRequestOptions} hubRequestOptions`dom
+     */
+    function removeDomainsBySiteId(domainSiteId, hubRequestOptions) {
+        // TODO: Can remove this if no longer required
+        if (hubRequestOptions.isPortal) {
+            throw new Error("removeDomainsBySiteId is not available in ArcGIS Enterprise. Instead, edit the hubdomain typekeyword on the item");
+        }
+        var headers = _getAuthHeader(hubRequestOptions);
+        headers["Content-Type"] = "application/json";
+        var url = _getDomainServiceUrl(hubRequestOptions.hubApiUrl) + "/?siteId=" + domainSiteId;
+        return fetch(url, { method: "DELETE", headers: headers, mode: "cors" }).then(_checkStatusAndParseJson);
+    }
+
     /**
      * Update an entry in the domain system
      * @param {IHubDomain} domainEntry  Doman object to be updated
@@ -12076,21 +12667,19 @@
      *
      * myHub.context.currentUser //=> {username: "casey", ...} as IUser
      *
-     * const projectStore = await myHub.getProjectStore();
-     *
-     * const pavingProject = await projectStore.create({name: "12th Street Paving"});
+     * const pavingProject = await myHub.projects.create({name: "12th Street Paving"});
      * pavingProject.summary = "This is the 2024 planned paving of 12th Street, between 8th and 11th Ave";
-     * await projectStore.update(pavingProject);
+     * await myHub.projects.update(pavingProject);
      * ```
      *
-     * This is a convenience class. Hub Stores can be created
+     * This is a convenience class. Hub Managers can be created
      * directly, or the underlying functions can be imported an used
      * as need for scenarios where these class structures introduce
      * unwanted complexity
      */
     var Hub = /** @class */ (function () {
         /**
-         * Private so we can employ a factory function should we need
+         * Private so we can employ a factory function to do
          * async work during creation
          * @param contextManager
          */
@@ -12098,9 +12687,7 @@
             this._contextManager = contextManager;
         }
         /**
-         * Factory function to construct a new HubProjectStore instance.
-         *
-         * Note: Used so that we could do async actions in the ctor.
+         * Factory function to construct a new Hub instance.
          * @param contextManager
          * @returns
          */
@@ -12134,7 +12721,7 @@
         });
         Object.defineProperty(Hub.prototype, "projects", {
             /**
-             * Create a Project Store connected to the current Hub
+             * HubProjectManager for the current Hub
              * @returns
              */
             get: function () {
@@ -12523,6 +13110,7 @@
     exports.cloneObject = cloneObject$1;
     exports.completeOAuth2 = completeOAuth2;
     exports.compose = compose;
+    exports.composeContent = composeContent;
     exports.constructSlug = constructSlug;
     exports.convertContentDefinitionToFilter = convertContentDefinitionToFilter;
     exports.convertContentFilterToSearchOptions = convertContentFilterToSearchOptions;
@@ -12566,13 +13154,15 @@
     exports.fetchAndUploadThumbnail = fetchAndUploadThumbnail;
     exports.fetchHubTranslation = fetchHubTranslation;
     exports.fetchImageAsBlob = fetchImageAsBlob;
+    exports.fetchModelFromItem = fetchModelFromItem;
+    exports.fetchProject = fetchProject;
     exports.fetchSite = fetchSite;
     exports.filterBy = filterBy;
     exports.findBy = findBy;
+    exports.findItemsBySlug = findItemsBySlug;
     exports.flattenArray = flattenArray;
     exports.generateRandomString = generateRandomString;
     exports.getCategory = getCategory;
-    exports.getCollection = getCollection;
     exports.getContentIdentifier = getContentIdentifier;
     exports.getContentSiteUrls = getContentSiteUrls;
     exports.getContentTypeIcon = getContentTypeIcon;
@@ -12609,7 +13199,7 @@
     exports.getPortalApiUrl = getPortalApiUrl;
     exports.getPortalBaseFromOrgUrl = getPortalBaseFromOrgUrl;
     exports.getPortalUrl = getPortalUrl;
-    exports.getProject = getProject;
+    exports.getPortalUrls = getPortalUrls;
     exports.getProp = getProp;
     exports.getProps = getProps;
     exports.getProxyUrl = getProxyUrl;
@@ -12677,10 +13267,12 @@
     exports.relativeDateToDateRange = relativeDateToDateRange;
     exports.removeContextFromSlug = removeContextFromSlug;
     exports.removeDomain = removeDomain;
+    exports.removeDomainsBySiteId = removeDomainsBySiteId;
     exports.removeEmptyProps = removeEmptyProps;
     exports.replaceItemId = replaceItemId;
     exports.runRevertableTask = runRevertableTask;
     exports.saveSession = saveSession;
+    exports.searchProjects = searchProjects;
     exports.serializeContentFilterForPortal = serializeContentFilterForPortal;
     exports.serializeDateRange = serializeDateRange;
     exports.serializeGroupFilterForPortal = serializeGroupFilterForPortal;
@@ -12692,6 +13284,7 @@
     exports.setContentHubId = setContentHubId;
     exports.setContentSiteUrls = setContentSiteUrls;
     exports.setContentType = setContentType;
+    exports.setItemThumbnail = setItemThumbnail;
     exports.setProp = setProp;
     exports.setSlugKeyword = setSlugKeyword;
     exports.shareItemToGroups = shareItemToGroups;