@microsoft/1ds-core-js 3.2.12 → 4.0.1

package/dist-esm/src/DataModels.d.ts

@@ -1,273 +0,0 @@
-/**
- * DataModels.ts
- * @author Abhilash Panwar (abpanwar) Hector Hernandez (hectorh)
- * @copyright Microsoft 2018
- * File containing the interfaces for Web JS SDK.
- */
-import { ITelemetryItem, IConfiguration, IAppInsightsCore } from "@microsoft/applicationinsights-core-js";
-import { EventLatencyValue, EventPersistenceValue, EventSendType, FieldValueSanitizerType } from "./Enums";
-/**
- * An interface used to create an event property value along with tagging it as PII, or customer content.
- * <b>Caution:</b> Customer content and PII are mutually exclusive. You can use only one of them at a time.
- * If you use both, then the property will be considered invalid, and therefore won't be sent.
- */
-export interface IEventProperty {
-    /**
-     * The value for the property.
-     */
-    value: string | number | boolean | string[] | number[] | boolean[];
-    /**
-     * [Optional] The value kind associated with property value. The constant enum ValueKind should be used to specify the
-     * different kinds.
-     */
-    kind?: number;
-    /**
-     * [Optional] The data type for the property. Valid values accepted by onecollector are
-     * "string", "bool", "double", "int64", "datetime", "guid".
-     *  The EventPropertyType constant enum should be used to specify the different property type values.
-     */
-    propertyType?: number;
-}
-/**
- * An interface used to create an event, along with its name, properties, type, timestamp, and priority.
- */
-export interface IExtendedTelemetryItem extends ITelemetryItem {
-    /**
-     * Properties to be captured about the telemetry item.
-     * Custom properties (alternatively referred to as Part C properties for a Common Schema event) can be
-     * directly added under data.
-     */
-    data?: {
-        [key: string]: string | number | boolean | string[] | number[] | boolean[] | IEventProperty | object;
-    };
-    /**
-     * Telemetry properties pertaining to domain about which data is being captured. Example, duration, referrerUri for browser page.
-     * These are alternatively referred to as Part B properties for a Common Schema event.
-     */
-    baseData?: {
-        [key: string]: string | number | boolean | string[] | number[] | boolean[] | IEventProperty | object;
-    };
-    /**
-     * An EventLatency value, that specifies the latency for the event.The EventLatency constant should be
-     * used to specify the different latency values.
-     */
-    latency?: number | EventLatencyValue;
-    /**
-     * [Optional] An EventPersistence value, that specifies the persistence for the event. The EventPersistence constant
-     * should be used to specify the different persistence values.
-     */
-    persistence?: number | EventPersistenceValue;
-    /**
-     * [Optional] A boolean that specifies whether the event should be sent as a sync request.
-     */
-    sync?: boolean | EventSendType;
-    /**
-     * [Optional] A timings object.
-     */
-    timings?: IEventTiming;
-}
-/**
- * The IExtendedConfiguration interface holds the configuration details passed to core during initialize.
- */
-export interface IExtendedConfiguration extends IConfiguration {
-    /**
-     * [Optional] The property storage override that should be used to store
-     * internal SDK properties, otherwise stored as cookies. It is needed where cookies are not available.
-     */
-    propertyStorageOverride?: IPropertyStorageOverride;
-    /**
-     * [Optional] A boolean that indicated whether to disable the use of cookies by the 1DS Web SDK. The cookies added by the SDK are
-     * MicrosoftApplicationsTelemetryDeviceId. If cookies are disabled, then session events are not sent unless propertyStorageOverride
-     * is provided to store the values elsewhere.
-     */
-    disableCookiesUsage?: boolean;
-    /**
-     * [Optional] Name of the Anon cookie.  The value will be set in the qsp header to collector requests.  Collector will use this value to look for specific cookie to use for anid property.
-     */
-    anonCookieName?: string;
-    /**
-     * [Optional] Disables additional internal event timings that are added during processing of events, the timings are not sent as part telemetry items to the server
-     */
-    disableEventTimings?: boolean;
-    /**
-     * [Optional] Enables support for objects with compound keys which indirectly represent an object where the "key" of the object contains a "." as part of it's name.
-     * @example
-     * ```typescript
-     * event: { "somedata.embeddedvalue": 123 }
-     * ```
-     */
-    enableCompoundKey?: boolean;
-    /**
-     * [Optional] An array of the page unload events that you would like to be ignored, special note there must be at least one valid unload
-     * event hooked, if you list all or the runtime environment only supports a listed "disabled" event it will still be hooked, if required by the SDK.
-     * Unload events include "beforeunload", "unload", "visibilitychange" (with 'hidden' state) and "pagehide"
-     */
-    disablePageUnloadEvents?: string[];
-    /**
-     * [Optional] An array of page show events that you would like to be ignored, special note there must be at lease one valid show event
-     * hooked, if you list all or the runtime environment only supports a listed (disabled) event it will STILL be hooked, if required by the SDK.
-     * Page Show events include "pageshow" and "visibilitychange" (with 'visible' state)
-     */
-    disablePageShowEvents?: string[];
-    /**
-     * Add "&w=0" parameter to support UA Parsing when web-workers don't have access to Document.
-     * Default is false
-     */
-    enableWParam?: boolean;
-}
-/**
- * An interface used for telemetry event timings.
- */
-export interface IEventTiming {
-    /**
-     * Time when 1DS Core calls track
-     */
-    trackStart?: number;
-    /**
-     * Array of times when each plugin configured in 1DS calls processTelemetry method
-     */
-    processTelemetryStart?: {
-        [key: string]: number;
-    };
-    /**
-     * Array of times when a specific channel tried to send the telemetry to configured endpoint
-     */
-    sendEventStart?: {
-        [key: string]: number;
-    };
-    /**
-     * Array of times when a specific channel received a response from endpoint or request timed out
-     */
-    sendEventCompleted?: {
-        [key: string]: number;
-    };
-    /**
-     * Array of times when a specific channel started serialization of the telemetry event
-     */
-    serializationStart?: {
-        [key: string]: number;
-    };
-    /**
-     * Array of times when a specific channel completed serialization of the telemetry event
-     */
-    serializationCompleted?: {
-        [key: string]: number;
-    };
-}
-/**
- * The IPropertyStorageOverride interface provides a custom interface for storing internal SDK properties - otherwise they are
- * stored as cookies.
- * You need this interface when you intend to run auto collection for common properties, or when you log a session in
- * a non browser environment.
- */
-export interface IPropertyStorageOverride {
-    /**
-     * A function for passing key value pairs to be stored.
-     * @param key   - The key for the key value pair.
-     * @param value - The value for the key value pair.
-     */
-    setProperty: (key: string, value: string) => void;
-    /**
-     * A function that gets a value for a given key.
-     * @param key - The key for which the value must be fetched.
-     */
-    getProperty: (key: string) => string;
-}
-export interface IExtendedAppInsightsCore extends IAppInsightsCore {
-    /**
-     * [Optional] Get method to retrieve w parameter
-     */
-    getWParam?: () => number;
-}
-export type FieldValueSanitizerFunc = (details: IFieldSanitizerDetails) => IEventProperty | null;
-export type FieldValueSanitizerTypes = string | number | boolean | object | string[] | number[] | boolean[] | IEventProperty;
-/**
- * This interface defines the object that is passed to any provided FieldValueSanitizerFunc, it provides not only the value to be sanitized but also
- * some context about the value like it's location within the envelope (serialized object), the format is defined via the
- * [Common Schema 4.0](https://1dsdocs.azurewebsites.net/schema/README.html) specification.
- */
-export interface IFieldSanitizerDetails {
-    /**
-     * The path within the event where the value is stored
-     */
-    path: string;
-    /**
-     * The name of the field with the event path that will store the value
-     */
-    name: string;
-    /**
-     * Identifies the type of the property value
-     */
-    type: FieldValueSanitizerType;
-    /**
-     * The value for the property.
-     */
-    prop: IEventProperty;
-    /**
-     * A reference to the value sanitizer that created the details
-     */
-    sanitizer: IValueSanitizer;
-}
-/**
- * This interface is used during the serialization of individual fields when converting the events into envelope (serialized object) which is sent to the services,
- * the format is defined via the [Common Schema 4.0](https://1dsdocs.azurewebsites.net/schema/README.html) specification. The path and field names used are based
- * on how the data is serialized to the service (CS 4.0 location) and not specifically the location on the event object you pass into the track methods (unless they are the same).
- */
-export interface IFieldValueSanitizerProvider {
-    /**
-     * Does this field value sanitizer handle this path / field combination
-     * @param path - The field path
-     * @param name - The name of the field
-     */
-    handleField(path: string, name: string): boolean;
-    /**
-     * Get the field sanitizer for this type of field based on the field type, value kind and/or event property type
-     * @param path - The field path
-     * @param name - The name of the field
-     * @param theType - The type of field
-     * @param theKind - The value kind of the field
-     * @param propType - The property type of the field
-     */
-    getSanitizer(path: string, name: string, theType: FieldValueSanitizerType, theKind?: number, propType?: number): FieldValueSanitizerFunc | null | undefined;
-}
-/**
- * This interface is used during the serialization of events into envelope (serialized object) which is sent to the services, the format is defined via the
- * [Common Schema 4.0](https://1dsdocs.azurewebsites.net/schema/README.html) specification. The path and field names used are based on how the data is serialized
- * to the service (CS 4.0 location) and not specifically the location on the event object you pass into the track methods (unless they are the same).
- */
-export interface IValueSanitizer {
-    /**
-     * Add a value sanitizer as a fallback sanitizer if this sanitizer can't handle the path/name.
-     */
-    addSanitizer: (sanitizer: IValueSanitizer) => void;
-    /**
-     * Adds a field sanitizer to the evaluation list
-     */
-    addFieldSanitizer: (fieldSanitizer: IFieldValueSanitizerProvider) => void;
-    /**
-     * Does this field value sanitizer handle this path / field combination
-     * @param path - The field path
-     * @param name - The name of the field
-     */
-    handleField: (path: string, name: string) => boolean;
-    /**
-     * Sanitizes the value. It checks the that the property name and value are valid. It also
-     * checks/populates the correct type and pii of the property value.
-     * @param path - The root path of the property
-     * @param name - The property name.
-     * @param value - The property value or an IEventProperty containing value, type ,pii and customer content.
-     * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
-     * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
-     */
-    value: (path: string, name: string, value: FieldValueSanitizerTypes, stringifyObjects?: boolean) => IEventProperty | null;
-    /**
-     * Sanitizes the Property. It checks the that the property name and value are valid. It also
-     * checks/populates the correct type and pii of the property value.
-     * @param path - The root path of the property
-     * @param name - The property name.
-     * @param property - The property value or an IEventProperty containing value, type ,pii and customer content.
-     * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
-     * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
-     */
-    property: (path: string, name: string, property: IEventProperty, stringifyObjects?: boolean) => IEventProperty | null;
-}

