@esri/hub-common 9.10.1 → 9.13.0

package/dist/types/util.d.ts

@@ -0,0 +1,253 @@
+/**
+ * ```js
+ * import { cloneObject } from "@esri/hub-common";
+ * const original = { foo: "bar" }
+ * const copy = cloneObject(original)
+ * copy.foo // "bar"
+ * copy === original // false
+ * ```
+ * Make a deep clone, including arrays. Does not handle functions!
+ */
+export declare function cloneObject<T>(obj: T): T;
+/**
+ * Given an array of objects, convert into an object, with each
+ * entry assigned the key via the keyprop
+ */
+export declare function arrayToObject(arr: any[], key: string): any;
+/**
+ * Given an object, convert into an array, with each
+ * something or other
+ */
+export declare function objectToArray(obj: {
+    [index: string]: any;
+}, keyProp?: string): any[];
+/**
+ * Return an entry from an array by a property name
+ */
+export declare function findBy(arr: any[], prop: string, value: any): any;
+/**
+ * Return a new array without the specified value.
+ *
+ * @export
+ * @param {any[]} arr
+ * @param {*} val value or object to remove
+ * @returns {any[]} Array without the value
+ */
+export declare function without(arr: any[], value: any): any[];
+/**
+ * Compose
+ * adapted from: https://github.com/stoeffel/compose-function/blob/master/module/index.js
+ */
+export declare function compose(...fns: any[]): any;
+/**
+ * Return a random number, prefixed with a string. Used for unique identifiers that do not require
+ * the rigor of a full UUID - i.e. node id's, process ids etc.
+ * @param prefix String to prefix the random number with so the result is a valid javascript property
+ */
+export declare function createId(prefix?: string): string;
+/**
+ * Append or replace a value on an object, using a specified key, if the value is not null.
+ * This is a very useful companion to the [getProp()](../getProp/) utility.
+ *
+ * Note: object that is passed in is cloned before the property is appended.
+ *
+ * Allows for code like:
+ *
+ * ```js
+ * let model = {
+ *  item: {
+ *    title: 'some example object',
+ *    description: 'this is some longer text',
+ *    type: 'Web Map',
+ *    properties: {
+ *      sourceId: '3ef'
+ *    }
+ *  },
+ *  data: {
+ *    theme: 'orange',
+ *    parcelLayer: {
+ *      primaryField: 'PIN'
+ *    }
+ *  }
+ * };
+ *
+ * // Let's extract some details into an object.
+ * const summary = [
+ *  'item.title',
+ *  'item.description',
+ *  'item.missingProp',
+ *  'data.parcelLayer.primaryField'].reduce((acc, prop) => {
+ *   // create the property name... you could do this however...
+ *   let propName = prop.split('.').reverse()[0];
+ *   return maybeAdd(propName, getProp(model, key), acc);
+ * }, {});
+ *
+ * // summary =>
+ * // {
+ * //   title: 'some example object',
+ * //   description: 'this is some longer text',
+ * //   primaryField: 'PIN'
+ * // }
+ * ```
+ * @param key - key to use when appending to the object
+ * @param val - the possibly null value
+ * @param target - the object to update
+ */
+export declare function maybeAdd(key: string, val: any, target: any): any;
+/**
+ * Append a value to an array, if the value is not null.
+ * This is a very useful companion to the [getProp()](../getProp/) utility.
+ *
+ * Note: the array that is passed in is cloned before being appended to.
+ *
+ * Allows for code like:
+ * ```js
+ *  // example object
+ * let model = {
+ *  item: {
+ *    id: 'c00',
+ *    title: 'some example object',
+ *    description: 'this is some longer text',
+ *    type: 'Web Map',
+ *    properties: {
+ *      sourceId: '3ef'
+ *    }
+ *  },
+ *  data: {
+ *    theme: 'orange',
+ *    parcelLayer: {
+ *      itemId: '7ca',
+ *      primaryField: 'PIN'
+ *    }
+ *  }
+ * };
+ * // lets pluck some id's into an array...
+ * maybePush(getProp(model, 'item.properties.sourceId'), []);
+ * // > ['3ef']
+ *
+ * // now try to get a value from a property that is missing...
+ * maybePush(getProp(obj, 'item.properties.childId'), []);
+ * // > []
+ *
+ * // easily pluck values via property paths
+ * const summary = [
+ *  'item.id',
+ *  'item.properties.sourceId',
+ *  'item.properties.childId',
+ *  'data.parcelLayer.itemId'].reduce((acc, prop) => {
+ *   return maybePush(getProp(model, key), acc);
+ * }, []);
+ *
+ * // summary => ['c00', '3ef', '7ca']
+ *
+ * ```
+ *
+ * @param val - the possibly null value
+ * @param target - the array to add the value to
+ */
+export declare function maybePush(val: any, target: any[]): any[];
+/**
+ * Convert a string to camelCase
+ *
+ * @export
+ * @param {string} value
+ * @returns {string} camelCased string
+ */
+export declare function camelize(value: string): string;
+/**
+ * Determines if a value is unique in an array
+ * Allows for code like:
+ *
+ * ```js
+ * const ary = [ 1, 2, 3, 3, 4, 5, 1 ];
+ *
+ * const result = ary.filter(unique);
+ *
+ * result => [ 1, 2, 3, 4, 5 ]
+ * ```
+ * @param value - the value to search for
+ * @param index - the index of the searched value
+ * @param ary - the array to search
+ * @returns {boolean} - indicating if the value is unique in the array
+ */
+export declare function unique(value: any, index: number, ary: any[]): boolean;
+/**
+ * Return array of unique objects, based on a deep property value
+ *  Note: Property you compare on should be a primative type
+ * @export
+ * @template T
+ * @param {T[]} arr
+ * @param {string} prop
+ * @return {*}  {T[]}
+ */
+export declare function uniqueBy<T>(arr: T[], prop: string): T[];
+/**
+ * Return last element of an array
+ *
+ * @export
+ * @template T
+ * @param {T[]} arr
+ * @return {*}  {T}
+ */
+export declare function last<T>(arr: T[]): T;
+/**
+ * Filter an array by a deep property value
+ *
+ * @export
+ * @template T
+ * @param {T[]} arr
+ * @param {string} prop
+ * @param {unknown} val
+ * @return {*}  {T[]}
+ */
+export declare function filterBy<T>(arr: T[], prop: string, val: unknown): T[];
+/**
+ * Extends the target object with props from the source object, overwriting identically named
+ * props in target with those from source, ignoring null and undefined values; similar to $.extend.
+ * Performs a deep extend by default, unless deep = false is passed as the third arg.
+ *
+ * @param target - the object that will take props from source
+ * @param source - the object from which to take props
+ * @param deep - whether or not to perform a deep (recursive) extend of source
+ */
+export declare function extend(target: {
+    [index: string]: any;
+}, source: {
+    [index: string]: any;
+}, deep?: boolean): {
+    [index: string]: any;
+};
+/**
+ * Add number of days to a given date
+ *
+ * @export
+ * @param {string} date
+ * @param {number} numOfDays
+ * @returns {string} date string with numOfDays added to the given date
+ */
+export declare function addDays(date: string, numOfDays: number): string;
+/**
+ * Returns an array with arrays of the given size.
+ *
+ * @param arr Array to split
+ * @param size Size of every group
+ */
+export declare function chunkArray(arr: any[], size: number): any[][];
+/**
+ * Determine if a value is null or undefined
+ * @param value anything
+ * @returns
+ */
+export declare const isNil: (value: unknown) => boolean;
+/**
+ * Upper case first letter (only) of a string
+ * @param word
+ * @returns Word
+ */
+export declare const capitalize: (word: string) => string;
+/**
+ * An IE-compatible stand-in for Javascript's [array.flat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat)
+ * @param arr the array
+ * @returns an array
+ */
+export declare function flattenArray(arr: any[]): any[];

