si-funciona 2.0.0 → 2.0.2

package/dist/helpers/arrays/addUniqueToArray.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+/**
+ * Having an array and a potential new array element, check if the element is in the array, if not append to array.
+ * @function
+ * @memberOf module:arrayHelpers
+ * @param {*} item - An potential array element, possibly a DomItem
+ * @param {Array} array - An array where an element may be appended.
+ * @returns {Array}
+ */
+declare const addUniqueToArray: (item: any, array: Array<any>) => Array<any>;
+export default addUniqueToArray;

package/dist/helpers/arrays/buildArray.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+/**
+ * Leverage buildArrayBase to generate an array filled with a copy of the provided item.
+ * The length defines how long the array should be.
+ * @function
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+declare const buildArray: (item: any, length: number) => Array<any>;
+export default buildArray;

package/dist/helpers/arrays/buildArrayOfReferences.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+/**
+ * Leverage buildArrayBase to generate an array filled with references to the provided item.
+ * The length defines how long the array should be.
+ * @function
+ * @memberOf module:arrayHelpers
+ * @param {*} item - The item to be used for each array element
+ * @param {number} length - The desired length of the array
+ * @returns {Array.<*>}
+ */
+declare const buildArrayOfReferences: (item: any, length: number) => Array<any>;
+export default buildArrayOfReferences;

package/dist/helpers/arrays/compareArrays.d.ts

@@ -0,0 +1,98 @@
+import 'core-js/stable';
+/**
+ * Store the comparison result for an element that may exist in either of compared arrays.
+ * - value stores the element value from the arrays being compared
+ * - results has the comparison results where first index (0) is result for first compared array
+ *   and the second index (1) will be the result for the second compared array
+ * @example
+ * // example of input and resulting output
+ *
+ * const arr1 = ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1']
+ * const arr2 = ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
+ *
+ * // Taking the first element in both, then the value: 'match1' exists in both arrays
+ * // compareArrayResult will be { value: 'match1', result: [0, 0] }
+ * // First index of 0 indicates this value in the first array exists in the second array
+ * // Second index of 0 indicates this value in the second array exists in the first array
+ *
+ * // Taking the second element in the first array, then the value: 'firstMismatch1' exists in only the first array
+ * // compareArrayResult will be { value: 'firstMismatch1', result: [1, -1] }
+ * // First index of 1 indicates this value in the first array might need to be added to the second array
+ * // Second index of -1 indicates this value only exists in the first array
+ *
+ * // Taking the third element in the second array, then the value: 'secondMismatch1' exists in only the second array
+ * // compareArrayResult will be { value: 'secondMismatch1', result: [-1, 1] }
+ * // First index of -1 indicates this value only exists in the second array
+ * // Second index of 1 indicates this value in the second array might need to be added to the first array
+ * @typedef {Object.<string, string|Array.<number>>} module:arrayHelpers~compareArrayResult
+ * @memberOf module:arrayHelpers
+ * @property {string} value - The element value being compared
+ * @property {Array.<Array.<string|number>>} keys - Keys in arrays associated with this value
+ * @property {Array.<number>} result - The results in the order of the compared arrays
+ */
+export type compareArrayResult = {
+    value: string;
+    keys: Array<Array<number | string>>;
+    result: Array<number>;
+};
+export type compareArrayResultMap = Array<compareArrayResult>;
+/**
+ * Compare two Arrays and return the Object where the value for each property is as follows:
+ * -1 to indicate val1 is less than val2
+ * 0 to indicate both values are the equal
+ * 1 to indicate val1 is greater than val2
+ * The returned Object uses the element values as the property names
+ * This functions works by first creating a concatenated array of all unique values. Then for each unique values,
+ * convert to a string and use it as a new property name. Array filter each array checking if it has the unique value.
+ * Use the lengths of these filtered arrays to compare. So if the first array has the value and the second one doesn't
+ * the first length will be one or more and the second will be zero, if the both have the value then both will be one
+ * or more.
+ * @example
+ * // example of input and resulting output
+ * compareArrays(
+ *   ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1'],
+ *   ['match1', 'match2', 'secondMismatch1', 'badMatch1', 'badMatch1']
+ * )
+ * // unique array
+ * ['match1', 'firstMismatch1', 'match2', 'firstMismatch2', 'badMatch1', 'secondMismatch1']
+ * // result object
+ * [
+ *   {
+ *     value: 'match1',
+ *     keys: [[0], [0]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'firstMismatch1',
+ *     keys: [[1], []],
+ *     result: [1, -1]
+ *   },
+ *   {
+ *     value: 'match2',
+ *     keys: [[2], [1]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'firstMismatch2',
+ *     keys: [[3], []],
+ *     result: [1, -1]
+ *   },
+ *   {
+ *     value: 'badMatch1',
+ *     keys: [[4], [3, 4]],
+ *     result: [0, 0]
+ *   },
+ *   {
+ *     value: 'secondMismatch1',
+ *     keys: [[], [2]],
+ *     result: [-1, 1]
+ *   }
+ * ]
+ *
+ * @function
+ * @memberOf module:arrayHelpers
+ * @param {...Array} arrays - The arrays to compare
+ * @returns {Array.<module:arrayHelpers~compareArrayResult>}
+ */
+declare const compareArrays: (...arrays: Array<Array<any>>) => compareArrayResultMap;
+export default compareArrays;

