@kwiz/common 1.0.102 → 1.0.103

package/src/helpers/promises.ts

@@ -1,166 +1,166 @@
-import { IDictionary } from "../types/common.types";
-import { getGlobal, hasOwnProperty } from "./objects";
-import { isFunction, isNullOrUndefined, isNumber } from "./typecheckers";
-
-function _getGlobal() {
-    let _global = getGlobal<{ promises: IDictionary<Promise<any>> }>("helpers_promises",
-        {
-            promises: {}
-        });
-    return _global;
-}
-
-/**
- * Lock all concurrent calls to a resource to one promise for a set duration of time.
- * @param {string} key - Unique key to identify the promise.
- * @param {() => Promise<T>} promiseFunc - Function that will return the promise to be run only once.
- * @param {number} duration - Duration to hold on to the promise result. (default=1)
- * @returns {Promise<T>} Returns the single promise that will be fullfilled for all promises with the same key.
- * @example
- * // returns Promise<string>
- * var initTests = await promiseLock<string>("initTests", async () => { ... }, 2); 
- */
-export async function promiseLock<T>(key: string, promiseFunc: () => Promise<T>, duration = 1): Promise<T> {
-    return promiseOnce(key, promiseFunc).then((result) => {
-        (globalThis || window).setTimeout(() => {
-            _deletePromiseByKey(key);
-        }, isNumber(duration) && duration >= 1 ? duration : 1);
-        return result;
-    });
-}
-/**
- * Ensures that a promise runs only once
- * @param {string} key - Unique key to identify the promise.
- * @param {() => Promise<T>} promiseFunc - Function that will return the promise to be run only once.
- * @param {(result: T) => Promise<boolean>} isValidResult - Optional function that returns boolean to indicate if the result returned
- * by the promise is valid and should be kepy in memory. 
- * @returns {Promise<T>} Returns the single promise that will be fullfilled for all promises with the same key.
- * @example
- * // returns Promise<string>
- * var initTests = await promiseOnce<string>("initTests", async () => { ... }); 
- */
-export async function promiseOnce<T>(key: string, promiseFunc: () => Promise<T>, isValidResult?: (result: T) => Promise<boolean>): Promise<T> {
-    let _global = _getGlobal();
-    let promises = _global.promises;
-
-    if (hasOwnProperty(promises, key) && isFunction(isValidResult)) {
-        //we have en existing pending promise...
-        let queuedResult: T = null;
-        try { queuedResult = await promises[key]; } catch (e) { }
-        if ((await isValidResult(queuedResult)) !== true) {
-            _deletePromiseByKey(key);
-        }
-    }
-
-    if (!hasOwnProperty(promises, key)) {
-        promises[key] = promiseFunc();
-    }
-
-    return promises[key];
-}
-
-/**
- * Runs all promises in sequential order.
- * @param {(() => Promise<T>)[]} asyncFuncs - Array of functions that return the promises to fullfill. 
- * @returns {Promise<T[]>} Returns a single promise with a merged array of results that are in the same order as the 
- * provided promise functions
- */
-export function promiseAllSequential<T = any>(asyncFuncs: (() => Promise<T>)[]): Promise<T[]> {
-    if (!Array.isArray(asyncFuncs) || !asyncFuncs.length) {
-        return Promise.resolve([]);
-    }
-    return asyncFuncs.reduce((promiseChain, currentTaskcurrentTask) => (
-        promiseChain.then((result) => {
-            let taskResult = currentTaskcurrentTask();
-            if (isNullOrUndefined(taskResult) || !isFunction(taskResult.then))//culprit - found one that did not return a promise?! make one.
-                taskResult = Promise.resolve() as any as Promise<T>;
-
-            return taskResult.then(Array.prototype.concat.bind(result));
-        })
-    ), Promise.resolve([]));
-}
-
-/**
- * Runs N promises in parallel.
- * @param {(() => Promise<T>)[]} asyncFuncs - Array of functions that return the promises to fullfill.
- * @param {number} [maxParallel] - Max number of promises to run in parallel (default=8).
- * @returns {Promise<T[]>} Returns a single promise with a merged array of results that are in the same order as the 
- * provided promise functions
- */
-export function promiseNParallel<T>(asyncFuncs: (() => Promise<T>)[], maxParallel: number = 8): Promise<T[]> {
-    if (!Array.isArray(asyncFuncs) || !asyncFuncs.length) {
-        return Promise.resolve([]);
-    }
-
-    let startChain = () => {
-        let chainData = [];
-
-        if (asyncFuncs.length) {
-            let next = (data: T) => {
-                chainData.push(data);
-                return asyncFuncs.length ? (asyncFuncs.shift())().then(next) : chainData;
-            };
-            return (asyncFuncs.shift())().then(next);
-        } else {
-            return Promise.resolve(chainData);
-        }
-    };
-
-    let chains = [];
-    for (let k = 0; k < maxParallel; k += 1) {
-        chains.push(startChain());
-    }
-
-    return Promise.all(chains).then(d => {
-        //flatten results
-        return d.reduce((acc, val) => acc.concat(val), []);
-    });
-}
-
-/**
- * Provides an asnyc sleep function that allows you to delay async/wait calls.
- * @param {number} [seconds] - Time to sleep in seconds. 
- */
-export function sleepAsync(seconds?: number): Promise<void> {
-    return new Promise(resolve => {
-        (globalThis || window).setTimeout(() => resolve(), seconds > 0 ? seconds * 1000 : 3000);
-    });
-}
-
-/**
- * Provides the ability to retry an async function n times with a optional delay between calls
- * @param {(...args) => Promise<T>} fn - Function to retry,
- * @param {number} numberOfRetries - Number of times to retry.
- * @param {number} [seconds] - Delay between retries in seconds (default=1).
- */
-export async function retryAsync<T>(fn: (...args) => Promise<T>, numberOfRetries: number, seconds = 1) {
-    let error: Error = null;
-
-    for (let i = 0; i < numberOfRetries; i++) {
-        try {
-            error = null;
-            await sleepAsync(i === 0 ? 0 : seconds);
-            return await fn();
-        } catch (ex) {
-            error = ex;
-        }
-    }
-
-    if (error) {
-        throw error;
-    }
-    throw new Error(`Failed retrying ${numberOfRetries} times`);
-}
-
-function _deletePromiseByKey(key: string) {
-    let _global = _getGlobal();
-    let promises = _global.promises;
-    if (hasOwnProperty(promises, key)) {
-        try {
-            delete promises[key];
-            return true;
-        } catch {
-            return false;
-        }
-    }
+import { IDictionary } from "../types/common.types";
+import { getGlobal, hasOwnProperty } from "./objects";
+import { isFunction, isNullOrUndefined, isNumber } from "./typecheckers";
+
+function _getGlobal() {
+    let _global = getGlobal<{ promises: IDictionary<Promise<any>> }>("helpers_promises",
+        {
+            promises: {}
+        });
+    return _global;
+}
+
+/**
+ * Lock all concurrent calls to a resource to one promise for a set duration of time.
+ * @param {string} key - Unique key to identify the promise.
+ * @param {() => Promise<T>} promiseFunc - Function that will return the promise to be run only once.
+ * @param {number} duration - Duration to hold on to the promise result. (default=1)
+ * @returns {Promise<T>} Returns the single promise that will be fullfilled for all promises with the same key.
+ * @example
+ * // returns Promise<string>
+ * var initTests = await promiseLock<string>("initTests", async () => { ... }, 2); 
+ */
+export async function promiseLock<T>(key: string, promiseFunc: () => Promise<T>, duration = 1): Promise<T> {
+    return promiseOnce(key, promiseFunc).then((result) => {
+        (globalThis || window).setTimeout(() => {
+            _deletePromiseByKey(key);
+        }, isNumber(duration) && duration >= 1 ? duration : 1);
+        return result;
+    });
+}
+/**
+ * Ensures that a promise runs only once
+ * @param {string} key - Unique key to identify the promise.
+ * @param {() => Promise<T>} promiseFunc - Function that will return the promise to be run only once.
+ * @param {(result: T) => Promise<boolean>} isValidResult - Optional function that returns boolean to indicate if the result returned
+ * by the promise is valid and should be kepy in memory. 
+ * @returns {Promise<T>} Returns the single promise that will be fullfilled for all promises with the same key.
+ * @example
+ * // returns Promise<string>
+ * var initTests = await promiseOnce<string>("initTests", async () => { ... }); 
+ */
+export async function promiseOnce<T>(key: string, promiseFunc: () => Promise<T>, isValidResult?: (result: T) => Promise<boolean>): Promise<T> {
+    let _global = _getGlobal();
+    let promises = _global.promises;
+
+    if (hasOwnProperty(promises, key) && isFunction(isValidResult)) {
+        //we have en existing pending promise...
+        let queuedResult: T = null;
+        try { queuedResult = await promises[key]; } catch (e) { }
+        if ((await isValidResult(queuedResult)) !== true) {
+            _deletePromiseByKey(key);
+        }
+    }
+
+    if (!hasOwnProperty(promises, key)) {
+        promises[key] = promiseFunc();
+    }
+
+    return promises[key];
+}
+
+/**
+ * Runs all promises in sequential order.
+ * @param {(() => Promise<T>)[]} asyncFuncs - Array of functions that return the promises to fullfill. 
+ * @returns {Promise<T[]>} Returns a single promise with a merged array of results that are in the same order as the 
+ * provided promise functions
+ */
+export function promiseAllSequential<T = any>(asyncFuncs: (() => Promise<T>)[]): Promise<T[]> {
+    if (!Array.isArray(asyncFuncs) || !asyncFuncs.length) {
+        return Promise.resolve([]);
+    }
+    return asyncFuncs.reduce((promiseChain, currentTaskcurrentTask) => (
+        promiseChain.then((result) => {
+            let taskResult = currentTaskcurrentTask();
+            if (isNullOrUndefined(taskResult) || !isFunction(taskResult.then))//culprit - found one that did not return a promise?! make one.
+                taskResult = Promise.resolve() as any as Promise<T>;
+
+            return taskResult.then(Array.prototype.concat.bind(result));
+        })
+    ), Promise.resolve([]));
+}
+
+/**
+ * Runs N promises in parallel.
+ * @param {(() => Promise<T>)[]} asyncFuncs - Array of functions that return the promises to fullfill.
+ * @param {number} [maxParallel] - Max number of promises to run in parallel (default=8).
+ * @returns {Promise<T[]>} Returns a single promise with a merged array of results that are in the same order as the 
+ * provided promise functions
+ */
+export function promiseNParallel<T>(asyncFuncs: (() => Promise<T>)[], maxParallel: number = 8): Promise<T[]> {
+    if (!Array.isArray(asyncFuncs) || !asyncFuncs.length) {
+        return Promise.resolve([]);
+    }
+
+    let startChain = () => {
+        let chainData = [];
+
+        if (asyncFuncs.length) {
+            let next = (data: T) => {
+                chainData.push(data);
+                return asyncFuncs.length ? (asyncFuncs.shift())().then(next) : chainData;
+            };
+            return (asyncFuncs.shift())().then(next);
+        } else {
+            return Promise.resolve(chainData);
+        }
+    };
+
+    let chains = [];
+    for (let k = 0; k < maxParallel; k += 1) {
+        chains.push(startChain());
+    }
+
+    return Promise.all(chains).then(d => {
+        //flatten results
+        return d.reduce((acc, val) => acc.concat(val), []);
+    });
+}
+
+/**
+ * Provides an asnyc sleep function that allows you to delay async/wait calls.
+ * @param {number} [seconds] - Time to sleep in seconds. 
+ */
+export function sleepAsync(seconds?: number): Promise<void> {
+    return new Promise(resolve => {
+        (globalThis || window).setTimeout(() => resolve(), seconds > 0 ? seconds * 1000 : 3000);
+    });
+}
+
+/**
+ * Provides the ability to retry an async function n times with a optional delay between calls
+ * @param {(...args) => Promise<T>} fn - Function to retry,
+ * @param {number} numberOfRetries - Number of times to retry.
+ * @param {number} [seconds] - Delay between retries in seconds (default=1).
+ */
+export async function retryAsync<T>(fn: (...args) => Promise<T>, numberOfRetries: number, seconds = 1) {
+    let error: Error = null;
+
+    for (let i = 0; i < numberOfRetries; i++) {
+        try {
+            error = null;
+            await sleepAsync(i === 0 ? 0 : seconds);
+            return await fn();
+        } catch (ex) {
+            error = ex;
+        }
+    }
+
+    if (error) {
+        throw error;
+    }
+    throw new Error(`Failed retrying ${numberOfRetries} times`);
+}
+
+function _deletePromiseByKey(key: string) {
+    let _global = _getGlobal();
+    let promises = _global.promises;
+    if (hasOwnProperty(promises, key)) {
+        try {
+            delete promises[key];
+            return true;
+        } catch {
+            return false;
+        }
+    }
 }

package/src/helpers/random.ts

@@ -1,27 +1,27 @@
-export function getRandomId() {
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
-}
-
-export function getUniqueId() {
-    var _s_hexcode = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-    for (var a = "", c = 0; c < 32; c++) {
-        var b = Math.floor(Math.random() * 16);
-        switch (c) {
-            case 8:
-                a += "-";
-                break;
-            case 12:
-                b = 4;
-                a += "-";
-                break;
-            case 16:
-                b = b & 3 | 8;
-                a += "-";
-                break;
-            case 20:
-                a += "-";
-        }
-        a += _s_hexcode[b];
-    }
-    return a;
-}
+export function getRandomId() {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+
+export function getUniqueId() {
+    var _s_hexcode = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
+    for (var a = "", c = 0; c < 32; c++) {
+        var b = Math.floor(Math.random() * 16);
+        switch (c) {
+            case 8:
+                a += "-";
+                break;
+            case 12:
+                b = 4;
+                a += "-";
+                break;
+            case 16:
+                b = b & 3 | 8;
+                a += "-";
+                break;
+            case 20:
+                a += "-";
+        }
+        a += _s_hexcode[b];
+    }
+    return a;
+}

package/src/helpers/scheduler/scheduler.test.js

@@ -1,104 +1,104 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { isValidSchedule, getNextUTC } from "./scheduler";
-import { ScheduleTypes } from './scheduler';
-
-var startDate = "2020-01-01T05:00Z";
-var invalidOutput = "9999999999";
-var schedules = [
-    { schedule: {}, output: invalidOutput, valid: false },
-    { schedule: { ScheduleType: "x" }, output: invalidOutput, valid: false },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.hourly,
-            interval: 24
-        }, output: invalidOutput, valid: false
-    },
-    {
-        name: "move 2 hours",
-        schedule: {
-            ScheduleType: ScheduleTypes.hourly,
-            interval: 2
-        }, output: "2020010107", valid: true
-    },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.daily,
-            hours: []
-        }, output: invalidOutput, valid: false
-    },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.daily,
-            hours: [5, 2, 9, 26]
-        }, output: invalidOutput, valid: false
-    },
-    {
-        name: "move to next hour in same day",
-        schedule: {
-            ScheduleType: ScheduleTypes.daily,
-            hours: [5, 2, 9, 22]
-        }, output: "2020010109", valid: true
-    },
-    {
-        name: "passed last hour, move to next day",
-        schedule: {
-            ScheduleType: ScheduleTypes.daily,
-            hours: [3, 1, 5, 2]
-        }, output: "2020010201", valid: true
-    },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: []
-        }, output: invalidOutput, valid: false
-    },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: [5, 2, 9, 26],
-            days: [2],
-        }, output: invalidOutput, valid: false
-    },
-    {
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: [5, 2, 9, 22],
-            days: [5, 2, 7]
-        }, output: invalidOutput, valid: false
-    },
-    {
-        name: "day is no ok, move to next day first hour",
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: [5, 2, 9, 22],
-            days: [5, 2, 4]
-        }, output: "2020010202", valid: true
-    },
-    {
-        name: "day is not ok, move to first day in next week",
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: [5, 2, 9, 22],
-            days: [2, 0, 1]
-        }, output: "2020010502", valid: true
-    },
-    {
-        name: "day is ok, move to next hour",
-        schedule: {
-            ScheduleType: ScheduleTypes.weekly,
-            hours: [5, 2, 9, 22],
-            days: [5, 2, 3, 4]
-        }, output: "2020010109", valid: true
-    }
-];
-
-
-test('isValidSchedule', t => {
-    schedules.forEach(s => assert.strictEqual(isValidSchedule(s.schedule), s.valid));
-});
-
-test('getNextUTC', async t => {
-    let date = new Date(startDate);
-    schedules.forEach(s => assert.strictEqual(getNextUTC(date, s.schedule), s.output));
+import assert from 'assert/strict';
+import test from 'node:test';
+import { isValidSchedule, getNextUTC } from "./scheduler";
+import { ScheduleTypes } from './scheduler';
+
+var startDate = "2020-01-01T05:00Z";
+var invalidOutput = "9999999999";
+var schedules = [
+    { schedule: {}, output: invalidOutput, valid: false },
+    { schedule: { ScheduleType: "x" }, output: invalidOutput, valid: false },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.hourly,
+            interval: 24
+        }, output: invalidOutput, valid: false
+    },
+    {
+        name: "move 2 hours",
+        schedule: {
+            ScheduleType: ScheduleTypes.hourly,
+            interval: 2
+        }, output: "2020010107", valid: true
+    },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.daily,
+            hours: []
+        }, output: invalidOutput, valid: false
+    },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.daily,
+            hours: [5, 2, 9, 26]
+        }, output: invalidOutput, valid: false
+    },
+    {
+        name: "move to next hour in same day",
+        schedule: {
+            ScheduleType: ScheduleTypes.daily,
+            hours: [5, 2, 9, 22]
+        }, output: "2020010109", valid: true
+    },
+    {
+        name: "passed last hour, move to next day",
+        schedule: {
+            ScheduleType: ScheduleTypes.daily,
+            hours: [3, 1, 5, 2]
+        }, output: "2020010201", valid: true
+    },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: []
+        }, output: invalidOutput, valid: false
+    },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: [5, 2, 9, 26],
+            days: [2],
+        }, output: invalidOutput, valid: false
+    },
+    {
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: [5, 2, 9, 22],
+            days: [5, 2, 7]
+        }, output: invalidOutput, valid: false
+    },
+    {
+        name: "day is no ok, move to next day first hour",
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: [5, 2, 9, 22],
+            days: [5, 2, 4]
+        }, output: "2020010202", valid: true
+    },
+    {
+        name: "day is not ok, move to first day in next week",
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: [5, 2, 9, 22],
+            days: [2, 0, 1]
+        }, output: "2020010502", valid: true
+    },
+    {
+        name: "day is ok, move to next hour",
+        schedule: {
+            ScheduleType: ScheduleTypes.weekly,
+            hours: [5, 2, 9, 22],
+            days: [5, 2, 3, 4]
+        }, output: "2020010109", valid: true
+    }
+];
+
+
+test('isValidSchedule', t => {
+    schedules.forEach(s => assert.strictEqual(isValidSchedule(s.schedule), s.valid));
+});
+
+test('getNextUTC', async t => {
+    let date = new Date(startDate);
+    schedules.forEach(s => assert.strictEqual(getNextUTC(date, s.schedule), s.output));
 });