@lowentry/utils 1.7.1 → 1.9.1

package/LeUtils.js

@@ -1,5 +1,6 @@
 import FastDeepEqual from 'fast-deep-equal';
-import {ISSET, IS_OBJECT, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY} from './LeTypes.js';
+import CloneDeep from 'clone-deep';
+import {ISSET, IS_OBJECT, IS_ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY} from './LeTypes.js';
 
 
 /**
@@ -2765,4 +2766,253 @@ export const LeUtils = {
 			}
 			return transactionalValue.changes[transactionalValue.changes.length - 1].value;
 		},
+	
+	/**
+	 * Creates a worker thread. Workers have to be stored at /workers/{workerName}.worker.js for this to work.
+	 *
+	 * Example of a worker file:
+	 *
+	 * ```js
+	 * onmessage = (message) =>
+	 * {
+	 *     postMessage({
+	 *         ...message.data,
+	 *         results: ['...some expensive calculation involving message.data...'],
+	 *     });
+	 * };
+	 * ```
+	 *
+	 * Usage:
+	 *
+	 * ```js
+	 * const {results} = await (async () =>
+	 * {
+	 *     try
+	 *     {
+	 *         return await LeUtils.sendWorkerMessage('my-worker', {someData:[1, 2, 3, 4, 5]});
+	 *     }
+	 *     catch(error)
+	 *     {
+	 *         console.error('MyWorker: ', error);
+	 *         return {results:[]};
+	 *     }
+	 * })();
+	 * ```
+	 *
+	 * or, if you want more control over the number of threads you have (the above example will only create 1 thread per worker):
+	 *
+	 * ```js
+	 * const myWorker1 = LeUtils.createWorkerThread('my-worker'); // creates a thread, you can create multiple worker threads of the same worker, to run multiple instances in parallel
+	 * const myWorker2 = LeUtils.createWorkerThread('my-worker'); // same worker, another thread
+	 * const {results} = await (async () =>
+	 * {
+	 *     try
+	 *     {
+	 *         return await myWorker1.sendMessage({someData:[1, 2, 3, 4, 5]});
+	 *     }
+	 *     catch(error)
+	 *     {
+	 *         console.error('MyWorker: ', error);
+	 *         return {results:[]};
+	 *     }
+	 * })();
+	 * ```
+	 *
+	 * @param {string} name
+	 * @returns {{worker: Worker,  sendMessage: function(Object, {timeout: number|undefined}|undefined): Promise<Object>}}
+	 */
+	createWorkerThread:
+		(name) =>
+		{
+			const worker = new Worker('/workers/' + name + '.worker.js');
+			let listeners = {};
+			
+			const addListener = (id, callback) =>
+			{
+				listeners[id] = callback;
+			};
+			
+			const removeListener = (id) =>
+			{
+				delete listeners[id];
+			};
+			
+			const sendMessage = (data, options) =>
+			{
+				return new Promise((resolve, reject) =>
+				{
+					const id = LeUtils.uniqueId();
+					addListener(id, resolve);
+					setTimeout(() =>
+					{
+						removeListener(id);
+						reject('timeout');
+					}, options?.timeout ?? 10000);
+					
+					worker.postMessage({
+						id,
+						...data,
+					});
+				});
+			};
+			
+			worker.onerror = (error) =>
+			{
+				console.error('Worker ' + name + ':', error);
+			};
+			worker.onmessage = (message) =>
+			{
+				const data = message.data;
+				if(data?.id)
+				{
+					const callback = listeners[data.id];
+					if(callback)
+					{
+						removeListener(data.id);
+						callback(data);
+					}
+				}
+			};
+			
+			return {worker, sendMessage};
+		},
+	
+	/**
+	 * Sends a message to the given worker. Creates a worker thread for this worker if it doesn't exist yet.
+	 *
+	 * See {@link LeUtils#createWorkerThread} for more info on how to use workers.
+	 *
+	 * @param {string} workerName
+	 * @param {Object} data
+	 * @param {{timeout: number|undefined}} [options]
+	 * @returns {Promise<Object>}
+	 */
+	sendWorkerMessage:
+		(() =>
+		{
+			const workers = {};
+			return (workerName, data, options) =>
+			{
+				if(!workers[workerName])
+				{
+					workers[workerName] = LeUtils.createWorkerThread(workerName);
+				}
+				return workers[workerName].sendMessage(data, options);
+			};
+		})(),
+	
+	/**
+	 * Returns a deep copy of the given value.
+	 *
+	 * @param {*} value
+	 * @returns {*}
+	 */
+	clone:
+		(value) => CloneDeep(value, true),
+	
+	/**
+	 * Purges the given email address, returning an empty string if it's invalid.
+	 *
+	 * @param {string} email
+	 * @returns {string}
+	 */
+	purgeEmail:
+		(email) =>
+		{
+			email = STRING(email).trim().toLowerCase().replace(/\s/g, '');
+			if(!email.includes('@') || !email.includes('.'))
+			{
+				return '';
+			}
+			return email;
+		},
+	
+	/**
+	 * Returns true if the focus is effectively clear, meaning that the user is not typing in an input field.
+	 *
+	 * @returns {boolean}
+	 */
+	isFocusClear:(() =>
+	{
+		const inputTypes = ['text', 'search', 'email', 'number', 'password', 'tel', 'time', 'url', 'week', 'month', 'date', 'datetime-local'];
+		return () => !((document?.activeElement?.tagName?.toLowerCase() === 'input') && inputTypes.includes(document?.activeElement?.type?.toLowerCase()));
+	})(),
+	
+	/**
+	 * Returns the user's locale. Returns 'en-US' if it can't be determined.
+	 *
+	 * @returns {string}
+	 */
+	getUserLocale:(() =>
+	{
+		let userLocale = null;
+		return () =>
+		{
+			if(userLocale === null)
+			{
+				userLocale = (() =>
+				{
+					if(typeof window === 'undefined')
+					{
+						return 'en-US';
+					}
+					let locales = window.navigator.languages;
+					if(!IS_ARRAY(locales) || (locales.length <= 0))
+					{
+						return 'en-US';
+					}
+					locales = locales.filter(locale => ((typeof locale === 'string') && locale.includes('-') && (locale.toLowerCase() !== 'en-us')));
+					if(locales.length <= 0)
+					{
+						return 'en-US';
+					}
+					const localesNoEnglish = locales.filter(locale => !locale.toLowerCase().startsWith('en-'));
+					if(localesNoEnglish.length <= 0)
+					{
+						return locales[0];
+					}
+					return localesNoEnglish[0];
+				})();
+			}
+			return userLocale;
+		};
+	})(),
+	
+	/**
+	 * Returns the user's locale date format. Always returns YYYY MM DD, with the character in between depending on the user's locale. Returns 'YYYY/MM/DD' if the user's locale can't be determined.
+	 *
+	 * @returns {string}
+	 */
+	getUserLocaleDateFormat:(() =>
+	{
+		let userLocaleDateFormat = null;
+		return () =>
+		{
+			if(userLocaleDateFormat === null)
+			{
+				userLocaleDateFormat = (() =>
+				{
+					let char = '/';
+					if((typeof window !== 'undefined') && (typeof Intl !== 'undefined') && (typeof Intl.DateTimeFormat !== 'undefined'))
+					{
+						const formattedDate = new Intl.DateTimeFormat(LeUtils.getUserLocale()).format();
+						if(formattedDate.includes('-'))
+						{
+							char = '-';
+						}
+						else if(formattedDate.includes('. '))
+						{
+							char = '.';
+						}
+						else if(formattedDate.includes('.'))
+						{
+							char = '.';
+						}
+					}
+					return 'YYYY' + char + 'MM' + char + 'DD';
+				})();
+			}
+			return userLocaleDateFormat;
+		};
+	})(),
 };