package/dist/types/utils/batch.d.ts

@@ -0,0 +1,10 @@
+import { IBatch, IBatchTransform } from "../types";
+/**
+ * Helper to split a large number of calls into
+ * smaller batches of concurrent calls.
+ * @param {Array} values Any array of values with which to invoke fn
+ * @param {Function} fn The function that will be invoked with each value
+ * @param {number} [batchSize=5] The number of concurrent calls to fn, defaults to 5
+ * @returns {Promise<IBatch[]>}
+ */
+export declare function batch(values: IBatch, fn: IBatchTransform, batchSize?: number): Promise<any>;

package/dist/types/utils/create-operation-pipeline.d.ts

@@ -0,0 +1,32 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import OperationStack from "../OperationStack";
+import { IHubRequestOptions } from "../types";
+/**
+ * Container type for Piping in Hub
+ */
+export interface IPipeable<Type> {
+    data: Type;
+    stack: OperationStack;
+    requestOptions?: IHubRequestOptions | IRequestOptions;
+}
+/**
+ * Signature of a function that can be used with createOperationPipeline
+ */
+export declare type PipelineFn<T> = (value: IPipeable<T>) => Promise<IPipeable<T>>;
+/**
+ * Returns a function that orchestrates a pipeline of smaller functions.
+ * See [Composing Workflows](../../../guides/composing-workflows) for more information.
+ *
+ * All the functions must adhere to the `PipelineFn<T>` signature:
+ *
+ * `(value: IPipeable<T>) => Promise<IPipeable<T>>`
+ *
+ * Given an array of OperationPipeFns, run them in sequence and return the resultant promise
+ *
+ * i.e. `createOperationPipeline([fn1, fn2, f3])` will return in a function that chains
+ * the functions like this: `fn1(input).then(fn2).then(fn3).then(result)`
+ *
+ * @param fns functions to be run in sequence
+ * @returns Promise<Pipable<T>>
+ */
+export declare const createOperationPipeline: <T>(fns: PipelineFn<T>[]) => (input: IPipeable<T>) => Promise<IPipeable<T>>;

