@dynamic-labs/utils 0.0.0-exp20240808.0

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.cjs

@@ -0,0 +1,192 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger = require('../../../logger/logger.cjs');
+
+const providersWithoutWindowOpenerReference = ['twitter'];
+let authWindowInterval;
+const createWindowOauth2Service = () => ({
+    getOauthCode: ({ apiProvider, provider, setIsProcessing, state, oauthLoginUrl, getOAuthResultFromApi, sessionTimeout, isMobile, onSettled, }) => new Promise((resolve, _reject) => {
+        // When we catch this error we assume it follows this type, so we must enforce it
+        // here to ensure the assumption is correct
+        const typedReject = (params) => _reject(params);
+        // Clear any potential pending timeouts and intervals
+        clearInterval(authWindowInterval);
+        const providersWaitingOauthMessage = {};
+        let shouldPool = false;
+        const authWindow = window.open('', '_blank', 'width=500,height=600');
+        const clearListeners = () => {
+            window.removeEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = false;
+        };
+        const handleWindowMessage = (event) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            const message = event.data;
+            const expectedOrigin = getExpectedOrigin(apiProvider, provider);
+            if (!expectedOrigin) {
+                return;
+            }
+            if ((message === null || message === void 0 ? void 0 : message.type) === 'origin_check' && authWindow) {
+                logger.logger.debug('Origin check message received. Sending response now.', {
+                    data: message,
+                    expectedOrigin,
+                });
+                authWindow.postMessage('origin_check_response', expectedOrigin);
+                return;
+            }
+            const isTelegramCompletedMessage = (message === null || message === void 0 ? void 0 : message.type) === 'telegram_completed';
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage || isTelegramCompletedMessage) {
+                logger.logger.debug('Message received', { data: message });
+            }
+            const isExpectedOrigin = event.origin === expectedOrigin;
+            const isValidMessage = ((isAuthorizationMessage && (message === null || message === void 0 ? void 0 : message.provider) === provider) ||
+                isTelegramCompletedMessage) &&
+                isExpectedOrigin;
+            // don't process invalid messages for provider
+            if (!isValidMessage) {
+                return;
+            }
+            setIsProcessing(true);
+            if (!providersWaitingOauthMessage[provider]) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            if (isTelegramCompletedMessage) {
+                handleTelegramCompletionMessage(message);
+                return;
+            }
+            handleAuthorizationMessage(message, provider, state);
+        });
+        const getExpectedOrigin = (apiProvider, provider) => {
+            if (!(apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.redirectUrl)) {
+                return;
+            }
+            let expectedOrigin = window.location.origin;
+            if (!providersWithoutWindowOpenerReference.includes(provider)) {
+                try {
+                    const redirectUri = new URL(apiProvider.redirectUrl);
+                    expectedOrigin = redirectUri.origin;
+                }
+                catch (e) {
+                    logger.logger.error('Failed to parse social provider redirect url', {
+                        error: e,
+                    });
+                    return;
+                }
+            }
+            return expectedOrigin;
+        };
+        const handleTelegramCompletionMessage = (message) => {
+            logger.logger.debug('Telegram completion message received', {
+                data: message,
+            });
+            resolve('telegram_completed');
+            setIsProcessing(false);
+        };
+        const handleAuthorizationMessage = (message, provider, state) => {
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: ${error}`,
+                });
+                return;
+            }
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            // this state check is used only by providers with an open window opener reference (eg, not twitter)
+            if (!providersWithoutWindowOpenerReference.includes(provider) &&
+                state !== authState) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.NO_AUTH_CODE,
+                    message: `Failed to connect ${provider} social account: no authorization code`,
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        if (!providersWaitingOauthMessage[provider]) {
+            window.addEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = true;
+        }
+        authWindow === null || authWindow === void 0 ? void 0 : authWindow.location.assign(oauthLoginUrl);
+        if (!providersWithoutWindowOpenerReference.includes(provider)) {
+            // For provider that support window.opener, we need to clear all states/listeners when the window is closed
+            authWindowInterval = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed))
+                    return;
+                clearInterval(authWindowInterval);
+                setIsProcessing(false);
+                // user didn't complete oauth
+                if (providersWaitingOauthMessage[provider])
+                    typedReject('user-cancelled');
+            }, 2000);
+        }
+        else {
+            // For provider that don't support window.opener, we need to use a timeout to pool the oauth result
+            // If we don't get a valid result in {async sessionTimeout} ms, we'll assume the user closed the window
+            // and we'll clear all states/listeners
+            const poolOauthResult = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+                if (!shouldPool)
+                    return;
+                const result = yield getOAuthResultFromApi();
+                if (!shouldPool)
+                    return;
+                if ((result === null || result === void 0 ? void 0 : result.status) !== sdkApiCore.OauthResultStatus.Completed) {
+                    authWindowInterval = setTimeout(() => {
+                        poolOauthResult();
+                    }, 1000);
+                    return;
+                }
+                shouldPool = false;
+                const authMessage = {
+                    code: result === null || result === void 0 ? void 0 : result.code,
+                    error: result === null || result === void 0 ? void 0 : result.error,
+                    provider,
+                    type: 'authorization_response',
+                };
+                window.postMessage(authMessage, '*');
+            });
+            // start pooling oauth result
+            shouldPool = true;
+            poolOauthResult();
+            // if this is mobile, set a longer timeout to allow the user to login to the provider in the browser
+            let authWindowTimeout = sessionTimeout;
+            if (isMobile) {
+                authWindowTimeout = authWindowTimeout * 3;
+            }
+            authWindowInterval = setTimeout(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+                shouldPool = false;
+                // clear all states/listeners, assuming user closed the window before completing oauth
+                if (providersWaitingOauthMessage[provider]) {
+                    clearListeners();
+                    typedReject({
+                        code: types.SocialOAuthErrorCode.OAUTH_WINDOW_TIMEOUT,
+                        message: `Connecting ${provider} account window timeout.`,
+                    });
+                }
+                setIsProcessing(false);
+                onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+            }), authWindowTimeout);
+        }
+    }),
+});
+
+exports.createWindowOauth2Service = createWindowOauth2Service;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.d.ts

@@ -0,0 +1,2 @@
+import { IOauth2Service } from '../Oauth2Service';
+export declare const createWindowOauth2Service: () => IOauth2Service;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.js

@@ -0,0 +1,188 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { OauthResultStatus } from '@dynamic-labs/sdk-api-core';
+import { logger } from '../../../logger/logger.js';
+
+const providersWithoutWindowOpenerReference = ['twitter'];
+let authWindowInterval;
+const createWindowOauth2Service = () => ({
+    getOauthCode: ({ apiProvider, provider, setIsProcessing, state, oauthLoginUrl, getOAuthResultFromApi, sessionTimeout, isMobile, onSettled, }) => new Promise((resolve, _reject) => {
+        // When we catch this error we assume it follows this type, so we must enforce it
+        // here to ensure the assumption is correct
+        const typedReject = (params) => _reject(params);
+        // Clear any potential pending timeouts and intervals
+        clearInterval(authWindowInterval);
+        const providersWaitingOauthMessage = {};
+        let shouldPool = false;
+        const authWindow = window.open('', '_blank', 'width=500,height=600');
+        const clearListeners = () => {
+            window.removeEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = false;
+        };
+        const handleWindowMessage = (event) => __awaiter(void 0, void 0, void 0, function* () {
+            const message = event.data;
+            const expectedOrigin = getExpectedOrigin(apiProvider, provider);
+            if (!expectedOrigin) {
+                return;
+            }
+            if ((message === null || message === void 0 ? void 0 : message.type) === 'origin_check' && authWindow) {
+                logger.debug('Origin check message received. Sending response now.', {
+                    data: message,
+                    expectedOrigin,
+                });
+                authWindow.postMessage('origin_check_response', expectedOrigin);
+                return;
+            }
+            const isTelegramCompletedMessage = (message === null || message === void 0 ? void 0 : message.type) === 'telegram_completed';
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage || isTelegramCompletedMessage) {
+                logger.debug('Message received', { data: message });
+            }
+            const isExpectedOrigin = event.origin === expectedOrigin;
+            const isValidMessage = ((isAuthorizationMessage && (message === null || message === void 0 ? void 0 : message.provider) === provider) ||
+                isTelegramCompletedMessage) &&
+                isExpectedOrigin;
+            // don't process invalid messages for provider
+            if (!isValidMessage) {
+                return;
+            }
+            setIsProcessing(true);
+            if (!providersWaitingOauthMessage[provider]) {
+                typedReject({
+                    code: SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            if (isTelegramCompletedMessage) {
+                handleTelegramCompletionMessage(message);
+                return;
+            }
+            handleAuthorizationMessage(message, provider, state);
+        });
+        const getExpectedOrigin = (apiProvider, provider) => {
+            if (!(apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.redirectUrl)) {
+                return;
+            }
+            let expectedOrigin = window.location.origin;
+            if (!providersWithoutWindowOpenerReference.includes(provider)) {
+                try {
+                    const redirectUri = new URL(apiProvider.redirectUrl);
+                    expectedOrigin = redirectUri.origin;
+                }
+                catch (e) {
+                    logger.error('Failed to parse social provider redirect url', {
+                        error: e,
+                    });
+                    return;
+                }
+            }
+            return expectedOrigin;
+        };
+        const handleTelegramCompletionMessage = (message) => {
+            logger.debug('Telegram completion message received', {
+                data: message,
+            });
+            resolve('telegram_completed');
+            setIsProcessing(false);
+        };
+        const handleAuthorizationMessage = (message, provider, state) => {
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: ${error}`,
+                });
+                return;
+            }
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            // this state check is used only by providers with an open window opener reference (eg, not twitter)
+            if (!providersWithoutWindowOpenerReference.includes(provider) &&
+                state !== authState) {
+                typedReject({
+                    code: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: SocialOAuthErrorCode.NO_AUTH_CODE,
+                    message: `Failed to connect ${provider} social account: no authorization code`,
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        if (!providersWaitingOauthMessage[provider]) {
+            window.addEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = true;
+        }
+        authWindow === null || authWindow === void 0 ? void 0 : authWindow.location.assign(oauthLoginUrl);
+        if (!providersWithoutWindowOpenerReference.includes(provider)) {
+            // For provider that support window.opener, we need to clear all states/listeners when the window is closed
+            authWindowInterval = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed))
+                    return;
+                clearInterval(authWindowInterval);
+                setIsProcessing(false);
+                // user didn't complete oauth
+                if (providersWaitingOauthMessage[provider])
+                    typedReject('user-cancelled');
+            }, 2000);
+        }
+        else {
+            // For provider that don't support window.opener, we need to use a timeout to pool the oauth result
+            // If we don't get a valid result in {async sessionTimeout} ms, we'll assume the user closed the window
+            // and we'll clear all states/listeners
+            const poolOauthResult = () => __awaiter(void 0, void 0, void 0, function* () {
+                if (!shouldPool)
+                    return;
+                const result = yield getOAuthResultFromApi();
+                if (!shouldPool)
+                    return;
+                if ((result === null || result === void 0 ? void 0 : result.status) !== OauthResultStatus.Completed) {
+                    authWindowInterval = setTimeout(() => {
+                        poolOauthResult();
+                    }, 1000);
+                    return;
+                }
+                shouldPool = false;
+                const authMessage = {
+                    code: result === null || result === void 0 ? void 0 : result.code,
+                    error: result === null || result === void 0 ? void 0 : result.error,
+                    provider,
+                    type: 'authorization_response',
+                };
+                window.postMessage(authMessage, '*');
+            });
+            // start pooling oauth result
+            shouldPool = true;
+            poolOauthResult();
+            // if this is mobile, set a longer timeout to allow the user to login to the provider in the browser
+            let authWindowTimeout = sessionTimeout;
+            if (isMobile) {
+                authWindowTimeout = authWindowTimeout * 3;
+            }
+            authWindowInterval = setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                shouldPool = false;
+                // clear all states/listeners, assuming user closed the window before completing oauth
+                if (providersWaitingOauthMessage[provider]) {
+                    clearListeners();
+                    typedReject({
+                        code: SocialOAuthErrorCode.OAUTH_WINDOW_TIMEOUT,
+                        message: `Connecting ${provider} account window timeout.`,
+                    });
+                }
+                setIsProcessing(false);
+                onSettled === null || onSettled === void 0 ? void 0 : onSettled();
+            }), authWindowTimeout);
+        }
+    }),
+});
+
+export { createWindowOauth2Service };