package/dist/helpers/arrays/mergeArrays.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Take multiple arrays and then filter all these into one unique array.
+ * @function
+ * @memberOf module:arrayHelpers
+ * @param {...Array} arrays - Provide multiple arrays to create one unique array
+ * @returns {Array}
+ */
+declare const mergeArrays: (...arrays: Array<Array<any>>) => Array<any>;
+export default mergeArrays;

package/dist/helpers/arrays/uniqueArray.d.ts

@@ -0,0 +1,10 @@
+import 'core-js/stable';
+/**
+ * Remove duplicate values from an array.
+ * @function uniqueArray
+ * @memberOf module:arrayHelpers
+ * @param {Array} array - The array to make unique
+ * @returns {Array}
+ */
+declare const uniqueArray: (array: Array<any>) => Array<any>;
+export default uniqueArray;

package/dist/helpers/arrays.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Some simple utility functions for generating arrays or performing work on arrays.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module arrayHelpers
+ * @memberOf module:siFunciona
+ */
+import 'core-js/stable';
+declare const _default: {
+    addUniqueToArray: (item: any, array: any[]) => any[];
+    buildArray: (item: any, length: number) => any[];
+    buildArrayOfReferences: (item: any, length: number) => any[];
+    compareArrays: (...arrays: any[][]) => import("./arrays/compareArrays").compareArrayResultMap;
+    mergeArrays: (...arrays: any[][]) => any[];
+    uniqueArray: (array: any[]) => any[];
+};
+export default _default;

package/dist/helpers/descriptors/assignDescriptor.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Apply one or more descriptors to an existing descriptor so that they represent a merged version of the descriptors.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} originalMap
+ * @param  {...module:objectDescriptors~descriptor} descriptors
+ * @returns {module:objectDescriptors~descriptor}
+ */
+declare const assignDescriptor: (originalMap: descriptor, ...descriptors: Array<descriptor>) => descriptor;
+export default assignDescriptor;

package/dist/helpers/descriptors/assignDescriptorDetail.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptorDetail } from './samples/descriptorDetail';
+/**
+ * Assign properties from other details onto an existing detail.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptorDetail} originalDetail
+ * @param  {...module:objectDescriptors~descriptorDetail} details
+ * @returns {module:objectDescriptors~descriptorDetail}
+ */
+declare const assignDescriptorDetail: (originalDetail: descriptorDetail, ...details: Array<descriptorDetail>) => descriptorDetail;
+export default assignDescriptorDetail;