package/dist-esm/src/ESPromise.d.ts

@@ -1,110 +0,0 @@
-/**
-* ESPromise.ts
-* @author  Nev Wylie (newylie))
-* @copyright Microsoft 2019
-* Simplified wrapper to provide ES6 style Promise callback handling for older browsers
-*/
-/**
- * This defines the handler function for when a promise is resolved.
- * @param value This is the value passed as part of resolving the Promise
- * @return This may return a value, another Promise or void. See [[then]] for how the value is handled.
- */
-export type ESPromiseOnResolvedFunc<T> = (value: T) => T | ESPromise<T | any> | void;
-/**
- * This defines the handler function for when a promise is rejected.
- * @param value This is the value passed as part of resolving the Promise
- * @return This may return a value, another Promise or void. @see then for how the value is handled.
- */
-export type ESPromiseOnRejectedFunc<T> = (reason: any) => T | ESPromise<T | any> | void;
-/**
- * Defines the signature of the resolve function passed to the resolverFunc (in the Promise constructor)
- * @param value The value to resolve the Promise with
- * @returns Nothing
- */
-export type ResolverResolveFunc<T> = (value?: T | void) => void;
-/**
- * Defines the signature of the reject function passed to the resolverFunc (in the Promise constructor)
- * @param value The value to reject the Promise with
- * @returns Nothing
- */
-export type ResolverRejectFunc<T> = (reason?: T | Error | void) => void;
-/**
- * Simplified wrapper to provide ES6 style Promise callback handling for older browsers
- */
-export default class ESPromise<T> {
-    /**
-     * The Promise.resolve() method returns a Promise object that is resolved with a given value. If the value is a promise, that promise is returned;
-     * if the value is a thenable (i.e. has a "then" method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise
-     * the returned promise will be fulfilled with the value. This function flattens nested layers of promise-like objects (e.g. a promise that resolves
-     * to a promise that resolves to something) into a single layer.
-     * @param value Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve.
-     */
-    static resolve<T>(value?: any): ESPromise<any>;
-    /**
-     * The Promise.reject() method returns a Promise object that is rejected with a given reason.
-     * @param reason The reason why this Promise rejected.
-     */
-    static reject<T>(reason?: T | Error | void): ESPromise<T>;
-    /**
-     * The Promise.all() method returns a single Promise that resolves when all of the promises passed as an iterable
-     * have resolved or when the iterable contains no promises. It rejects with the reason of the first promise that
-     * rejects. There is no implied ordering in the execution of the array of Promises given. On some computers, they
-     * may be executed in parallel, or in some sense concurrently, while on others they may be executed serially. For
-     * this reason, there must be no dependency in any Promise on the order of execution of the Promises.
-     * This method can be useful for aggregating the results of multiple promises.
-     * FulfillmentSection - The returned promise is fulfilled with an array containing all the values of the iterable
-     * passed as argument (also non-promise values).
-     * If an empty iterable is passed, then this method returns (synchronously) an already resolved promise.
-     * If all of the passed-in promises fulfill, or are not promises, the promise returned by Promise.all is fulfilled
-     * asynchronously.
-     * RejectionSection - If any of the passed-in promises reject, Promise.all asynchronously rejects with the value of
-     * the promise that rejected, whether or not the other promises have resolved.
-     * @param iterable
-     */
-    static all<T>(iterable: any[]): ESPromise<T>;
-    /**
-     * The race function returns a Promise that is settled the same way (and takes the same value) as the first promise
-     * that settles amongst the promises of the iterable passed as an argument.
-     * If the iterable passed is empty, the promise returned will be forever pending.
-     * If the iterable contains one or more non-promise value and/or an already settled promise, then Promise.race will
-     * resolve to the first of these values found in the iterable.
-     * @param iterable
-     */
-    static race<T>(iterable: any[]): ESPromise<T>;
-    /**
-     * The Promise object represents the eventual completion (or failure) of an asynchronous operation, and its resulting value.
-     * @param resolverFunc A function that is passed with the arguments resolve and reject. The executor function is executed
-     * immediately by the Promise implementation, passing resolve and reject functions (the executor is called before the Promise
-     * constructor even returns the created object). The resolve and reject functions, when called, resolve or reject the promise,
-     * respectively. The executor normally initiates some asynchronous work, and then, once that completes, either calls the resolve
-     * function to resolve the promise or else rejects it if an error occurred. If an error is thrown in the executor function, the
-     * promise is rejected. The return value of the executor is ignored.
-     */
-    constructor(resolverFunc: (resolve: ResolverResolveFunc<T>, reject: ResolverRejectFunc<T>) => void);
-    /**
-     * The then() method returns a Promise. It takes up to two arguments: callback functions for the success and failure cases of the Promise.
-     * @param onResolved A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value. If it is not a
-     * function, it is internally replaced with an "Identity" function (it returns the received argument).
-     * @param onRejected A Function called if the Promise is rejected. This function has one argument, the rejection reason. If it is not a
-     * function, it is internally replaced with a "Thrower" function (it throws an error it received as argument).
-     * @returns Once a Promise is fulfilled or rejected, the respective handler function (onFulfilled or onRejected) will be called asynchronously
-     * (scheduled in the current thread loop). The behavior of the handler function follows a specific set of rules. If a handler function:
-     * - returns a value, the promise returned by then gets resolved with the returned value as its value;
-     * - doesn't return anything, the promise returned by then gets resolved with an undefined value;
-     * - throws an error, the promise returned by then gets rejected with the thrown error as its value;
-     * - returns an already fulfilled promise, the promise returned by then gets fulfilled with that promise's value as its value;
-     * - returns an already rejected promise, the promise returned by then gets rejected with that promise's value as its value;
-     * - returns another pending promise object, the resolution/rejection of the promise returned by then will be subsequent to the
-     * resolution/rejection of the promise returned by the handler. Also, the value of the promise returned by then will be the same as the value of the promise returned by the handler.
-     */
-    then(onResolved: ESPromiseOnResolvedFunc<T>, onRejected?: ESPromiseOnRejectedFunc<T>): ESPromise<T>;
-    /**
-     * The catch() method returns a Promise and deals with rejected cases only. It behaves the same as calling Promise.prototype.then(undefined, onRejected)
-     * (in fact, calling obj.catch(onRejected) internally calls obj.then(undefined, onRejected)). This means that you have to provide an onRejected function
-     * even if you want to fall back to an undefined result value - for example obj.catch(() => {}).
-     * @param onRejected A Function called when the Promise is rejected. This function has one argument: reason The rejection reason.
-     * @returns Internally calls Promise.prototype.then on the object upon which it was called, passing the parameters undefined and the received
-     * onRejected handler. Returns the value of that call, which is a Promise.
-     */
-    catch(onRejected: ESPromiseOnRejectedFunc<T>): ESPromise<T>;
-}

