@esri/hub-common 9.8.1 → 9.10.1

package/dist/types/util.d.ts

@@ -1,253 +0,0 @@
-/**
- * ```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

@@ -1,10 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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";

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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-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

@@ -1,75 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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/slugify.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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[];