@esri/hub-common 9.13.2 → 9.16.0

package/dist/types/Hub.d.ts

@@ -0,0 +1,72 @@
+import { ArcGISContextManager, IArcGISContextManagerOptions } from "./ArcGISContextManager";
+import { HubProjectManager } from "./projects/HubProjectManager";
+/**
+ * Options for instantiating a Hub instance
+ */
+export interface IHubOptions {
+    contextManager?: ArcGISContextManager;
+    managerOptions?: IArcGISContextManagerOptions;
+    authOptions?: {
+        usename: string;
+        password: string;
+        portalUrl?: string;
+    };
+}
+/**
+ * Hub class can be used as an entry point to managing
+ * content, teams, sites, projects etc, in an organization's Hub.
+ *
+ * ```js
+ * import {Hub} from '@esri/hub-common';
+ * // create a Hub instance, authenticating as a specific user
+ * // working against arcgis online
+ * const myHub = await Hub.create({authOptions: {username: "casey", password: "jones"}});
+ *
+ * myHub.context.currentUser //=> {username: "casey", ...} as IUser
+ *
+ * const projectStore = await myHub.getProjectStore();
+ *
+ * const pavingProject = await projectStore.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);
+ * ```
+ *
+ * This is a convenience class. Hub Stores can be created
+ * directly, or the underlying functions can be imported an used
+ * as need for scenarios where these class structures introduce
+ * unwanted complexity
+ */
+export declare class Hub {
+    /**
+     * Hold a context manager, which should be a single instance for
+     * an application. When authentication changes, the .context
+     * property on the context manager will be replaced. As long as
+     * all the fns in this class leverage properties on .context
+     * everything be kept in sync.
+     */
+    private _contextManager;
+    private _projectManager;
+    /**
+     * Private so we can employ a factory function should we need
+     * async work during creation
+     * @param contextManager
+     */
+    private constructor();
+    /**
+     * Factory function to construct a new HubProjectStore instance.
+     *
+     * Note: Used so that we could do async actions in the ctor.
+     * @param contextManager
+     * @returns
+     */
+    static create(options: IHubOptions): Promise<Hub>;
+    /**
+     * Getter to abstract the context manager
+     */
+    get context(): import("./ArcGISContext").IArcGISContext;
+    /**
+     * Create a Project Store connected to the current Hub
+     * @returns
+     */
+    get projects(): HubProjectManager;
+}

package/dist/types/HubError.d.ts

@@ -0,0 +1,17 @@
+import { OperationError } from ".";
+/**
+ * Generic Hub Error with an Error stack as well
+ * as an optional serialized OperationStack.
+ *
+ * Also accepts a `rootCause` Error object
+ */
+export default class HubError extends OperationError {
+    /**
+     * Creates an instance of HubError.
+     * @param {string} operation
+     * @param {string} [message]
+     * @param {Error} [rootCause]
+     * @memberof HubError
+     */
+    constructor(operation: string, message?: string, rootCause?: Error);
+}

package/dist/types/collections.d.ts

@@ -1,3 +1,15 @@
+/**
+ * ```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.
+ */
+export declare const getCollection: (type?: string) => string;
 export declare const collections: {
     [key: string]: string[];
 };

package/dist/types/content/_internal.d.ts

@@ -8,7 +8,8 @@
  * 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.
  */
