@esri/hub-common 9.18.0 → 9.21.0

package/dist/umd/common.umd.js

@@ -1,5 +1,5 @@
 /* @preserve
- * @esri/hub-common - v9.17.1 - Fri Feb 18 2022 21:45:18 GMT+0000 (Coordinated Universal Time)
+ * @esri/hub-common - v9.20.0 - Mon Feb 28 2022 15:56:25 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 = {
@@ -5942,6 +5963,26 @@
                 })));
     }
 
+    /* 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);
+    }
+
     function createExtent(xmin, ymin, xmax, ymax, wkid) {
         if (wkid === void 0) { wkid = 4326; }
         return {
@@ -6084,6 +6125,291 @@
         };
     };
 
+    // 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 };
+    };
+    /**
+     * Extracts additional resources from the provided metadata
+     * and transforms them into a hub-friendly format.
+     *
+     * Returns null if no resources are available
+     *
+     * @param item
+     * @param metadata formal metadata
+     * @returns
+     */
+    var getAdditionalResources = function (item, metadata, requestOptions) {
+        var rawResources = getProp(metadata, "metadata.distInfo.distTranOps.onLineSrc") || null;
+        if (rawResources === null) {
+            return null;
+        }
+        // Coerce to array since rawResources will be an object if only 1 resource is available
+        rawResources = Array.isArray(rawResources) ? rawResources : [rawResources];
+        return rawResources.map(function (resource) { return ({
+            name: resource.orName,
+            url: getAdditionalResourceUrl(resource, item, requestOptions),
+            isDataSource: isDataSourceOfItem(resource, item),
+        }); });
+    };
+    /**
+     * Determines whether a raw additional resource (i.e. extracted out of formal
+     * metadata with no transformation) references the underlying service that backs
+     * the item.
+     *
+     * @param resource raw additional resource of an item
+     * @param item
+     * @returns
+     */
+    var isDataSourceOfItem = function (resource, item) {
+        var serviceUrl = item.url && parseServiceUrl(item.url);
+        return serviceUrl && resource.linkage.includes(serviceUrl);
+    };
+    /**
+     * Returns the url for an additional resource.
+     *
+     * Automatically appends auth token if token is available
+     * and resource points to the backing service of an item.
+     *
+     * @param resource raw additional resource of an item
+     * @param item
+     * @param requestOptions IHubRequestOptions, including authentication
+     * @returns
+     */
+    var getAdditionalResourceUrl = function (resource, item, requestOptions) {
+        var result = resource.linkage;
+        var token = getProp(requestOptions, "authentication.token");
+        if (token && isDataSourceOfItem(resource, item)) {
+            var resUrl = new URL(resource.linkage);
+            var params = new URLSearchParams(resUrl.search);
+            params.set("token", token);
+            resUrl.search = params.toString();
+            result = resUrl.toString();
+        }
+        return result;
+    };
+
     var STANDARD_LICENSES = [
         {
             type: "CC0-1.0",
@@ -6380,116 +6706,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;
-    }
+    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";
+    };
     /**
-     * ```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.
+     * 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";
@@ -6525,76 +7048,6 @@
         }
         return ret;
     }
-    /**
-     * ```js
-     * import { getTypeCategories } from "@esri/hub-common";
-     * //
-     * getTypeCategories(item)
-     * > [ 'Hub Site Application' ]
-     * ```
-     * @param item Item object.
-     * @returns typeCategory of the input item.
-     *
-     */
-    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"];
-        }
-    }
-    /**
-     * ```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.
-     */
-    function getCollection(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;
-                }
-            }
-        }
-    }
-    /**
-     * 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
@@ -6606,6 +7059,7 @@
         // 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"));
     };
@@ -6623,6 +7077,316 @@
         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 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()); });
+    }
+    /**
+     * 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);
+            },
+            get additionalResources() {
+                return getAdditionalResources(item, metadata);
+            } });
+    };
+
+    // TODO: remove this at next breaking version
+    /**
+     * ```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.
+     */
+    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.
+     *
+     */
+    function getTypes(category) {
+        if (category === void 0) { category = ""; }
+        return categories[category.toLowerCase()];
+    }
+    /**
+     * ```js
+     * import { getTypeCategories } from "@esri/hub-common";
+     * //
+     * getTypeCategories(item)
+     * > [ 'Hub Site Application' ]
+     * ```
+     * @param item Item object.
+     * @returns typeCategory of the input item.
+     *
+     */
+    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"];
+        }
+    }
     /**
      * ```js
      * import { getContentIdentifier } from "@esri/hub-common";
@@ -6652,7 +7416,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
@@ -6721,74 +7485,20 @@
             return context + "::" + slug;
         }
     }
-    /**
-     * Remove context (prefix) from a slug
-     *
-     * @param slug Hub API slug with context
-     * @param context usually a portal's orgKey
-     * @returns slug without context
-     */
-    function removeContextFromSlug(slug, context) {
-        if (context && slug.match(context + "::")) {
-            return slug.split(context + "::")[1];
-        }
-        else {
-            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));
+    /**
+     * Remove context (prefix) from a slug
+     *
+     * @param slug Hub API slug with context
+     * @param context usually a portal's orgKey
+     * @returns slug without context
+     */
+    function removeContextFromSlug(slug, context) {
+        if (context && slug.match(context + "::")) {
+            return slug.split(context + "::")[1];
+        }
+        else {
+            return slug;
         }
-        return family;
     }
     /**
      * DEPRECATED: Use getFamily() instead.
@@ -6816,51 +7526,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 +7538,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
@@ -7072,122 +7705,6 @@
             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",
-        };
-        return (_a = iconMap[type]) !== null && _a !== void 0 ? _a : "file";
-    };
     /**
      * Compute the content type label
      * @param contentType
@@ -7252,78 +7769,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);
     };
 
     /**
@@ -9543,7 +9989,7 @@
     function searchProjects(filter, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var scopingFilter, projectFilter, expanded, so;
+            var scopingFilter, projectFilter, expanded, so, props;
             return __generator(this, function (_b) {
                 scopingFilter = {
                     filterType: "content",
@@ -9559,22 +10005,19 @@
                     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;
-                }
+                props = [
+                    "authentication",
+                    "num",
+                    "sortField",
+                    "sortOrder",
+                    "site",
+                ];
+                // copy the props over
+                props.forEach(function (prop) {
+                    if (options.hasOwnProperty(prop)) {
+                        so[prop] = options[prop];
+                    }
+                });
                 return [2 /*return*/, searchPortalProjects(so)];
             });
         });
