@capsitech/react-utilities 0.1.4 → 0.1.5

package/lib/Utilities/CustomEventEmitter.d.ts

@@ -1,12 +1,12 @@
-export interface ICustomEventEmitter<EventNames = string> {
-    on: (event: EventNames, callback: Function) => void;
-    off: (event: EventNames, callback: Function) => void;
-    emit: (event: EventNames, ...params: any) => void;
-}
-export declare class CustomEventEmitter implements ICustomEventEmitter {
-    private events;
-    constructor();
-    on: (event: string, callback: Function) => void;
-    off: (event: string, callback: Function) => void;
-    emit: (event: string, ...params: any[]) => void;
-}
+export interface ICustomEventEmitter<EventNames = string> {
+    on: (event: EventNames, callback: Function) => void;
+    off: (event: EventNames, callback: Function) => void;
+    emit: (event: EventNames, ...params: any) => void;
+}
+export declare class CustomEventEmitter implements ICustomEventEmitter {
+    private events;
+    constructor();
+    on: (event: string, callback: Function) => void;
+    off: (event: string, callback: Function) => void;
+    emit: (event: string, ...params: any[]) => void;
+}

package/lib/Utilities/CustomEventEmitter.js

@@ -1,30 +1,30 @@
-export class CustomEventEmitter {
-    events;
-    constructor() {
-        this.events = {};
-    }
-    on = (event, callback) => {
-        if (!this.events[event]) {
-            this.events[event] = [];
-        }
-        this.events[event].push(callback);
-    };
-    off = (event, callback) => {
-        if (!this.events[event]) {
-            return;
-        }
-        const index = this.events[event].indexOf(callback);
-        this.events[event].splice(index, 1);
-    };
-    emit = (event, ...params) => {
-        if (!this.events[event]) {
-            return;
-        }
-        this.events[event].forEach((callback) => {
-            //callback(params);
-            if (callback) {
-                callback.apply(null, params);
-            }
-        });
-    };
-}
+export class CustomEventEmitter {
+    events;
+    constructor() {
+        this.events = {};
+    }
+    on = (event, callback) => {
+        if (!this.events[event]) {
+            this.events[event] = [];
+        }
+        this.events[event].push(callback);
+    };
+    off = (event, callback) => {
+        if (!this.events[event]) {
+            return;
+        }
+        const index = this.events[event].indexOf(callback);
+        this.events[event].splice(index, 1);
+    };
+    emit = (event, ...params) => {
+        if (!this.events[event]) {
+            return;
+        }
+        this.events[event].forEach((callback) => {
+            //callback(params);
+            if (callback) {
+                callback.apply(null, params);
+            }
+        });
+    };
+}

package/lib/Utilities/FastCompare.d.ts

@@ -1 +1 @@
-export declare function fastCompare(a: any, b: any): boolean;
+export declare function fastCompare(a: any, b: any): boolean;

package/lib/Utilities/FastCompare.js