-import { BBox, IHubContent, IHubGeography, GeographyProvenance } from "../types";
+import { IItem } from "@esri/arcgis-rest-types/dist/types/item";
+import { BBox, IHubContent, IHubGeography, GeographyProvenance, IHubRequestOptions } from "..";
 /**
  * Create a new content with updated boundary properties
  * @param content original content
@@ -17,70 +18,89 @@ import { BBox, IHubContent, IHubGeography, GeographyProvenance } from "../types"
  */
 export declare const setContentBoundary: (content: IHubContent, boundary: GeographyProvenance) => {
     boundary: IHubGeography;
-    item: any;
+    item: {
+        properties: any;
+        id: string;
+        owner: string;
+        tags: string[];
+        created: number;
+        modified: number;
+        numViews: number;
+        size: number;
+        protected?: boolean;
+        title: string;
+        type: string;
+        typeKeywords?: string[];
+        description?: string;
+        snippet?: string;
+        documentation?: string;
+        extent?: number[][];
+        categories?: string[];
+        spatialReference?: import("@esri/arcgis-rest-types").ISpatialReference;
+        culture?: string;
+        url?: string;
+    };
+    slug?: string;
     hubId?: string;
+    identifier: string;
     permissions: {
         visibility: "private" | "public" | "org";
-        control?: import("../types").AccessControl;
+        control?: import("..").AccessControl;
         groups?: import("@esri/arcgis-rest-types").IGroup[];
     };
-    family?: import("../types").HubFamily;
-    itemCategories?: string[];
-    normalizedType?: string;
+    family?: import("..").HubFamily;
+    categories?: string[];
+    isDownloadable: boolean;
+    structuredLicense?: import("..").IStructuredLicense;
     publishedDate: Date;
     publishedDateSource?: string;
     updateFrequency?: string;
-    actionLinks?: import("../types").IActionLink[];
-    hubActions?: object;
-    metrics?: {
-        visibility: "private" | "public" | "org" | "updateGroups";
-    };
-    slug?: string;
+    portalHomeUrl?: string;
+    portalApiUrl?: string;
     portalDataUrl?: string;
-    groupIds?: string[];
-    errors?: import("../types").IEnrichmentErrorInfo[];
-    data?: {
-        [propName: string]: any;
-    };
-    server?: Partial<import("@esri/arcgis-rest-types").IFeatureServiceDefinition>;
-    layers?: Partial<import("@esri/arcgis-rest-types").ILayerDefinition>[];
+    actionLinks?: import("..").IActionLink[];
+    hubActions?: object;
     layer?: Partial<import("@esri/arcgis-rest-types").ILayerDefinition>;
-    recordCount?: number;
+    itemCategories?: string[];
+    normalizedType?: string;
     orgId?: string;
-    org?: Partial<import("@esri/arcgis-rest-portal").IPortal>;
-    isDownloadable: boolean;
-    structuredLicense?: import("..").IStructuredLicense;
+    thumbnailUrl?: string;
+    owner: string;
+    description?: string;
+    culture?: string;
+    tags: string[];
+    typeKeywords?: string[];
+    url?: string;
+    id: string;
     name: string;
     summary?: string;
-    hubType: import("../types").HubType;
     createdDate: Date;
-    createdDateSource?: string;
+    createdDateSource: string;
     updatedDate: Date;
-    updatedDateSource?: string;
-    portalHomeUrl?: string;
-    portalApiUrl?: string;
-    thumbnailUrl?: string;
+    updatedDateSource: string;
+    type: string;
+    server?: Partial<import("@esri/arcgis-rest-types").IFeatureServiceDefinition>;
+    layers?: Partial<import("@esri/arcgis-rest-types").ILayerDefinition>[];
+    recordCount?: number;
+    data?: {
+        [propName: string]: any;
+    };
     metadata?: any;
-    id: string;
-    owner: string;
-    tags: string[];
+    groupIds?: string[];
+    ownerUser?: import("@esri/arcgis-rest-types").IUser;
+    org?: Partial<import("@esri/arcgis-rest-portal").IPortal>;
+    errors?: import("..").IEnrichmentErrorInfo[];
     created: number;
     modified: number;
     numViews: number;
     size: number;
     protected?: boolean;
     title: string;
-    type: string;
-    typeKeywords?: string[];
-    description?: string;
     snippet?: string;
     documentation?: string;
     extent?: number[][];
-    categories?: string[];
     spatialReference?: import("@esri/arcgis-rest-types").ISpatialReference;
-    culture?: string;
     properties?: any;
-    url?: string;
 };
 /**
  * Create a new content with updated extent and derived properties like boundary
@@ -89,3 +109,11 @@ export declare const setContentBoundary: (content: IHubContent, boundary: Geogra
  * @returns a new content with the updated extent and boundary
  */
 export declare const setContentExtent: (content: IHubContent, extent: BBox) => IHubContent;
+/**
+ * Returns whether or not an item is a proxied csv
+ *
+ * @param item
+ * @param requestOptions Hub Request Options (including whether we're in portal)
+ * @returns
+ */
+export declare const isProxiedCSV: (item: IItem, requestOptions: IHubRequestOptions) => boolean;

package/dist/types/content/index.d.ts

@@ -1,7 +1,7 @@
 import { ResourceObject } from "jsonapi-typescript";
 import { IItem } from "@esri/arcgis-rest-portal";