@@ -9991,36 +10434,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
@@ -11249,40 +11662,36 @@
     function _searchContent(filter, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var expanded, api, searchPromise, so;
+            var expanded, api, searchPromise, so_1, props;
             return __generator(this, function (_b) {
                 expanded = expandContentFilter(filter);
                 api = expandApi(options.api || "arcgis");
                 // Portal Search
                 if (api.type === "arcgis") {
-                    so = serializeContentFilterForPortal(expanded);
-                    // if we have auth, pass it forward
-                    // otherwise set the portal property
-                    if (options.authentication) {
-                        so.authentication = options.authentication;
-                    }
-                    else {
-                        so.portal = api.url + "/sharing/rest";
+                    so_1 = serializeContentFilterForPortal(expanded);
+                    props = [
+                        "authentication",
+                        "num",
+                        "sortField",
+                        "sortOrder",
+                        "site",
+                    ];
+                    // copy the props over
+                    props.forEach(function (prop) {
+                        if (options.hasOwnProperty(prop)) {
+                            so_1[prop] = options[prop];
+                        }
+                    });
+                    // If we don't have auth, ensure we have .portal
+                    if (!so_1.authentication) {
+                        so_1.portal = api.url + "/sharing/rest";
                     }
                     // 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;
+                        so_1.countFields = options.aggregations.join(",");
+                        so_1.countSize = 200;
                     }
-                    if (options.sortField) {
-                        so.sortField = options.sortField;
-                    }
-                    if (options.sortOrder) {
-                        so.sortOrder = options.sortOrder;
-                    }
-                    if (options.site) {
-                        so.site = cloneObject$1(options.site);
-                    }
-                    searchPromise = searchPortal(so);
+                    searchPromise = searchPortal(so_1);
                 }
                 else {
                     // Hub API Search
@@ -11354,33 +11763,30 @@
      */
     function _searchGroups(filter, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var expanded, api, so;
+            var expanded, api, so_1, props;
             return __generator(this, function (_a) {
                 expanded = expandGroupFilter(filter);
                 api = expandApi(options.api || "arcgis");
                 if (api.type === "arcgis") {
-                    so = serializeGroupFilterForPortal(expanded);
-                    // if we have auth, pass it forward
-                    // otherwise set the portal property
-                    if (options.authentication) {
-                        so.authentication = options.authentication;
-                    }
-                    else {
-                        so.portal = api.url + "/sharing/rest";
-                    }
-                    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);
+                    so_1 = serializeGroupFilterForPortal(expanded);
+                    props = [
+                        "authentication",
+                        "num",
+                        "sortField",
+                        "sortOrder",
+                        "site",
+                    ];
+                    // copy the props over
+                    props.forEach(function (prop) {
+                        if (options.hasOwnProperty(prop)) {
+                            so_1[prop] = options[prop];
+                        }
+                    });
+                    // If we don't have auth, ensure we have .portal
+                    if (!so_1.authentication) {
+                        so_1.portal = api.url + "/sharing/rest";
                     }
-                    return [2 /*return*/, searchPortalGroups(so)];
+                    return [2 /*return*/, searchPortalGroups(so_1)];
                 }
                 else {
                     throw new Error("_searchGroups is not implemented for non-arcgis apis");
@@ -11441,7 +11847,7 @@
      */
     function _searchUsers(filter, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var expanded, api, searchOptions;
+            var expanded, api, searchOptions_1, props;
             return __generator(this, function (_a) {
                 // JS Clients may not pass in authentication
                 if (!options.authentication) {
@@ -11450,23 +11856,21 @@
                 expanded = expandUserFilter(filter);
                 api = expandApi(options.api || "arcgis");
                 if (api.type === "arcgis") {
-                    searchOptions = serializeUserFilterForPortal(expanded);
-                    // carry the auth forward
-                    searchOptions.authentication = options.authentication;
-                    // TODO: Dry this up - typscript makes this... inconvenient
-                    if (options.num) {
-                        searchOptions.num = options.num;
-                    }
-                    if (options.sortField) {
-                        searchOptions.sortField = options.sortField;
-                    }
-                    if (options.sortOrder) {
-                        searchOptions.sortOrder = options.sortOrder;
-                    }
-                    if (options.site) {
-                        searchOptions.site = cloneObject$1(options.site);
-                    }
-                    return [2 /*return*/, searchPortalUsers(searchOptions)];
+                    searchOptions_1 = serializeUserFilterForPortal(expanded);
+                    props = [
+                        "authentication",
+                        "num",
+                        "sortField",
+                        "sortOrder",
+                        "site",
+                    ];
+                    // copy the props over
+                    props.forEach(function (prop) {
+                        if (options.hasOwnProperty(prop)) {
+                            searchOptions_1[prop] = options[prop];
+                        }
+                    });
+                    return [2 /*return*/, searchPortalUsers(searchOptions_1)];
                 }
                 else {
                     throw new Error("_searchUsers is not implemented for non-arcgis apis");
@@ -11822,6 +12226,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
@@ -12739,6 +13160,7 @@
     exports.cloneObject = cloneObject$1;
     exports.completeOAuth2 = completeOAuth2;
     exports.compose = compose;
+    exports.composeContent = composeContent;
     exports.constructSlug = constructSlug;
     exports.convertContentDefinitionToFilter = convertContentDefinitionToFilter;
     exports.convertContentFilterToSearchOptions = convertContentFilterToSearchOptions;
@@ -12791,7 +13213,6 @@
     exports.flattenArray = flattenArray;
     exports.generateRandomString = generateRandomString;
     exports.getCategory = getCategory;
-    exports.getCollection = getCollection;
     exports.getContentIdentifier = getContentIdentifier;
     exports.getContentSiteUrls = getContentSiteUrls;
     exports.getContentTypeIcon = getContentTypeIcon;
@@ -12828,6 +13249,7 @@
     exports.getPortalApiUrl = getPortalApiUrl;
     exports.getPortalBaseFromOrgUrl = getPortalBaseFromOrgUrl;
     exports.getPortalUrl = getPortalUrl;
+    exports.getPortalUrls = getPortalUrls;
     exports.getProp = getProp;
     exports.getProps = getProps;
     exports.getProxyUrl = getProxyUrl;
@@ -12895,6 +13317,7 @@
     exports.relativeDateToDateRange = relativeDateToDateRange;
     exports.removeContextFromSlug = removeContextFromSlug;
     exports.removeDomain = removeDomain;
+    exports.removeDomainsBySiteId = removeDomainsBySiteId;
     exports.removeEmptyProps = removeEmptyProps;
     exports.replaceItemId = replaceItemId;
     exports.runRevertableTask = runRevertableTask;