@@ -1,128 +1,128 @@
-var hasElementType = typeof Element !== 'undefined';
-var hasMap = typeof Map === 'function';
-var hasSet = typeof Set === 'function';
-var hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;
-function deepEqual(a, b) {
-    // START: fast-deep-equal es6/index.js 3.1.1
-    if (a === b)
-        return true;
-    if (a && b && typeof a == 'object' && typeof b == 'object') {
-        if (a.constructor !== b.constructor)
-            return false;
-        let length, i;
-        if (Array.isArray(a)) {
-            length = a.length;
-            if (length != b.length)
-                return false;
-            for (i = length; i-- !== 0;)
-                if (!deepEqual(a[i], b[i]))
-                    return false;
-            return true;
-        }
-        // START: Modifications:
-        // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code
-        //    to co-exist with es5.
-        // 2. Replace `for of` with es5 compliant iteration using `for`.
-        //    Basically, take:
-        //
-        //    ```js
-        //    for (i of a.entries())
-        //      if (!b.has(i[0])) return false;
-        //    ```
-        //
-        //    ... and convert to:
-        //
-        //    ```js
-        //    it = a.entries();
-        //    while (!(i = it.next()).done)
-        //      if (!b.has(i.value[0])) return false;
-        //    ```
-        //
-        //    **Note**: `i` access switches to `i.value`.
-        let it;
-        if (hasMap && a instanceof Map && b instanceof Map) {
-            if (a.size !== b.size)
-                return false;
-            let it = a.entries();
-            while (!(i = it.next()).done)
-                if (!b.has(i.value[0]))
-                    return false;
-            it = a.entries();
-            while (!(i = it.next()).done)
-                if (!deepEqual(i.value[1], b.get(i.value[0])))
-                    return false;
-            return true;
-        }
-        if (hasSet && a instanceof Set && b instanceof Set) {
-            if (a.size !== b.size)
-                return false;
-            it = a.entries();
-            while (!(i = it.next()).done)
-                if (!b.has(i.value[0]))
-                    return false;
-            return true;
-        }
-        // END: Modifications
-        if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
-            length = a.length;
-            if (length != b.length)
-                return false;
-            for (i = length; i-- !== 0;)
-                if (a[i] !== b[i])
-                    return false;
-            return true;
-        }
-        if (a.constructor === RegExp)
-            return a.source === b.source && a.flags === b.flags;
-        if (a.valueOf !== Object.prototype.valueOf)
-            return a.valueOf() === b.valueOf();
-        if (a.toString !== Object.prototype.toString)
-            return a.toString() === b.toString();
-        const keys = Object.keys(a);
-        length = keys.length;
-        if (length !== Object.keys(b).length)
-            return false;
-        for (i = length; i-- !== 0;)
-            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
-                return false;
-        // custom handling for DOM elements
-        if (hasElementType && a instanceof Element)
-            return false;
-        // custom handling for React/Preact
-        for (i = length; i-- !== 0;) {
-            if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {
-                // React-specific: avoid traversing React elements' _owner
-                // Preact-specific: avoid traversing Preact elements' __v and __o
-                //    __v = $_original / $_vnode
-                //    __o = $_owner
-                // These properties contain circular references and are not needed when
-                // comparing the actual elements (and not their owners)
-                // .$$typeof and ._store on just reasonable markers of elements
-                continue;
-            }
-            // all other properties should be traversed as usual
-            if (!deepEqual(a[keys[i]], b[keys[i]]))
-                return false;
-        }
-        return true;
-    }
-    return a !== a && b !== b;
-}
-export function fastCompare(a, b) {
-    try {
-        return deepEqual(a, b);
-    }
-    catch (error) {
-        if ((error.message || '').match(/stack|recursion/i)) {
-            // warn on circular references, don't crash
-            // browsers give this different errors name and messages:
-            // chrome/safari: "RangeError", "Maximum call stack size exceeded"
-            // firefox: "InternalError", too much recursion"
-            // edge: "Error", "Out of stack space"
-            console.warn('react-fast-compare cannot handle circular refs');
-            return false;
-        }
-        // some other error. we should definitely know about these
-        throw error;
-    }
-}
+var hasElementType = typeof Element !== 'undefined';
+var hasMap = typeof Map === 'function';
+var hasSet = typeof Set === 'function';
+var hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;
+function deepEqual(a, b) {
+    // START: fast-deep-equal es6/index.js 3.1.1
+    if (a === b)
+        return true;
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+        if (a.constructor !== b.constructor)
+            return false;
+        let length, i;
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (!deepEqual(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        // START: Modifications:
+        // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code
+        //    to co-exist with es5.
+        // 2. Replace `for of` with es5 compliant iteration using `for`.
+        //    Basically, take:
+        //
+        //    ```js
+        //    for (i of a.entries())
+        //      if (!b.has(i[0])) return false;
+        //    ```
+        //
+        //    ... and convert to:
+        //
+        //    ```js
+        //    it = a.entries();
+        //    while (!(i = it.next()).done)
+        //      if (!b.has(i.value[0])) return false;
+        //    ```
+        //
+        //    **Note**: `i` access switches to `i.value`.
+        let it;
+        if (hasMap && a instanceof Map && b instanceof Map) {
+            if (a.size !== b.size)
+                return false;
+            let it = a.entries();
+            while (!(i = it.next()).done)
+                if (!b.has(i.value[0]))
+                    return false;
+            it = a.entries();
+            while (!(i = it.next()).done)
+                if (!deepEqual(i.value[1], b.get(i.value[0])))
+                    return false;
+            return true;
+        }
+        if (hasSet && a instanceof Set && b instanceof Set) {
+            if (a.size !== b.size)
+                return false;
+            it = a.entries();
+            while (!(i = it.next()).done)
+                if (!b.has(i.value[0]))
+                    return false;
+            return true;
+        }
+        // END: Modifications
+        if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (a[i] !== b[i])
+                    return false;
+            return true;
+        }
+        if (a.constructor === RegExp)
+            return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+            return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+            return a.toString() === b.toString();
+        const keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+                return false;
+        // custom handling for DOM elements
+        if (hasElementType && a instanceof Element)
+            return false;
+        // custom handling for React/Preact
+        for (i = length; i-- !== 0;) {
+            if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {
+                // React-specific: avoid traversing React elements' _owner
+                // Preact-specific: avoid traversing Preact elements' __v and __o
+                //    __v = $_original / $_vnode
+                //    __o = $_owner
+                // These properties contain circular references and are not needed when
+                // comparing the actual elements (and not their owners)
+                // .$$typeof and ._store on just reasonable markers of elements
+                continue;
+            }
+            // all other properties should be traversed as usual
+            if (!deepEqual(a[keys[i]], b[keys[i]]))
+                return false;
+        }
+        return true;
+    }
+    return a !== a && b !== b;
+}
+export function fastCompare(a, b) {
+    try {
+        return deepEqual(a, b);
+    }
+    catch (error) {
+        if ((error.message || '').match(/stack|recursion/i)) {
+            // warn on circular references, don't crash
+            // browsers give this different errors name and messages:
+            // chrome/safari: "RangeError", "Maximum call stack size exceeded"
+            // firefox: "InternalError", too much recursion"
+            // edge: "Error", "Out of stack space"
+            console.warn('react-fast-compare cannot handle circular refs');
+            return false;
+        }
+        // some other error. we should definitely know about these
+        throw error;
+    }
+}