package/src/services/Oauth2Service/createWindowOauth2Service/index.d.ts

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

package/src/services/Oauth2Service/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Oauth2Service';
+export * from './createWindowOauth2Service';

package/src/services/PlatformService/PlatformService.cjs

@@ -0,0 +1,40 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var createBrowserPlatformService = require('./createBrowserPlatformService/createBrowserPlatformService.cjs');
+
+var _a, _PlatformService_implementation;
+class PlatformService {
+    static get implementation() {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _PlatformService_implementation)) {
+            return createBrowserPlatformService.createBrowserPlatformService(window);
+        }
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _PlatformService_implementation);
+    }
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _PlatformService_implementation);
+    }
+    static get getOrigin() {
+        return _a.implementation.getOrigin;
+    }
+    static get getHost() {
+        return _a.implementation.getHost;
+    }
+    static get getHostname() {
+        return _a.implementation.getHostname;
+    }
+    static get getTLD() {
+        return _a.implementation.getTLD;
+    }
+    // Deeplink handling
+    static get openURL() {
+        return _a.implementation.openURL;
+    }
+}
+_a = PlatformService;
+_PlatformService_implementation = { value: void 0 };
+
+exports.PlatformService = PlatformService;

package/src/services/PlatformService/PlatformService.d.ts