package/index.js

@@ -1,4 +1,2 @@
-import {LeUtils} from './LeUtils.js';
-import {ISSET, IS_ARRAY, ARRAY, IS_OBJECT, OBJECT, STRING, STRING_ANY, INT, INT_ANY, FLOAT, FLOAT_ANY, INT_LAX, INT_LAX_ANY, FLOAT_LAX, FLOAT_LAX_ANY} from './LeTypes.js';
-
-export {LeUtils, ISSET, IS_ARRAY, ARRAY, IS_OBJECT, OBJECT, STRING, STRING_ANY, INT, INT_ANY, FLOAT, FLOAT_ANY, INT_LAX, INT_LAX_ANY, FLOAT_LAX, FLOAT_LAX_ANY};
+export {LeUtils} from './LeUtils.js';
+export {ISSET, IS_ARRAY, ARRAY, IS_OBJECT, OBJECT, STRING, STRING_ANY, INT, INT_ANY, FLOAT, FLOAT_ANY, INT_LAX, INT_LAX_ANY, FLOAT_LAX, FLOAT_LAX_ANY} from './LeTypes.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowentry/utils",
-  "version": "1.7.1",
+  "version": "1.9.1",
   "private": false,
   "type": "module",
   "description": "Provides utilities for general JavaScript development.",
@@ -20,6 +20,7 @@
     "test": "node --check index.js"
   },
   "dependencies": {
+    "clone-deep": "^4",
     "fast-deep-equal": "^3"
   }
 }