package/lib/Utilities/HideablePromise.d.ts

@@ -1,5 +1,5 @@
-export declare class HideablePromise<T = any> extends Promise<T> {
-    hide?: () => void;
-    id?: string | number;
-    cancel(): void;
-}
+export declare class HideablePromise<T = any> extends Promise<T> {
+    hide?: () => void;
+    id?: string | number;
+    cancel(): void;
+}

package/lib/Utilities/HideablePromise.js

@@ -1,10 +1,10 @@
-export class HideablePromise extends Promise {
-    hide;
-    id;
-    //cancel the operation
-    cancel() {
-        if (this.hide) {
-            this.hide();
-        }
-    }
-}
+export class HideablePromise extends Promise {
+    hide;
+    id;
+    //cancel the operation
+    cancel() {
+        if (this.hide) {
+            this.hide();
+        }
+    }
+}

package/lib/Utilities/LoadScripts.d.ts

@@ -1,9 +1,9 @@
-interface ILoadScriptOptions {
-    type?: string;
-    charset?: string;
-    async?: boolean;
-    attrs?: any[];
-    text?: string;
-}
-export declare const LoadScript: (src: string, opts?: ILoadScriptOptions | Function, callback?: Function) => void;
-export {};
+interface ILoadScriptOptions {
+    type?: string;
+    charset?: string;
+    async?: boolean;
+    attrs?: any[];
+    text?: string;
+}
+export declare const LoadScript: (src: string, opts?: ILoadScriptOptions | Function, callback?: Function) => void;
+export {};

package/lib/Utilities/LoadScripts.js