-import { HubType, HubFamily } from "../types";
-import { IHubContent, IModel } from "../types";
+import { HubType, HubFamily, IModel, IHubRequestOptions } from "../types";
+import { IHubContent } from "..";
 /**
  * JSONAPI dataset resource returned by the Hub API
  */
@@ -204,25 +204,25 @@ export declare function datasetToContent(dataset: DatasetResource): IHubContent;
 export declare function datasetToItem(dataset: DatasetResource): IItem;
 /**
  * returns a new content that has the specified type and
- * and updated related properties like normalizedType, family, etc
+ * and updated related properties like, family, etc
  * @param content orignal content
  * @param type new type
  * @returns new content
  */
 export declare const setContentType: (content: IHubContent, type: string) => IHubContent;
 /**
- * Compute the content type icon based on the normalizedType
- * @param normalizedType
+ * Compute the content type icon based on the content type
+ * @param content type
  * @returns content type icon
  */
-export declare const getContentTypeIcon: (normalizedType: string) => any;
+export declare const getContentTypeIcon: (contentType: string) => any;
 /**
  * Compute the content type label
- * @param normalizedType
+ * @param contentType
  * @param isProxied
  * @returns content type label
  */
-export declare const getContentTypeLabel: (normalizedType: string, isProxied: boolean) => string;
+export declare const getContentTypeLabel: (contentType: string, isProxied: boolean) => string;
 /**
  * returns a new content that has the specified hubId and updated identifier
  * @param content orignal content
@@ -249,3 +249,12 @@ export declare const getContentSiteUrls: (content: IHubContent, siteModel: IMode
  * @returns
  */
 export declare const setContentSiteUrls: (content: IHubContent, siteModel: IModel) => IHubContent;
+/**
+ * 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
+ */
+export declare const getProxyUrl: (item: IItem, requestOptions: IHubRequestOptions) => string;

package/dist/types/core/helpers/PropertyMapper.d.ts

@@ -0,0 +1,69 @@
+import { IModel } from "../..";
+/**
+ * Manage forward and backward property mappings to
+ * streamline conversion between the Hub entities, and
+ * the backing IModel
+ */
+export declare class PropertyMapper<T> {
+    mappings: IPropertyMap[];
+    /**
+     * Pass in the mappings between the Entity and
+     * it's backing structure (model or otherwise)
+     * @param mappings
+     */
+    constructor(mappings: IPropertyMap[]);
+    /**
+     * Map properties from a model on to the entity object.
+     *
+     * Used when constructing an entity can from a fetched model,
+     * in which case the entity should be an empty object (`{}`).
+     *
+     * Can also be used to apply changes to an entity from a model,
+     * in which case an existing entity can be passed in.
+     * @param model
+     * @param object
+     * @returns
+     */
+    modelToObject(model: IModel, object: T): T;
+    /**
+     * Map properties from an entity object onto a model.
+     *
+     * Typically the model will already exist, and this
+     * method is used to transfer changes to the model
+     * prior to storage.
+     * @param object
+     * @param model
+     * @returns
+     */
+    objectToModel(object: T, model: IModel): IModel;
+}
+/**
+ * Property Map Entry that provides a cross-walk
+ * between a property path (`name`) on the "object"
+ * to a property path on a model (`item.title`).
+ *
+ * This enables autmatic mapping of properties between
+ * the two types of objects.
+ */
+export interface IPropertyMap {
+    objectKey: string;
+    modelKey: string;
+}
+/**
+ * Generic function to apply properties from an Object
+ * (i.e. IHubProject) onto a Model that can be persisted to an Item
+ * @param object
+ * @param model
+ * @param mappings
+ * @returns
+ */
+export declare function mapObjectToModel<T>(object: T, model: IModel, mappings: IPropertyMap[]): IModel;
+/**
+ * Generic function to apply properties from a Model
+ * onto an Object (i.e. IHubProject etc)
+ * @param model
+ * @param object
+ * @param mappings
+ * @returns
+ */
+export declare function mapModelToObject<T>(model: IModel, object: T, mappings: IPropertyMap[]): T;

package/dist/types/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./traits";
+export * from "./types";

package/dist/types/core/traits/WithBannerImage.d.ts