@@ -0,0 +1,11 @@
+import { IPlatformService } from './types';
+export declare class PlatformService {
+    #private;
+    static get implementation(): IPlatformService;
+    static set implementation(implementation: IPlatformService);
+    static get getOrigin(): () => string;
+    static get getHost(): () => string;
+    static get getHostname(): () => string;
+    static get getTLD(): () => string | undefined;
+    static get openURL(): (url: string) => Promise<void>;
+}

package/src/services/PlatformService/PlatformService.js

@@ -0,0 +1,36 @@
+'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+import { createBrowserPlatformService } from './createBrowserPlatformService/createBrowserPlatformService.js';
+
+var _a, _PlatformService_implementation;
+class PlatformService {
+    static get implementation() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _PlatformService_implementation)) {
+            return createBrowserPlatformService(window);
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _PlatformService_implementation);
+    }
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _PlatformService_implementation);
+    }
+    static get getOrigin() {
+        return _a.implementation.getOrigin;
+    }
+    static get getHost() {
+        return _a.implementation.getHost;
+    }
+    static get getHostname() {
+        return _a.implementation.getHostname;
+    }
+    static get getTLD() {
+        return _a.implementation.getTLD;
+    }
+    // Deeplink handling
+    static get openURL() {
+        return _a.implementation.openURL;
+    }
+}
+_a = PlatformService;
+_PlatformService_implementation = { value: void 0 };
+
+export { PlatformService };