package/dist/helpers/descriptors/checkClearValues.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Check if we should clear the values on this descriptor
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} descriptor
+ * @param {boolean} [keepValues=false]
+ * @returns {module:objectDescriptors~descriptor}
+ */
+declare const checkClearValues: (descriptor: descriptor, keepValues?: boolean) => descriptor;
+export default checkClearValues;

package/dist/helpers/descriptors/checkDescriptorComplete.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Check if the descriptors references have all been built and set complete to true if they have.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} descriptor
+ * @returns {module:objectDescriptors~descriptor}
+ */
+declare const checkDescriptorComplete: (descriptor: descriptor) => descriptor;
+export default checkDescriptorComplete;

package/dist/helpers/descriptors/cloneDescriptor.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Make a copy of an object descriptor so that the original will not be mutated.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} originalMap
+ * @returns {module:objectDescriptors~descriptor}
+ */
+declare const cloneDescriptor: (originalMap: descriptor) => descriptor;
+export default cloneDescriptor;

package/dist/helpers/descriptors/cloneDescriptorDetail.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+import { descriptorDetail } from './samples/descriptorDetail';
+/**
+ * Get a new copy of an existing Descriptor Detail
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptorDetail} originalDetail
+ * @returns {module:objectDescriptors~descriptorDetail}
+ */
+declare const cloneDescriptorDetail: (originalDetail: descriptorDetail) => descriptorDetail;
+export default cloneDescriptorDetail;

package/dist/helpers/descriptors/compareDescriptor.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Check if two descriptors are the same or similar in that they have similar keys and the associated types are the same.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} descriptor1
+ * @param {module:objectDescriptors~descriptor} descriptor2
+ * @returns {boolean}
+ */
+declare const compareDescriptor: (descriptor1: descriptor, descriptor2: descriptor) => boolean;
+export default compareDescriptor;

package/dist/helpers/descriptors/describeObject.d.ts

@@ -0,0 +1,14 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+export type describeableObject = Array<any> | {
+    [k: number | string]: any;
+};
+/**
+ * Trace an object and return the descriptor which defines the object's structure and attributes.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {Object} object
+ * @returns {module:objectDescriptors~descriptor}
+ */
+declare const describeObject: (object: describeableObject) => descriptor;
+export default describeObject;

package/dist/helpers/descriptors/describeObjectDetail.d.ts

@@ -0,0 +1,13 @@
+import 'core-js/stable';
+import { descriptorDetail } from './samples/descriptorDetail';
+/**
+ * Trace an object's attribute and provide details about it.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {*} value
+ * @param {string|number} [key=0]
+ * @param {number} [index=0]
+ * @returns {module:objectDescriptors~descriptorDetail}
+ */
+declare const describeObjectDetail: (value: any, key?: number | string, index?: number) => descriptorDetail;
+export default describeObjectDetail;

package/dist/helpers/descriptors/describeObjectMap.d.ts

@@ -0,0 +1,21 @@
+import 'core-js/stable';
+import { describeableObject } from './describeObject';
+import { descriptorMap } from './samples/descriptorMap';
+type describeObjectMapOptions = {
+    mapLimit?: number;
+    depthLimit?: number;
+    keepValues?: boolean;
+};
+/**
+ * Trace out the entire object including nested objects.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {Object|Array} object
+ * @param {Object} [options={}]
+ * @param {number} [options.mapLimit=1000000000]
+ * @param {number} [options.depthLimit=-1]
+ * @param {boolean} [options.keepValues=false]
+ * @returns {module:objectDescriptors~descriptorMap}
+ */
+declare const describeObjectMap: (object: describeableObject, { mapLimit, depthLimit, keepValues }?: describeObjectMapOptions) => descriptorMap;
+export default describeObjectMap;