@@ -0,0 +1,30 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+import { IHubImage, IHubImageOptions } from "../types/IHubImage";
+/**
+ * WithBannerImage Trait
+ * Adds a .bannerImage property
+ */
+export interface IWithBannerImage {
+    /**
+     * Banner Image as IHubImage
+     */
+    bannerImage?: IHubImage;
+}
+/**
+ * Defines functions for working with Banner Images
+ */
+export interface IWithBannerImageStore {
+    /**
+     * Store a banner image
+     * @param id
+     * @param opts
+     * @param ro
+     */
+    setBannerImage(id: string, opts: IHubImageOptions, ro: IUserRequestOptions): Promise<IHubImage>;
+    /**
+     * Clear a banner image
+     * @param id
+     * @param ro
+     */
+    clearBannerImage(id: string, ro: IUserRequestOptions): Promise<void>;
+}

package/dist/types/core/traits/WithLayout.d.ts

@@ -0,0 +1,54 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { IHubLayout } from "../types/IHubLayout";
+/**
+ * Properties associated with a Layout
+ */
+export interface IWithLayout {
+    /**
+     * Layout property
+     */
+    layout?: IHubLayout;
+}
+/**
+ * Defined layout related functions that a module
+ * working with IWithLayout objects must implement
+ */
+export interface IWithLayoutStore {
+    /**
+     * Given a version name, copy that into the item's /data
+     * making it the "active version"
+     * @param id
+     * @param ro
+     */
+    setActiveVersion(id: string, ro: IUserRequestOptions): Promise<void>;
+    /**
+     * Return a list of all the versions by name
+     * @param id
+     * @param ro
+     */
+    listVersions(id: string, ro: IRequestOptions): Promise<string[]>;
+    /**
+     * Destroy the resource backing a version
+     * @param id
+     * @param name
+     * @param ro
+     */
+    destroyVersion(id: string, name: string, ro: IUserRequestOptions): Promise<void>;
+    /**
+     * Store a version as a resource, with the given name
+     * @param id
+     * @param name
+     * @param layout
+     * @param ro
+     */
+    saveVersion(id: string, name: string, layout: IHubLayout, ro: IUserRequestOptions): Promise<void>;
+    /**
+     * Fetch the layout from a specific version.
+     * Used when editing a specific version.
+     * @param id
+     * @param name
+     * @param ro
+     */
+    loadVersion(id: string, name: string, ro: IRequestOptions): Promise<IHubLayout>;
+}

package/dist/types/core/traits/WithSlug.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Adds slug and related properties
+ */
+export interface IWithSlug {
+    /**
+     * Slug that can be used to lookup an entity
+     * by something other than it's id
+     */
+    slug?: string;
+    /**
+     * Organization urlKey used to construct the
+     * slug
+     */
+    orgUrlKey: string;
+}

package/dist/types/core/traits/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./WithBannerImage";
+export * from "./WithLayout";
+export * from "./WithSlug";

package/dist/types/core/types/IContentEnrichments.d.ts

@@ -0,0 +1,10 @@
+import { IFeatureServiceDefinition, ILayerDefinition } from "@esri/arcgis-rest-feature-layer";
+import { IItemEnrichments } from "./IItemEnrichments";
+export interface IContentEnrichments extends IItemEnrichments {
+    /** Information about the service referenced by this content (currentVersion, capabilities, maxRecordCount etc) */
+    server?: Partial<IFeatureServiceDefinition>;
+    /** Detailed information about the service's layers (geometryType, fields, etc) for related layers in the service */
+    layers?: Array<Partial<ILayerDefinition>>;
+    /** The count of records for the layer referenced by this content */
+    recordCount?: number;
+}

package/dist/types/core/types/IHubContent.d.ts