package/src/services/PlatformService/createBrowserPlatformService/createBrowserPlatformService.cjs

@@ -0,0 +1,30 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var tldts = require('tldts');
+
+const createBrowserPlatformService = (window) => ({
+    getHost: () => window.location.host,
+    getHostname: () => window.location.hostname,
+    getOrigin: () => window.location.origin,
+    getTLD: () => {
+        // Passing the allowPrivateDomains option prevents returning the actual TLD
+        // for domains that have delegated subdomains like herokuapp.com or s3.amazonaws.com
+        // full list is contained here https://publicsuffix.org/list/effective_tld_names.dat
+        // separated by ICANN DOMAINS and PRIVATE DOMAINS
+        // so for instance parse('someapp.herokuapp.com') will return 'someapp.herokuapp.com' as the domain
+        // whereas parse('app.dynamic.xyz') will return 'dynamic.xyz'
+        const data = tldts.parse(window.location.hostname, {
+            allowPrivateDomains: true,
+        });
+        return data.domain || undefined;
+    },
+    openURL: (url) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        window.location.assign(url);
+    }),
+});
+
+exports.createBrowserPlatformService = createBrowserPlatformService;

package/src/services/PlatformService/createBrowserPlatformService/createBrowserPlatformService.d.ts

@@ -0,0 +1,2 @@
+import { IPlatformService } from '../types';
+export declare const createBrowserPlatformService: (window: Window) => IPlatformService;

package/src/services/PlatformService/createBrowserPlatformService/createBrowserPlatformService.js

