@dynamic-labs/utils 0.18.27 → 0.18.29

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 
+### [0.18.29](https://github.com/dynamic-labs/DynamicAuth/compare/v0.18.28...v0.18.29) (2023-11-13)
+
+
+### Bug Fixes
+
+* **bridge:** disconnect mm when locked offsite ([#3872](https://github.com/dynamic-labs/DynamicAuth/issues/3872)) ([4a34492](https://github.com/dynamic-labs/DynamicAuth/commit/4a344926d2987cd31123b9a5ac9c3dbf1efccbe0))
+* only process oauth message coming from the expected origin ([#3805](https://github.com/dynamic-labs/DynamicAuth/issues/3805)) ([970003c](https://github.com/dynamic-labs/DynamicAuth/commit/970003c81cc101dcca2c4a56c48095303377d8ef))
+
+### [0.18.28](https://github.com/dynamic-labs/DynamicAuth/compare/v0.18.27...v0.18.28) (2023-10-30)
+
+
+### Bug Fixes
+
+* better handling of Coinbase wallet disconnect + upgrade to 3.7.2 ([#3681](https://github.com/dynamic-labs/DynamicAuth/issues/3681)) ([075ca3c](https://github.com/dynamic-labs/DynamicAuth/commit/075ca3c0e6c34e8b75bc80cd1980efebdb41f35a))
+* safely render message to sign ([#3655](https://github.com/dynamic-labs/DynamicAuth/issues/3655)) ([#3660](https://github.com/dynamic-labs/DynamicAuth/issues/3660)) ([c91ff85](https://github.com/dynamic-labs/DynamicAuth/commit/c91ff85fef2616cafae6681ebc9328aac783b294))
+
 ### [0.18.27](https://github.com/dynamic-labs/DynamicAuth/compare/v0.18.26...v0.18.27) (2023-10-19)
 
 

package/package.json

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

package/src/index.cjs

@@ -25,6 +25,7 @@ var isMobile = require('./isMobile.cjs');
 var localStorageAsync = require('./localStorageAsync.cjs');
 var bufferToBase64 = require('./bufferToBase64.cjs');
 var last = require('./last.cjs');
+var retryableFn = require('./retryableFn.cjs');
 
 
 
@@ -59,3 +60,5 @@ exports.removeItemAsync = localStorageAsync.removeItemAsync;
 exports.setItemAsync = localStorageAsync.setItemAsync;
 exports.bufferToBase64 = bufferToBase64.bufferToBase64;
 exports.last = last.last;
+exports.FALLBACK_UNDEFINED = retryableFn.FALLBACK_UNDEFINED;
+exports.retryableFn = retryableFn.retryableFn;

package/src/index.d.ts

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

package/src/index.js

@@ -21,3 +21,4 @@ export { isAndroid, isIOS, isIPad, isIPhone, isLegacySafari, isMobile, isSamsung
 export { getItemAsync, removeItemAsync, setItemAsync } from './localStorageAsync.js';
 export { bufferToBase64 } from './bufferToBase64.js';
 export { last } from './last.js';
+export { FALLBACK_UNDEFINED, retryableFn } from './retryableFn.js';

package/src/retryableFn.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+
+const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
+const retryableFn = (fn, options = {}) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', } = options;
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error('Timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const result = yield Promise.race([fn(), timeoutPromise]);
+        return result;
+    }
+    catch (err) {
+        if (currentRetry >= maxRetries) {
+            if (fallbackValue instanceof Error) {
+                throw fallbackValue;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        const isTimeout = err.message === 'Timeout';
+        const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
+            (retryStrategy === 'timeout-only' && isTimeout) ||
+            (retryStrategy === 'rejection-only' && !isTimeout);
+        if (!shouldRetry) {
+            if (fallbackValue instanceof Error) {
+                throw err;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        return retryableFn(fn, {
+            currentRetry: currentRetry + 1,
+            fallbackValue,
+            maxRetries,
+            retryStrategy,
+            timeoutMs,
+        });
+    }
+});
+
+exports.FALLBACK_UNDEFINED = FALLBACK_UNDEFINED;
+exports.retryableFn = retryableFn;

package/src/retryableFn.d.ts

@@ -0,0 +1,14 @@
+export declare const FALLBACK_UNDEFINED = "FALLBACK_UNDEFINED";
+export type RetryableFnOptions<T> = {
+    /** Maximum number of retry attempts before returning fallbackValue */
+    maxRetries?: number;
+    /** Internal only. Do not use */
+    currentRetry?: number;
+    /** Timeout in ms to wait before executing retryStrategy */
+    timeoutMs?: number;
+    /** The value to fallback to when function rejects or times out */
+    fallbackValue?: T | Error | typeof FALLBACK_UNDEFINED;
+    /** Configure whether the fn should be retried only on timeout, only on rejection, or both */
+    retryStrategy?: 'timeout-only' | 'rejection-only' | 'timeout-and-rejection';
+};
+export declare const retryableFn: <T>(fn: () => Promise<T>, options?: RetryableFnOptions<T>) => Promise<T>;

package/src/retryableFn.js

@@ -0,0 +1,48 @@
+import { __awaiter } from '../_virtual/_tslib.js';
+
+const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
+const retryableFn = (fn, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', } = options;
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error('Timeout'));
+        }, timeoutMs);
+    });
+    try {
+        const result = yield Promise.race([fn(), timeoutPromise]);
+        return result;
+    }
+    catch (err) {
+        if (currentRetry >= maxRetries) {
+            if (fallbackValue instanceof Error) {
+                throw fallbackValue;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        const isTimeout = err.message === 'Timeout';
+        const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
+            (retryStrategy === 'timeout-only' && isTimeout) ||
+            (retryStrategy === 'rejection-only' && !isTimeout);
+        if (!shouldRetry) {
+            if (fallbackValue instanceof Error) {
+                throw err;
+            }
+            else if (fallbackValue === FALLBACK_UNDEFINED) {
+                return undefined;
+            }
+            return fallbackValue;
+        }
+        return retryableFn(fn, {
+            currentRetry: currentRetry + 1,
+            fallbackValue,
+            maxRetries,
+            retryStrategy,
+            timeoutMs,
+        });
+    }
+});
+
+export { FALLBACK_UNDEFINED, retryableFn };