package/dist-esm/src/ESPromise.js

@@ -1,286 +0,0 @@
-/*
- * 1DS JS SDK Core, 3.2.12
- * Copyright (c) Microsoft and contributors. All rights reserved.
- * (Microsoft Internal Only)
- */
-/**
-* ESPromise.ts
-* @author  Nev Wylie (newylie))
-* @copyright Microsoft 2019
-* Simplified wrapper to provide ES6 style Promise callback handling for older browsers
-*/
-import dynamicProto from "@microsoft/dynamicproto-js";
-import { isFunction } from "@microsoft/applicationinsights-core-js";
-/**
- * @ignore -- Don't include in the generated documentation
- * Using a local variable to assist with minfication
- */
-var _isFunction = isFunction;
-/**
- * @ignore -- Don't include in the generated documentation
- * This function will be used as onFulfilled handler for any Promise found in the iterable passed to Promise.all.
- * The goal here is to capture in a closure the index of the current item from the iterable. If we did not create
- * this closure, the captured index variable would be the same one that the for loop updates and thus would always
- * be pointing to the last index in the iterable by the time that the onFulfilled handler is called.
- * However, note that for the resolvedCallback callback we want the opposite. For this one we do want to capture
- * the same variable that the for loop updates so that we have the full count of pending promises by the time
- * the onFulfilled handlers start getting called.
- * @param values The resolving promise values
- * @param index The index of this callback function
- * @param resolvedCallback THe callback function used to check if the "all" promise is complete
- */
-function _createPromiseAllOnResolvedFunction(values, index, resolvedCallback) {
-    return function (value) {
-        values[index] = value;
-        resolvedCallback();
-    };
-}
-/**
- * Simplified wrapper to provide ES6 style Promise callback handling for older browsers
- */
-var ESPromise = /** @class */ (function () {
-    /**
-     * The Promise object represents the eventual completion (or failure) of an asynchronous operation, and its resulting value.
-     * @param resolverFunc A function that is passed with the arguments resolve and reject. The executor function is executed
-     * immediately by the Promise implementation, passing resolve and reject functions (the executor is called before the Promise
-     * constructor even returns the created object). The resolve and reject functions, when called, resolve or reject the promise,
-     * respectively. The executor normally initiates some asynchronous work, and then, once that completes, either calls the resolve
-     * function to resolve the promise or else rejects it if an error occurred. If an error is thrown in the executor function, the
-     * promise is rejected. The return value of the executor is ignored.
-     */
-    function ESPromise(resolverFunc) {
-        var _state = 0 /* PromiseState.Pending */;
-        var _settledValue = null;
-        var _queue = [];
-        dynamicProto(ESPromise, this, function (_this) {
-            _this.then = function (onResolved, onRejected) {
-                return new ESPromise(function (resolve, reject) {
-                    // Queue the new promise returned to be resolved or rejected
-                    // when this promise settles.
-                    _enqueue(onResolved, onRejected, resolve, reject);
-                });
-            };
-            _this["catch"] = function (onRejected) {
-                return _this.then(null, onRejected);
-            };
-        });
-        function _enqueue(onResolved, onRejected, resolve, reject) {
-            _queue.push(function () {
-                var value;
-                try {
-                    // First call the onFulfilled or onRejected handler, on the settled value
-                    // of this promise. If the corresponding handler does not exist, simply
-                    // pass through the settled value.
-                    if (_state === 1 /* PromiseState.Resolved */) {
-                        value = _isFunction(onResolved) ? onResolved(_settledValue) : _settledValue;
-                    }
-                    else {
-                        value = _isFunction(onRejected) ? onRejected(_settledValue) : _settledValue;
-                    }
-                    if (value instanceof ESPromise) {
-                        // The called handlers returned a new promise, so the chained promise
-                        // will follow the state of this promise.
-                        value.then(resolve, reject);
-                    }
-                    else if (_state === 2 /* PromiseState.Rejected */ && !_isFunction(onRejected)) {
-                        // If there wasn't an onRejected handler and this promise is rejected, then
-                        // the chained promise also rejects with the same reason.
-                        reject(value);
-                    }
-                    else {
-                        // If this promise is fulfilled, then the chained promise is also fulfilled
-                        // with either the settled value of this promise (if no onFulfilled handler
-                        // was available) or the return value of the handler. If this promise is
-                        // rejected and there was an onRejected handler, then the chained promise is
-                        // fulfilled with the return value of the handler.
-                        resolve(value);
-                    }
-                }
-                catch (error) {
-                    // The chained promise will reject if there is any exception thrown while
-                    // calling the onFulfilled or onRejected handlers.
-                    reject(error);
-                    return;
-                }
-            });
-            // If this promise is already settled, then immediately process the callback we
-            // just added to the queue.
-            if (_state !== 0 /* PromiseState.Pending */) {
-                _processQueue();
-            }
-        }
-        function _processQueue() {
-            if (_queue.length > 0) {
-                // The onFulfilled and onRejected handlers must be called asynchronously. Thus,
-                // we make a copy of the queue and work on it once the current call stack unwinds.
-                var pending_1 = _queue.slice();
-                _queue = [];
-                setTimeout(function () {
-                    for (var i = 0, len = pending_1.length; i < len; ++i) {
-                        try {
-                            pending_1[i]();
-                        }
-                        catch (e) {
-                            // Don't let 1 failing handler break all others
-                            // TODO (newylie): Add some form of error reporting (i.e. Call any registered JS error handler so the error is reported)
-                        }
-                    }
-                }, 0);
-            }
-        }
-        function _resolve(value) {
-            if (_state === 0 /* PromiseState.Pending */) {
-                _settledValue = value;
-                _state = 1 /* PromiseState.Resolved */;
-                _processQueue();
-            }
-        }
-        function _reject(reason) {
-            if (_state === 0 /* PromiseState.Pending */) {
-                _settledValue = reason;
-                _state = 2 /* PromiseState.Rejected */;
-                _processQueue();
-            }
-        }
-        (function _initialize() {
-            if (!_isFunction(resolverFunc)) {
-                throw new TypeError("ESPromise: resolvedFunc argument is not a Function");
-            }
-            try {
-                resolverFunc(_resolve, _reject);
-            }
-            catch (error) {
-                // This promise will immediately reject if any exception is thrown
-                // from within the executor function.
-                _reject(error);
-            }
-        })();
-    }
-    /**
-     * The Promise.resolve() method returns a Promise object that is resolved with a given value. If the value is a promise, that promise is returned;
-     * if the value is a thenable (i.e. has a "then" method), the returned promise will "follow" that thenable, adopting its eventual state; otherwise
-     * the returned promise will be fulfilled with the value. This function flattens nested layers of promise-like objects (e.g. a promise that resolves
-     * to a promise that resolves to something) into a single layer.
-     * @param value Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve.
-     */
-    ESPromise.resolve = function (value) {
-        if (value instanceof ESPromise) {
-            // Value is a Promise so just return it
-            return value;
-        }
-        else if (value && _isFunction(value.then)) {
-            // Value looks like a promise or thenable (has a then function)
-            return new ESPromise(function (resolve, reject) {
-                try {
-                    value.then(resolve, reject);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        return new ESPromise(function (resolve) {
-            resolve(value);
-        });
-    };
-    /**
-     * The Promise.reject() method returns a Promise object that is rejected with a given reason.
-     * @param reason The reason why this Promise rejected.
-     */
-    ESPromise.reject = function (reason) {
-        return new ESPromise(function (resolve, reject) {
-            reject(reason);
-        });
-    };
-    /**
-     * The Promise.all() method returns a single Promise that resolves when all of the promises passed as an iterable
-     * have resolved or when the iterable contains no promises. It rejects with the reason of the first promise that
-     * rejects. There is no implied ordering in the execution of the array of Promises given. On some computers, they
-     * may be executed in parallel, or in some sense concurrently, while on others they may be executed serially. For
-     * this reason, there must be no dependency in any Promise on the order of execution of the Promises.
-     * This method can be useful for aggregating the results of multiple promises.
-     * FulfillmentSection - The returned promise is fulfilled with an array containing all the values of the iterable
-     * passed as argument (also non-promise values).
-     * If an empty iterable is passed, then this method returns (synchronously) an already resolved promise.
-     * If all of the passed-in promises fulfill, or are not promises, the promise returned by Promise.all is fulfilled
-     * asynchronously.
-     * RejectionSection - If any of the passed-in promises reject, Promise.all asynchronously rejects with the value of
-     * the promise that rejected, whether or not the other promises have resolved.
-     * @param iterable
-     */
-    ESPromise.all = function (iterable) {
-        if (!iterable || !iterable.length) {
-            return;
-        }
-        return new ESPromise(function (resolve, reject) {
-            try {
-                var values_1 = [];
-                var pending_2 = 0;
-                for (var lp = 0; lp < iterable.length; lp++) {
-                    var item = iterable[lp];
-                    // Quick and direct check for a Promise (will also catch a thenable)
-                    if (item && _isFunction(item.then)) {
-                        pending_2++;
-                        item.then(_createPromiseAllOnResolvedFunction(values_1, lp, function () {
-                            if (--pending_2 === 0) {
-                                resolve(values_1);
-                            }
-                        }), reject);
-                    }
-                    else {
-                        values_1[lp] = item;
-                    }
-                }
-                if (pending_2 === 0) {
-                    // All promises were either resolved or where not a promise
-                    setTimeout(function () {
-                        resolve(values_1);
-                    }, 0);
-                }
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    };
-    /**
-     * The race function returns a Promise that is settled the same way (and takes the same value) as the first promise
-     * that settles amongst the promises of the iterable passed as an argument.
-     * If the iterable passed is empty, the promise returned will be forever pending.
-     * If the iterable contains one or more non-promise value and/or an already settled promise, then Promise.race will
-     * resolve to the first of these values found in the iterable.
-     * @param iterable
-     */
-    ESPromise.race = function (iterable) {
-        return new ESPromise(function (resolve, reject) {
-            if (!iterable || !iterable.length) {
-                return;
-            }
-            try {
-                var _loop_1 = function (lp) {
-                    var item = iterable[lp];
-                    // Quick and direct check for a Promise (will also catch a thenable)
-                    if (item && _isFunction(item.then)) {
-                        item.then(resolve, reject);
-                    }
-                    else {
-                        setTimeout(function () {
-                            resolve(item);
-                        }, 0);
-                    }
-                };
-                for (var lp = 0; lp < iterable.length; lp++) {
-                    _loop_1(lp);
-                }
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    };
-// Removed Stub for ESPromise.prototype.then.
-// Removed Stub for ESPromise.prototype["catch"].
-    return ESPromise;
-}());
-export default ESPromise;
-//# sourceMappingURL=ESPromise.js.map