@@ -1,51 +1,51 @@
-export const LoadScript = (src, opts, callback) => {
-    var head = document.head || document.getElementsByTagName('head')[0];
-    var script = document.createElement('script');
-    if (typeof opts === 'function') {
-        callback = opts;
-        opts = {};
-    }
-    opts = opts || {};
-    callback = callback || function () { };
-    script.type = opts.type || 'text/javascript';
-    script.charset = opts.charset || 'utf8';
-    script.async = 'async' in opts ? !!opts.async : true;
-    script.src = src;
-    if (opts.attrs) {
-        for (var attr in opts.attrs) {
-            script.setAttribute(attr, opts.attrs[attr]);
-        }
-    }
-    if (opts.text) {
-        script.text = '' + opts.text;
-    }
-    var onend = 'onload' in script ? stdOnEnd : ieOnEnd;
-    onend(script, callback);
-    // some good legacy browsers (firefox) fail the 'in' detection above
-    // so as a fallback we always set onload
-    // old IE will ignore this and new IE will set onload
-    if (!script.onload) {
-        stdOnEnd(script, callback);
-    }
-    head.appendChild(script);
-};
-function stdOnEnd(script, callback) {
-    script.onload = function () {
-        this.onerror = this.onload = null;
-        callback(null, script);
-    };
-    script.onerror = function () {
-        // this.onload = null here is necessary
-        // because even IE9 works not like others
-        this.onerror = this.onload = null;
-        callback(new Error('Failed to load ' + this.src), script);
-    };
-}
-function ieOnEnd(script, callback) {
-    script.onreadystatechange = function () {
-        if (this.readyState !== 'complete' && this.readyState !== 'loaded')
-            return;
-        this.onreadystatechange = null;
-        callback(null, script); // there is no way to catch loading errors in IE8
-    };
-}
+export const LoadScript = (src, opts, callback) => {
+    var head = document.head || document.getElementsByTagName('head')[0];
+    var script = document.createElement('script');
+    if (typeof opts === 'function') {
+        callback = opts;
+        opts = {};
+    }
+    opts = opts || {};
+    callback = callback || function () { };
+    script.type = opts.type || 'text/javascript';
+    script.charset = opts.charset || 'utf8';
+    script.async = 'async' in opts ? !!opts.async : true;
+    script.src = src;
+    if (opts.attrs) {
+        for (var attr in opts.attrs) {
+            script.setAttribute(attr, opts.attrs[attr]);
+        }
+    }
+    if (opts.text) {
+        script.text = '' + opts.text;
+    }
+    var onend = 'onload' in script ? stdOnEnd : ieOnEnd;
+    onend(script, callback);
+    // some good legacy browsers (firefox) fail the 'in' detection above
+    // so as a fallback we always set onload
+    // old IE will ignore this and new IE will set onload
+    if (!script.onload) {
+        stdOnEnd(script, callback);
+    }
+    head.appendChild(script);
+};
+function stdOnEnd(script, callback) {
+    script.onload = function () {
+        this.onerror = this.onload = null;
+        callback(null, script);
+    };
+    script.onerror = function () {
+        // this.onload = null here is necessary
+        // because even IE9 works not like others
+        this.onerror = this.onload = null;
+        callback(new Error('Failed to load ' + this.src), script);
+    };
+}
+function ieOnEnd(script, callback) {
+    script.onreadystatechange = function () {
+        if (this.readyState !== 'complete' && this.readyState !== 'loaded')
+            return;
+        this.onreadystatechange = null;
+        callback(null, script); // there is no way to catch loading errors in IE8
+    };
+}

package/lib/Utilities/MTDFraudPrevention.d.ts

@@ -1,28 +1,28 @@
-interface IHeaderValues {
-    headers?: Record<string, string>;
-    errors?: any[];
-}
-/**
- * Enum object of keys for each header in the Map returned by getFraudPreventionHeaders().headers
- */
-export declare const fraudPreventionHeadersEnum: {
-    TIMEZONE: string;
-    SCREENS_DETAILS: string;
-    WINDOW_SIZE: string;
-};
-export declare const getScreenDetails: () => {
-    width: number | null;
-    height: number | null;
-    colorDepth: number | null;
-    scalingFactor: number | null;
-};
-export declare const windowDetails: () => {
-    width: number | null;
-    height: number | null;
-};
-/**
- * Returns Map of HMRC Fraud prevention headers.
- * @returns {Promise<IHeaderValues>} with two fields headers and errors - The headers are a Map object and the errors are an array. If there are no errors, the array is empty
- */
-export declare const getFraudPreventionHeaders: () => Promise<IHeaderValues>;
-export {};
+interface IHeaderValues {
+    headers?: Record<string, string>;
+    errors?: any[];
+}
+/**
+ * Enum object of keys for each header in the Map returned by getFraudPreventionHeaders().headers
+ */
+export declare const fraudPreventionHeadersEnum: {
+    TIMEZONE: string;
+    SCREENS_DETAILS: string;
+    WINDOW_SIZE: string;
+};
+export declare const getScreenDetails: () => {
+    width: number | null;
+    height: number | null;
+    colorDepth: number | null;
+    scalingFactor: number | null;
+};
+export declare const windowDetails: () => {
+    width: number | null;
+    height: number | null;
+};
+/**
+ * Returns Map of HMRC Fraud prevention headers.
+ * @returns {Promise<IHeaderValues>} with two fields headers and errors - The headers are a Map object and the errors are an array. If there are no errors, the array is empty
+ */
+export declare const getFraudPreventionHeaders: () => Promise<IHeaderValues>;
+export {};