@@ -0,0 +1,26 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { parse } from 'tldts';
+
+const createBrowserPlatformService = (window) => ({
+    getHost: () => window.location.host,
+    getHostname: () => window.location.hostname,
+    getOrigin: () => window.location.origin,
+    getTLD: () => {
+        // Passing the allowPrivateDomains option prevents returning the actual TLD
+        // for domains that have delegated subdomains like herokuapp.com or s3.amazonaws.com
+        // full list is contained here https://publicsuffix.org/list/effective_tld_names.dat
+        // separated by ICANN DOMAINS and PRIVATE DOMAINS
+        // so for instance parse('someapp.herokuapp.com') will return 'someapp.herokuapp.com' as the domain
+        // whereas parse('app.dynamic.xyz') will return 'dynamic.xyz'
+        const data = parse(window.location.hostname, {
+            allowPrivateDomains: true,
+        });
+        return data.domain || undefined;
+    },
+    openURL: (url) => __awaiter(void 0, void 0, void 0, function* () {
+        window.location.assign(url);
+    }),
+});
+
+export { createBrowserPlatformService };

package/src/services/PlatformService/createBrowserPlatformService/index.d.ts

@@ -0,0 +1 @@
+export { createBrowserPlatformService } from './createBrowserPlatformService';

package/src/services/PlatformService/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PlatformService';
+export * from './createBrowserPlatformService';
+export * from './types';

package/src/services/PlatformService/types.d.ts

@@ -0,0 +1,25 @@
+export interface IPlatformService {
+    /**
+     * Gets the hostname of the current location.
+     *
+     * @example window.location.hostname
+     */
+    getHostname(): string;
+    /**
+     * Gets the host of the current location.
+     *
+     * @example window.location.host
+     */
+    getHost(): string;
+    /**
+     * Gets the origin of the current location.
+     *
+     * @example window.location.origin
+     */
+    getOrigin(): string;
+    getTLD(): string | undefined;
+    /**
+     * Opens a URL. If possible, should avoid new windows.
+     */
+    openURL(url: string): Promise<void>;
+}

package/src/sleep/index.d.ts

@@ -0,0 +1 @@
+export { sleep } from './sleep';

package/src/sleep/sleep.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function sleep(timeoutMs, valueToResolve) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(valueToResolve), timeoutMs);
+    });
+}
+
+exports.sleep = sleep;

package/src/sleep/sleep.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Delays the execution of subsequent code by a specified amount of time.
+ * If a value is provided, the promise will resolve with that value after the timeout.
+ *
+ * @template T - The type of the value to resolve with.
+ * @param {number} timeoutMs - The number of milliseconds to delay.
+ * @param {T} [valueToResolve] - Optional value to resolve the promise with after the timeout.
+ * @returns {Promise<T | void>} - Resolves after the specified timeout with valueToResolve or void.
+ */
+export declare function sleep(timeoutMs: number): Promise<void>;
+export declare function sleep<T>(timeoutMs: number, valueToResolve: T): Promise<T>;

package/src/sleep/sleep.js

@@ -0,0 +1,9 @@
+'use client'
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+function sleep(timeoutMs, valueToResolve) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(valueToResolve), timeoutMs);
+    });
+}
+
+export { sleep };

package/src/template/index.d.ts

@@ -0,0 +1 @@
+export { template } from './template';

package/src/template/template.cjs

@@ -0,0 +1,25 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Creates a template function that replaces placeholders with corresponding values from a data object.
+ * @param {string} templateText - The template string containing placeholders in the form {{placeholder}}.
+ * @returns {(data) => string} - A function that replaces the placeholders with the values from the data object.
+ *
+ * @example
+ * // Basic usage
+ * const compiled = template('Test text {{placeholder}} value');
+ * console.log(compiled({ placeholder: 'test' })); // Output: 'Test text test value'
+ *
+ * @example
+ * // Multiple placeholders
+ * const compiled = template('Test text {{placeholder}} value {{placeholder2}}');
+ * console.log(compiled({ placeholder: 'test', placeholder2: 'test2' })); // Output: 'Test text test value test2'
+ */
+const template = (templateText) => {
+    return (data) => templateText.replace(/{{(\w+?)}}/g, (match, key) => key in data ? data[key] : match);
+};
+
+exports.template = template;