package/dist/helpers/descriptors/nextReference.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Find the index of the next module:objectDescriptors.descriptorDetail to build a resource for.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} descriptor
+ * @param {number} currentReference
+ * @returns {number|undefined}
+ */
+declare const nextReference: (descriptor: descriptor, currentReference: number) => number | undefined;
+export default nextReference;

package/dist/helpers/descriptors/sameDescriptor.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+import { descriptor } from './samples/descriptor';
+/**
+ * Check if the two descriptors are the same.
+ * @function
+ * @memberOf module:objectDescriptors
+ * @param {module:objectDescriptors~descriptor} descriptor1
+ * @param {module:objectDescriptors~descriptor} descriptor2
+ * @returns {boolean}
+ */
+declare const sameDescriptor: (descriptor1: descriptor, descriptor2: descriptor) => boolean;
+export default sameDescriptor;

package/dist/helpers/descriptors/samples/descriptor.d.ts

@@ -0,0 +1,27 @@
+import { descriptorDetail } from './descriptorDetail';
+/**
+ * @typedef {Object} module:objectDescriptors~descriptor
+ * @memberOf module:objectDescriptors
+ * @property {number} index
+ * @property {Array.<module:objectDescriptors~descriptorDetail>} details
+ * @property {number} length
+ * @property {Array.<string|number>} keys
+ * @property {Array.<number>} references
+ * @property {boolean} isArray
+ * @property {boolean} complete
+ */
+export type descriptor = {
+    index: number;
+    details: Array<descriptorDetail>;
+    length: number;
+    keys: Array<number | string>;
+    references: Array<number>;
+    isArray: boolean;
+    complete: boolean;
+};
+/**
+ * @type {module:objectDescriptors~descriptor}
+ * @memberOf module:objectDescriptors
+ */
+declare const descriptorSample: descriptor;
+export default descriptorSample;

package/dist/helpers/descriptors/samples/descriptorDetail.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @typedef {Object} module:objectDescriptors~descriptorDetail
+ * @memberOf module:objectDescriptors
+ * @property {number} index
+ * @property {string|number} key
+ * @property {Array.<string>} type
+ * @property {Array} value
+ * @property {boolean} nullable
+ * @property {boolean} optional
+ * @property {boolean} circular
+ * @property {boolean} isReference
+ * @property {boolean} isInstance
+ * @property {null|number} arrayReference
+ * @property {null|number} objectReference
+ */
+export type descriptorDetail = {
+    index: number;
+    key: number | string;
+    type: Array<string>;
+    value: Array<any>;
+    nullable: boolean;
+    optional: boolean;
+    circular: boolean;
+    isReference: boolean;
+    isInstance: boolean;
+    arrayReference: number | null;
+    objectReference: number | null;
+};
+/**
+ * @type {module:objectDescriptors~descriptorDetail}
+ * @memberOf module:objectDescriptors
+ */
+declare const descriptorDetailSample: descriptorDetail;
+export default descriptorDetailSample;

package/dist/helpers/descriptors/samples/descriptorMap.d.ts

@@ -0,0 +1,12 @@
+import { descriptor } from './descriptor';
+/**
+ * @typedef {Array.<module:objectDescriptors~descriptor>} module:objectDescriptors~descriptorMap
+ * @memberOf module:objectDescriptors
+ */
+export type descriptorMap = Array<descriptor>;
+/**
+ * @type {module:objectDescriptors~descriptorMap}
+ * @memberOf module:objectDescriptors
+ */
+declare const descriptorMapSample: descriptorMap;
+export default descriptorMapSample;

package/dist/helpers/descriptors/samples/mappedDescriptorMap.d.ts

@@ -0,0 +1,7 @@
+import { descriptorMap } from './descriptorMap';
+/**
+ * @type {module:objectDescriptors~descriptorMap}
+ * @memberOf module:objectDescriptors
+ */
+declare const mappedDescriptorMap: descriptorMap;
+export default mappedDescriptorMap;