package/dist/types/utils/ensure-unique-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given an array of strings, add a value and ensure it is unique by incrementing a suffix number
+ * @param {Array} entries array of strings
+ * @param {string} value string to uniqueify and add
+ */
+export declare function ensureUniqueString(entries: string[], value: string): string;

package/dist/types/utils/fail-safe.d.ts

@@ -0,0 +1,7 @@
+import { GenericAsyncFunc } from "../types";
+/**
+ * Wrap an async function such that it will never reject
+ * @param {Function} fn Async Function that we want to never fail
+ * @param {Object} resolveWith Object to resolve with in the event of a failure
+ */
+export declare function failSafe(fn: GenericAsyncFunc, resolveWith?: any): GenericAsyncFunc;

package/dist/types/utils/generate-random-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a random string of a specified length
+ * User when we need to ensure a unique domain with a fixed length
+ * @param {Number} chars Length of random string
+ */
+export declare function generateRandomString(chars: number): string;

package/dist/types/utils/get-hub-product.d.ts

@@ -0,0 +1,8 @@
+export declare type HubProduct = "premium" | "portal" | "basic";
+/**
+ * Gien a portal settings object, determine the hub product name
+ * @param {Object} portal Portal settings object
+ */
+export declare function getHubProduct(portal: {
+    [index: string]: any;
+}): HubProduct;

package/dist/types/utils/get-subscription-type.d.ts

@@ -0,0 +1,2 @@
+import { IPortal } from "@esri/arcgis-rest-portal";
+export declare const getSubscriptionType: (portalSelf: IPortal) => any;

package/dist/types/utils/includes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks whether a value exists in the given array
+ * @param array The array
+ * @param val The value
+ */
+export declare function includes(array: any[], val: any): boolean;

package/dist/types/utils/increment-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given a string, append a `- 1` on the end if no number is present
+ * otherwise, increment the number
+ * @param {string} str String to increment
+ */
+export declare function incrementString(str: string): string;

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

@@ -0,0 +1,18 @@
+export * from "./batch";
+export * from "./ensure-unique-string";
+export * from "./create-operation-pipeline";
+export * from "./fail-safe";
+export * from "./generate-random-string";
+export * from "./get-hub-product";
+export * from "./get-subscription-type";
+export * from "./includes";
+export * from "./is-guid";
+export * from "./map-by";
+export * from "./slugify";
+export * from "./without-by-prop";
+export * from "./propify-string";
+export * from "./increment-string";
+export * from "./logger";
+export * from "./is-update-group";
+export * from "./revertable-tasks";
+export * from "./sessionLocalStorage";

package/dist/types/utils/is-guid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Is a String a GUID?
+ * @param {string} stringToTest string to check if it's a GUID
+ */
+export declare function isGuid(stringToTest: string): boolean;

package/dist/types/utils/is-update-group.d.ts