@@ -0,0 +1,77 @@
+import { IItem, IGroup } from "@esri/arcgis-rest-portal";
+import { ILayerDefinition } from "@esri/arcgis-rest-feature-layer";
+import { Visibility, AccessControl, HubFamily, IActionLink, IStructuredLicense } from "../..";
+import { IHubItemEntity } from ".";
+import { IContentEnrichments } from "./IContentEnrichments";
+/**
+ * Data model for content
+ */
+export interface IHubContent extends IHubItemEntity, IContentEnrichments, IItem {
+    /**
+     * The underlying portal item referenced by this content
+     */
+    item: IItem;
+    /**
+     * Slug that can be used to lookup an entity
+     * by something other than it's id
+     */
+    slug?: string;
+    /**
+     * The content's ID for use with the Hub API
+     * For most content this will be the item's id
+     * For layers this will be `<itemId>_<layerId>`
+     * This will be undefined for private items and in enterprise
+     * because only public online items are included in the Hub API
+     */
+    hubId?: string;
+    /**
+     * The preferred identifier to use for Hub URLs.
+     * This will be either the slug, hubId, or item id.
+     */
+    identifier: string;
+    /**
+     * Content visibility and access control, including groups
+     */
+    permissions: {
+        /** Visibility of the content */
+        visibility: Visibility;
+        /** Current user's control over the content */
+        control?: AccessControl;
+        /** The groups that have access to the item (as far as you know) */
+        groups?: IGroup[];
+    };
+    /**
+     * The the family of related types that this content belongs to.
+     */
+    family?: HubFamily;
+    /** Parsed item categories (see parseItemCategories) */
+    categories?: string[];
+    /** Whether the content is downloadable in the Hub app */
+    isDownloadable: boolean;
+    /** The content's structured license info */
+    structuredLicense?: IStructuredLicense;
+    /**
+     * Date the content was published (formal metadata),
+     * defaults to the date the content was created
+     */
+    publishedDate: Date;
+    /** Description of the source of the published date */
+    publishedDateSource?: string;
+    /** Frequency at which the content is updated */
+    updateFrequency?: string;
+    /** URL of the resource's page in the Portal Home application */
+    portalHomeUrl?: string;
+    /** URL of the Portal API endpoint for the resource */
+    portalApiUrl?: string;
+    /** URL of the Portal API data endpoint for the resource */
+    portalDataUrl?: string;
+    /** Optional links to show in the Hub application for this content */
+    actionLinks?: IActionLink[];
+    /** Configure which Hub application actions (i.e. create web map) are available for this content */
+    hubActions?: object;
+    /** Information about the layer referenced by this content (geometryType, fields, etc) */
+    layer?: Partial<ILayerDefinition>;
+    itemCategories?: string[];
+    normalizedType?: string;
+    orgId?: string;
+}

package/dist/types/core/types/IHubEntityBase.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Base properties for Hub Entities
+ * This is a subset of `IItem`, that can apply to
+ * models that are not backed by items.
+ */
+export interface IHubEntityBase {
+    /**
+     * Id of the entity as a string
+     */
+    id: string;
+    /**
+     * Name of the Entity
+     * For Entities backed by items, this is typically the title
+     */
+    name: string;
+    /**
+     * Simple summary of the Entity.
+     * For items, this is typically the `snippet` property.
+     */
+    summary?: string;
+    /**
+     * Date the entity was created
+     */
+    createdDate: Date;
+    /**
+     * Source of the creation date
+     */
+    createdDateSource: string;
+    /**
+     * Date the entity was last updated
+     */
+    updatedDate: Date;
+    /**
+     * Source of the updated date
+     */
+    updatedDateSource: string;
+    /**
+     * Type of entity
+     */
+    type: string;
+}

package/dist/types/core/types/IHubEntityManager.d.ts

@@ -0,0 +1,33 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+/**
+ * Baseline CRUD+Search functions required for all Store classes
+ */
+export interface IHubEntityManager<T> {
+    /**
+     * Create and Store a new Entity
+     * @param obj
+     * @param requestOptions
+     */
+    create(obj: T, requestOptions: IUserRequestOptions): Promise<T>;
+    /**
+     * Update an existing Entity
+     * @param obj
+     * @param requestOptions
+     */
+    update(obj: T, requestOptions: IUserRequestOptions): Promise<T>;
+    /**
+     * Destroy an Entity
+     * @param id
+     * @param requestOptions
+     */
+    destroy(id: string, requestOptions: IUserRequestOptions): Promise<void>;
+    /**
+     * Get an entity by an identifier. Implementations can handle this
+     * differently as needed. i.e. a HubProject can be fetched by item id (guid)
+     * or by a slug.
+     * @param identifier
+     * @param requestOptions
+     */
+    fetch(identifier: string, requestOptions: IRequestOptions): Promise<T>;
+}

package/dist/types/core/types/IHubEvent.d.ts

@@ -0,0 +1,10 @@
+import { IHubEntityBase } from "./IHubEntityBase";
+/**
+ * DRAFT: Under development and more properties will likely be added
+ * @internal
+ */
+export interface IHubEvent extends IHubEntityBase {
+    location: string;
+    startDate: Date;
+    readonly owner: string;
+}