package/dist/helpers/descriptors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Create a format to standardize every object into a specific template.
+ * @file
+ * @author Joshua Heagle <joshuaheagle@gmail.com>
+ * @version 1.0.0
+ * @module objectDescriptors
+ * @memberOf module:siFunciona
+ */
+import 'core-js/stable';
+declare const _default: {
+    assignDescriptor: (originalMap: import("./descriptors/samples/descriptor").descriptor, ...descriptors: import("./descriptors/samples/descriptor").descriptor[]) => import("./descriptors/samples/descriptor").descriptor;
+    assignDescriptorDetail: (originalDetail: import("./descriptors/samples/descriptorDetail").descriptorDetail, ...details: import("./descriptors/samples/descriptorDetail").descriptorDetail[]) => import("./descriptors/samples/descriptorDetail").descriptorDetail;
+    checkClearValues: (descriptor: import("./descriptors/samples/descriptor").descriptor, keepValues?: boolean) => import("./descriptors/samples/descriptor").descriptor;
+    checkDescriptorComplete: (descriptor: import("./descriptors/samples/descriptor").descriptor) => import("./descriptors/samples/descriptor").descriptor;
+    cloneDescriptor: (originalMap: import("./descriptors/samples/descriptor").descriptor) => import("./descriptors/samples/descriptor").descriptor;
+    cloneDescriptorDetail: (originalDetail: import("./descriptors/samples/descriptorDetail").descriptorDetail) => import("./descriptors/samples/descriptorDetail").descriptorDetail;
+    compareDescriptor: (descriptor1: import("./descriptors/samples/descriptor").descriptor, descriptor2: import("./descriptors/samples/descriptor").descriptor) => boolean;
+    describeObject: (object: import("./descriptors/describeObject").describeableObject) => import("./descriptors/samples/descriptor").descriptor;
+    describeObjectMap: (object: import("./descriptors/describeObject").describeableObject, { mapLimit, depthLimit, keepValues }?: {
+        mapLimit?: number;
+        depthLimit?: number;
+        keepValues?: boolean;
+    }) => import("./descriptors/samples/descriptorMap").descriptorMap;
+    describeObjectDetail: (value: any, key?: string | number, index?: number) => import("./descriptors/samples/descriptorDetail").descriptorDetail;
+    nextReference: (descriptor: import("./descriptors/samples/descriptor").descriptor, currentReference: number) => number;
+    sameDescriptor: (descriptor1: import("./descriptors/samples/descriptor").descriptor, descriptor2: import("./descriptors/samples/descriptor").descriptor) => boolean;
+};
+export default _default;

package/dist/helpers/functions/callWithParams.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+/**
+ * Given a function, call with the correct number of parameters from an array of possible parameters.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - The function to be called
+ * @param {Array} params - Array of possible function parameters
+ * @param {number} [minimum=2] - Minimum number of parameters to use in the function
+ * @returns {*}
+ */
+declare const callWithParams: (fn: Function, params?: Array<any>, minimum?: number) => any;
+export default callWithParams;

package/dist/helpers/functions/curry.d.ts

@@ -0,0 +1,12 @@
+import 'core-js/stable';
+/**
+ * Return a curried version of the passed function.
+ * The returned function expects the same number of arguments minus the ones provided.
+ * fn is the name of the function being curried.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - Receives a function to be curried
+ * @returns {Function|*}
+ */
+declare const curry: (fn: Function) => Function | any;
+export default curry;

package/dist/helpers/functions/delay.d.ts

@@ -0,0 +1,22 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+/**
+ * Provide a way to cancel a request or attach a resolve event.
+ * @typedef {Object} module:functionHelpers~delayHandler
+ * @memberOf module:functionHelpers
+ * @property {Promise} resolver
+ * @property {Function} cancel
+ */
+type delayHandler = {
+    resolver: Promise<any>;
+    cancel: () => void;
+};
+/**
+ * Provide a timeout which returns a promise.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {number} time - Delay in milliseconds
+ * @returns {module:functionHelpers~delayHandler}
+ */
+declare const delay: (time?: number) => delayHandler;
+export default delay;