@@ -0,0 +1,6 @@
+import { IGroup } from "@esri/arcgis-rest-types";
+/**
+ * Determines if a given IGroup is an update group
+ * @param {IGroup} group The group to evaluate
+ */
+export declare function isUpdateGroup(group: IGroup): boolean;

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Enum for Logger Levels
+ */
+export declare enum Level {
+    all = 0,
+    debug = 1,
+    info = 2,
+    warn = 3,
+    error = 4,
+    off = 5
+}
+/**
+ * ```js
+ * import { Logger, Level } from '@esri/hub-common'
+ * ```
+ * Functions share the console interface
+ * ```js
+ * Logger.log('My Message');
+ * Logger.warn('Watch out!', { threat: 'Charizard' });
+ * // etc, etc
+ * ```
+ * Available logging levels are specified in the Level enum. The hierarchy is as follows:
+ * ```
+ * off > error > warn > info > debug > all
+ * ```
+ * Logger only sends messages whose level is greater than or equal to the global log level
+ * ```js
+ * // Global level is 'warn'
+ * Logger.info('This message won't log');
+ * Logger.error('But this one will!');
+ * ```
+ * Logger's default level is 'off', so set desired level before use
+ * ```js
+ * Logger.setLogLevel(Level.all);
+ * ```
+ */
+export declare class Logger {
+    private static logLevel;
+    /**
+     * Sets the global log level
+     * @param {Level} level
+     */
+    static setLogLevel(level: Level): void;
+    /**
+     * Logs to debug if level is enabled
+     * @param {string} message
+     * @param {...*} objects additional objects to log (optional rest parameter)
+     */
+    static log(message: string, ...objects: any[]): void;
+    /**
+     * Logs to debug if level is enabled
+     * @param {string} message
+     * @param {...*} objects additional objects to log (optional rest parameter)
+     */
+    static debug(message: string, ...objects: any[]): void;
+    /**
+     * Logs to info if level is enabled
+     * @param {string} message
+     * @param {...*} objects additional objects to log (optional rest parameter)
+     */
+    static info(message: string, ...objects: any[]): void;
+    /**
+     * Logs to warn if level is enabled
+     * @param {string} message
+     * @param {...*} objects additional objects to log (optional rest parameter)
+     */
+    static warn(message: string, ...objects: any[]): void;
+    /**
+     * Logs to error if level is enabled
+     * @param {string} message
+     * @param {...*} objects additional objects to log (optional rest parameter)
+     */
+    static error(message: string, ...objects: any[]): void;
+    private static isLevelPermitted;
+}

package/dist/types/utils/map-by.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Map over an array returning the specified property for each entry
+ * @param {String} prop Property to extracct
+ * @param {Array} arr array of objects
+ */
+export declare function mapBy(prop: string, arr?: any): any;

package/dist/types/utils/propify-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given a string, strip out chars etc that would make it
+ * and invalid javascript property name, then camelize it.
+ * @param {string} value String to convert into a property
+ */
+export declare function propifyString(value: string): string;

package/dist/types/utils/revertable-tasks.d.ts

@@ -0,0 +1,17 @@
+import { IRevertableTaskResult } from "../types";
+/**
+ * Runs the given task and returns a IRevertableTaskResult
+ * @param {Function} task A task method to run
+ * @param {Function} revert A method to revert the task
+ * @returns {Promise<IRevertableTaskResult>}
+ */
+export declare const runRevertableTask: (task: (...args: any[]) => Promise<any>, revert: (...args: any[]) => Promise<any>) => Promise<IRevertableTaskResult>;
+/**
+ * Processes an Array of Promise<IRevertableTaskResult>. When all IRevertableTaskResult
+ * are IRevertableTaskSuccess, it resolves an Array of all result values. If any
+ * IRevertableTaskResult are IRevertableTaskFailed, it reverts all IRevertableTaskSuccess
+ * and rejects with the first IRevertableTaskFailed error
+ * @param revertableTasks
+ * @returns {Promise<any[]>}
+ */
+export declare const processRevertableTasks: (revertableTasks: Array<Promise<IRevertableTaskResult>>) => Promise<any[]>;

package/dist/types/utils/sessionLocalStorage.d.ts

@@ -0,0 +1,23 @@
+import { UserSession } from "@esri/arcgis-rest-auth";
+/**
+ * Remove any serialized sessions associated with the passed clientId
+ * from a browser's local storage
+ * @param clientId oAuth Client Id
+ * @param win optional window (used for testing)
+ */
+export declare function clearSession(clientId: string, win?: any): void;
+/**
+ * Re-hydrate a UserSession from a browser's local storage.
+ * If not found,
+ * @param clientId oAuth Client Id
+ * @param win optional window (used for testing)
+ * @returns
+ */
+export declare function getSession(clientId: string, win?: any): UserSession | null;
+/**
+ * Serialize a UserSession into a browser's local storage
+ * @param clientId oAuth Client Id
+ * @param session UserSession
+ * @param win optional window (used for testing)
+ */
+export declare function saveSession(clientId: string, session: UserSession, win?: any): void;

package/dist/types/utils/slugify.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Perform the following operations on a string to make it slug-friendly:
+ * 1. trim it
+ * 2. convert to lowercase
+ * 3. remove any character not a-z, 0-9, or _
+ * 4. dasherize it
+ * @param {String} value String to slugify
+ */
+export declare function slugify<T>(value: T): T;

package/dist/types/utils/without-by-prop.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a new array with all the entries have the given value
+ * at the given prop location removed.
+ *
+ * @param prop the property
+ * @param val the value
+ * @param arr the array
+ */
+export declare function withoutByProp(prop: string, val: any, arr: any[]): any[];