@dynamic-labs/utils 0.18.10 → 0.18.11

package/CHANGELOG.md

@@ -1,4 +1,13 @@
 
+### [0.18.11](https://github.com/dynamic-labs/DynamicAuth/compare/v0.18.10...v0.18.11) (2023-08-29)
+
+
+### Bug Fixes
+
+* **bridge:** connect L2 wallet after updating network ([#3162](https://github.com/dynamic-labs/DynamicAuth/issues/3162)) ([6a90668](https://github.com/dynamic-labs/DynamicAuth/commit/6a906687d793fdfa03df87895f9c44b7a5e099dc))
+* resend magic OTP on back click ([#3123](https://github.com/dynamic-labs/DynamicAuth/issues/3123)) ([#3150](https://github.com/dynamic-labs/DynamicAuth/issues/3150)) ([bcba905](https://github.com/dynamic-labs/DynamicAuth/commit/bcba905f22e796c122bb3bb156ec0e0f2a8fb3c6))
+* **WagmiConnector:** sync wagmi with wallet connector events ([#3161](https://github.com/dynamic-labs/DynamicAuth/issues/3161)) ([7cd1da1](https://github.com/dynamic-labs/DynamicAuth/commit/7cd1da173ff7fca50cf2e92e0fad4dfbe651717c)), closes [#3149](https://github.com/dynamic-labs/DynamicAuth/issues/3149)
+
 ### [0.18.10](https://github.com/dynamic-labs/DynamicAuth/compare/v0.18.9...v0.18.10) (2023-08-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/utils",
-  "version": "0.18.10",
+  "version": "0.18.11",
   "repository": {
     "type": "git",
     "url": "https://github.com/dynamic-labs/DynamicAuth.git",
@@ -26,7 +26,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@dynamic-labs/types": "0.18.10"
+    "@dynamic-labs/logger": "0.18.11",
+    "@dynamic-labs/types": "0.18.11"
   },
   "peerDependencies": {}
 }

package/src/CancellablePromise/CancellablePromise.cjs

@@ -2,32 +2,134 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var logger = require('../logger/logger.cjs');
+
+/* eslint-disable multiline-comment-style */
+const defaultCancel = () => {
+    logger.logger.error("Tried to cancel CancellablePromise without ever assigning it's '_cancel' method");
+};
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
 class CancellablePromise extends Promise {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    internalCancel(reason) {
+        defaultCancel();
+    }
     constructor(executor) {
+        let superReject = defaultCancel;
+        let superResolve = () => { };
         super((resolve, reject) => {
-            executor((val) => {
-                if (this.isCancelled)
-                    return;
-                resolve(val);
-            }, (err) => {
-                if (this.isCancelled)
-                    return;
-                reject(err);
-            });
+            superReject = reject;
+            superResolve = resolve;
+        });
+        this.internalIsCancelled = false;
+        this.isSettled = false;
+        executor((value) => {
+            if (!this.isCancelled && !this.isSettled)
+                superResolve(value);
+            this.isSettled = true;
+        }, (reason) => {
+            if (!this.isCancelled && !this.isSettled)
+                superReject(reason);
+            this.isSettled = true;
         });
-        this._controller = new AbortController();
+        this.internalCancel = superReject;
     }
+    /** Whether this CancellablePromise was cancelled. */
     get isCancelled() {
-        return this._controller.signal.aborted;
+        return this.internalIsCancelled;
     }
-    cancel() {
-        this._controller.abort();
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason) {
+        if (this.isSettled)
+            return this;
+        this.internalIsCancelled = true;
+        this.internalCancel(reason);
+        this.isSettled = true;
+        return this;
     }
-    static fromPromise(promise) {
-        return new CancellablePromise((resolve, reject) => {
-            promise.then(resolve).catch(reject);
+    internalOnCancel(listener, options) {
+        const newPromise = new CancellablePromise((resolve, reject) => {
+            this.internalThen(resolve, ({ wasCancelled, reason }) => {
+                if (wasCancelled)
+                    resolve(listener(reason));
+                else
+                    reject(reason);
+            }, { ignoreOnCancel: true });
+        });
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel(listener) {
+        return this.internalOnCancel(listener);
+    }
+    internalThen(onFulfilled, onRejected, options) {
+        /** Create a catch handler that is undefined if the received callback is undefined */
+        const catchHandler = onRejected
+            ? (reason) => onRejected({ reason, wasCancelled: this.isCancelled })
+            : onRejected;
+        // /** Create the CancellablePromise we will returned, associated to the then promise */
+        const newPromise = CancellablePromise.fromPromise(super.then(onFulfilled, catchHandler));
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    then(onFulfilled, onRejected) {
+        return this.internalThen(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+        return this.then((value) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            return value;
+        }, (reason) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            throw reason;
         });
     }
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise(promise) {
+        if ('internalIsCancelled' in promise)
+            return promise;
+        const newPromise = new CancellablePromise((resolve, reject) => promise.then(resolve, reject));
+        return newPromise;
+    }
 }
 
 exports.CancellablePromise = CancellablePromise;

package/src/CancellablePromise/CancellablePromise.d.ts

@@ -1,9 +1,54 @@
 type Executor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void;
+type CancelListener<TResult = never> = (reason?: unknown) => TResult;
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
 export declare class CancellablePromise<T> extends Promise<T> {
-    _controller: AbortController;
+    private internalIsCancelled;
+    private isSettled;
+    private internalCancel;
     constructor(executor: Executor<T>);
+    /** Whether this CancellablePromise was cancelled. */
     get isCancelled(): boolean;
-    cancel(): void;
-    static fromPromise<T>(promise: Promise<T>): CancellablePromise<T>;
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason?: unknown): this;
+    private internalOnCancel;
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel<TResult = never>(listener: CancelListener<TResult>): CancellablePromise<T | TResult>;
+    private internalThen;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: {
+        reason: unknown;
+        wasCancelled: boolean;
+    }) => TResult2 | PromiseLike<TResult2>) | null): CancellablePromise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: {
+        reason: unknown;
+        wasCancelled: boolean;
+    }) => TResult | PromiseLike<TResult>) | null): CancellablePromise<T | TResult>;
+    finally(onFinally?: (() => void) | null): CancellablePromise<T>;
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise<T>(promise: Promise<T> | CancellablePromise<T>): CancellablePromise<T>;
 }
 export {};

package/src/CancellablePromise/CancellablePromise.js

@@ -1,29 +1,131 @@
+import { logger } from '../logger/logger.js';
+
+/* eslint-disable multiline-comment-style */
+const defaultCancel = () => {
+    logger.error("Tried to cancel CancellablePromise without ever assigning it's '_cancel' method");
+};
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
 class CancellablePromise extends Promise {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    internalCancel(reason) {
+        defaultCancel();
+    }
     constructor(executor) {
+        let superReject = defaultCancel;
+        let superResolve = () => { };
         super((resolve, reject) => {
-            executor((val) => {
-                if (this.isCancelled)
-                    return;
-                resolve(val);
-            }, (err) => {
-                if (this.isCancelled)
-                    return;
-                reject(err);
-            });
+            superReject = reject;
+            superResolve = resolve;
+        });
+        this.internalIsCancelled = false;
+        this.isSettled = false;
+        executor((value) => {
+            if (!this.isCancelled && !this.isSettled)
+                superResolve(value);
+            this.isSettled = true;
+        }, (reason) => {
+            if (!this.isCancelled && !this.isSettled)
+                superReject(reason);
+            this.isSettled = true;
         });
-        this._controller = new AbortController();
+        this.internalCancel = superReject;
     }
+    /** Whether this CancellablePromise was cancelled. */
     get isCancelled() {
-        return this._controller.signal.aborted;
+        return this.internalIsCancelled;
     }
-    cancel() {
-        this._controller.abort();
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason) {
+        if (this.isSettled)
+            return this;
+        this.internalIsCancelled = true;
+        this.internalCancel(reason);
+        this.isSettled = true;
+        return this;
     }
-    static fromPromise(promise) {
-        return new CancellablePromise((resolve, reject) => {
-            promise.then(resolve).catch(reject);
+    internalOnCancel(listener, options) {
+        const newPromise = new CancellablePromise((resolve, reject) => {
+            this.internalThen(resolve, ({ wasCancelled, reason }) => {
+                if (wasCancelled)
+                    resolve(listener(reason));
+                else
+                    reject(reason);
+            }, { ignoreOnCancel: true });
+        });
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel(listener) {
+        return this.internalOnCancel(listener);
+    }
+    internalThen(onFulfilled, onRejected, options) {
+        /** Create a catch handler that is undefined if the received callback is undefined */
+        const catchHandler = onRejected
+            ? (reason) => onRejected({ reason, wasCancelled: this.isCancelled })
+            : onRejected;
+        // /** Create the CancellablePromise we will returned, associated to the then promise */
+        const newPromise = CancellablePromise.fromPromise(super.then(onFulfilled, catchHandler));
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    then(onFulfilled, onRejected) {
+        return this.internalThen(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+        return this.then((value) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            return value;
+        }, (reason) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            throw reason;
         });
     }
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise(promise) {
+        if ('internalIsCancelled' in promise)
+            return promise;
+        const newPromise = new CancellablePromise((resolve, reject) => promise.then(resolve, reject));
+        return newPromise;
+    }
 }
 
 export { CancellablePromise };

package/src/index.cjs

@@ -24,6 +24,7 @@ var isFunction = require('./isFunction/isFunction.cjs');
 var isMobile = require('./isMobile.cjs');
 var localStorageAsync = require('./localStorageAsync.cjs');
 var bufferToBase64 = require('./bufferToBase64.cjs');
+var last = require('./last.cjs');
 
 
 
@@ -57,3 +58,4 @@ exports.getItemAsync = localStorageAsync.getItemAsync;
 exports.removeItemAsync = localStorageAsync.removeItemAsync;
 exports.setItemAsync = localStorageAsync.setItemAsync;
 exports.bufferToBase64 = bufferToBase64.bufferToBase64;
+exports.last = last.last;

package/src/index.d.ts

@@ -6,3 +6,4 @@ export * from './isFunction';
 export * from './isMobile';
 export * from './localStorageAsync';
 export * from './bufferToBase64';
+export * from './last';

package/src/index.js

@@ -20,3 +20,4 @@ export { isFunction } from './isFunction/isFunction.js';
 export { isAndroid, isIOS, isIPad, isIPhone, isLegacySafari, isMobile, isSamsungBrowser } from './isMobile.js';
 export { getItemAsync, removeItemAsync, setItemAsync } from './localStorageAsync.js';
 export { bufferToBase64 } from './bufferToBase64.js';
+export { last } from './last.js';

package/src/last.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Retrieves the last item from an array.
+ *
+ * @template T - The type of the items in the array.
+ * @param {T[]} arr - The array from which to retrieve the last item.
+ * @returns {T | undefined} The last item in the array, or undefined if the array is empty.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * console.log(last(numbers));  // Outputs: 5
+ *
+ * const emptyArray: number[] = [];
+ * console.log(last(emptyArray));  // Outputs: undefined
+ */
+const last = (arr) => arr.length > 0 ? arr[arr.length - 1] : undefined;
+
+exports.last = last;

package/src/last.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Retrieves the last item from an array.
+ *
+ * @template T - The type of the items in the array.
+ * @param {T[]} arr - The array from which to retrieve the last item.
+ * @returns {T | undefined} The last item in the array, or undefined if the array is empty.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * console.log(last(numbers));  // Outputs: 5
+ *
+ * const emptyArray: number[] = [];
+ * console.log(last(emptyArray));  // Outputs: undefined
+ */
+export declare const last: <T>(arr: T[]) => T | undefined;

package/src/last.js

@@ -0,0 +1,17 @@
+/**
+ * Retrieves the last item from an array.
+ *
+ * @template T - The type of the items in the array.
+ * @param {T[]} arr - The array from which to retrieve the last item.
+ * @returns {T | undefined} The last item in the array, or undefined if the array is empty.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * console.log(last(numbers));  // Outputs: 5
+ *
+ * const emptyArray: number[] = [];
+ * console.log(last(emptyArray));  // Outputs: undefined
+ */
+const last = (arr) => arr.length > 0 ? arr[arr.length - 1] : undefined;
+
+export { last };

package/src/logger/index.d.ts

@@ -0,0 +1 @@
+export * from './logger';

package/src/logger/logger.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('magic');
+
+exports.logger = logger;

package/src/logger/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/logger/logger.js

@@ -0,0 +1,5 @@
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('magic');
+
+export { logger };