package/dist/helpers/functions/onBodyLoad.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+/**
+ * Prepare functions to be called once the body is available.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {Function} callback
+ * @param {boolean} [reset=false]
+ * @returns {Array.<Function>}
+ */
+declare const onBodyLoad: (callback: Function, reset?: boolean) => Array<Function>;
+export default onBodyLoad;

package/dist/helpers/functions/pipe.d.ts

@@ -0,0 +1,11 @@
+import 'core-js/stable';
+/**
+ * Take one or more function with a single parameter and return value.
+ * Pass a parameter and the value will be transformed by each function then returned.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {...Function} fns - Takes a series of functions having the same parameter
+ * @returns {*}
+ */
+declare const pipe: (...fns: Function[]) => any;
+export default pipe;

package/dist/helpers/functions/preloadParams.d.ts

@@ -0,0 +1,21 @@
+import 'core-js/stable';
+/**
+ * The return function which takes the missing parameter in order to call the preloaded function.
+ * @typedef {Function} module:functionHelpers~callWithMissing
+ * @memberOf module:functionHelpers
+ * @param {*} missing - The missing parameter to be applied
+ * @returns {*}
+ */
+type callWithMissing = (missing: any) => any;
+/**
+ * Provide an array of parameters to be used with a function, allow the function to be called later
+ * with the missing parameter.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - The function to be called
+ * @param {Array} params - The parameters to preload
+ * @param {number} [unassignedParam=0] - Position of missing parameter (zero indexed)
+ * @returns {module:functionHelpers~callWithMissing}
+ */
+declare const preloadParams: (fn: Function, params?: Array<any>, unassignedParam?: number) => callWithMissing;
+export default preloadParams;

package/dist/helpers/functions/queueManager.d.ts

@@ -0,0 +1,28 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+/**
+ * Each time queue handle is called the passed function is added to the queue to be called when ready.
+ * @typedef {Function} module:functionHelpers~queueManagerHandle
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - A function to enqueue
+ * @param  {...*} args - Arguments to be passed to the function once it is ready
+ * @returns {Promise}
+ */
+export type queueManagerHandle = (fn: Function, ...args: any) => Promise<any>;
+type callableLater = {
+    fn?: Function;
+    args?: Array<any>;
+};
+export type queuedItem = {
+    item: callableLater;
+    generator: Generator;
+};
+/**
+ * Manage functions to run sequentially.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {Iterable|array} [queue=[]] - The iterable that can be used to store queued functions
+ * @returns {module:functionHelpers~queueManagerHandle}
+ */
+declare const queueManager: (queue?: Array<queuedItem>) => queueManagerHandle;
+export default queueManager;

package/dist/helpers/functions/queueTimeout.d.ts

@@ -0,0 +1,22 @@
+import 'core-js/stable';
+import 'regenerator-runtime/runtime';
+import { queueManagerHandle } from './queueManager';
+/**
+ * Run Timeout functions one after the otherin queue.
+ * @typedef {Function} module:functionHelpers~queueTimeoutHandle
+ * @memberOf module:functionHelpers
+ * @param {Function} fn - A callback function to be performed at some time in the future.
+ * @param {number} time - The time in milliseconds to delay.
+ * @param {...*} args - Arguments to be passed to the callback once it is implemented.
+ * @returns {Promise}
+ */
+type queueTimeoutHandle = (fn: Function, time: number, ...args: any) => Promise<any>;
+/**
+ * Manage functions to run sequentially with delays.
+ * @function
+ * @memberOf module:functionHelpers
+ * @param {module:functionHelpers~queueManagerHandle} [queueManagerHandle=null]
+ * @returns {module:functionHelpers~queueTimeoutHandle}
+ */
+declare const queueTimeout: (queueManagerHandle?: queueManagerHandle) => queueTimeoutHandle;
+export default queueTimeout;