@kwiz/common 1.0.129 → 1.0.133

package/src/helpers/objects.ts

@@ -1,275 +0,0 @@
-import { makeUniqueArray } from "./collections.base";
-import { jsonParse } from "./json";
-import { isDate, isFunction, isNotEmptyArray, isNullOrEmptyString, isNullOrUndefined, isObject, isPrimitiveValue, isString, primitiveTypes } from "./typecheckers";
-
-/** global window, safe for testing and environments without a browser */
-export var $w = typeof window === "undefined" ? {
-    setTimeout: setTimeout,
-    clearTimeout: clearTimeout,
-    location: {
-        href: "", host: ""
-    }
-} as any as Window : window;
-
-/** wrapper for hasOwnProperty that satisfies https://eslint.org/docs/latest/rules/no-prototype-builtins */
-export function hasOwnProperty(obj: any, prop: string) {
-    if (!isNullOrUndefined(obj)) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    }
-    return false;
-}
-
-/** empty async function */
-/* eslint-disable-next-line @typescript-eslint/no-empty-function */
-export var noop = async () => { };
-/** empty sync function */
-/* eslint-disable-next-line @typescript-eslint/no-empty-function */
-export var noops = () => { };
-
-/** get or create kwizcom object from top window or current window, set allowFromTop if you want to try to get from window.top */
-export function getKWizComGlobal(allowFromTop?: boolean) {
-    if (allowFromTop) {
-        try {
-            $w.top["kwizcom"] = $w.top["kwizcom"] || {};
-            return $w.top["kwizcom"] as IKWizComGlobals;
-        } catch (ex) { }
-    }
-    $w["kwizcom"] = $w["kwizcom"] || {};
-    return $w["kwizcom"] as IKWizComGlobals;
-}
-/** get or create kwizcom.globals dictionary from top window or current window. Add or return key:name initialize as defaults or blank object if does not already exist */
-export function getGlobal<T>(name: string, defaults?: T, notFromTop?: boolean) {
-    var kGlobal = getKWizComGlobal(notFromTop !== true);
-    kGlobal.globals = kGlobal.globals || {};
-
-    if (!kGlobal.globals[name]) {
-        if (isObject(defaults)) {
-            // eslint-disable-next-line @typescript-eslint/ban-types
-            kGlobal.globals[name] = { ...(defaults as object) };
-        } else {
-            kGlobal.globals[name] = {};
-        }
-    }
-    return kGlobal.globals[name] as T;
-}
-
-/**
- * Automatically bind all functions of instance to instance
- * Note: if you use knockout, you should skip ko.isObservable
- * @param instance
- */
-//eslint-disable-next-line @typescript-eslint/ban-types
-export function autoBind(instance: any, skip?: (name: string, f: Function) => boolean) {
-    let funcitonNames = getAllFunctionNames(instance, 1);
-    funcitonNames.forEach(prop => {
-        const val = instance[prop];
-        if (!isFunction(skip) || !skip(prop, val))
-            instance[prop] = val.bind(instance);
-    });
-}
-
-/** Implements Object.assign which does not exist in IE
- *  Copies properties over from overrides into original object
- *  Merge default and override settings: var merged = assign({},defaults,props)
- *  Create deep copy of object by var copy = assign({},obj) */
-export function assign<T>(original: Partial<T>, ...overrides: Partial<T>[]): T {
-    if (original === undefined || original === null) {
-        throw new TypeError('Cannot convert first argument to object');
-    }
-
-    var to = Object(original);
-    if (overrides && overrides.length > 0)
-        overrides.forEach(o => {
-            if (!isNullOrUndefined(o)) {
-                var keysArray = Object.keys(Object(o));
-                for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
-                    var nextKey = keysArray[nextIndex];
-                    var desc = Object.getOwnPropertyDescriptor(o, nextKey);
-                    if (typeof (desc.value) === "undefined" || desc.value === null) {
-                        to[nextKey] = desc.value;
-                    }
-                    else if (typeof (desc.value) === "object") {
-                        //reference type, call assign  recursively. fixed problem that object value types from overrides were modified when the returnd object was modified.
-                        if (!Array.isArray(desc.value)) {
-                            to[nextKey] = assign({}, desc.value);
-                        } else {
-                            to[nextKey] = assign([], desc.value);
-                        }
-                    } else {
-                        if (desc !== undefined && desc.enumerable) {
-                            to[nextKey] = desc.value;//this will make a shallow copy, altering the override object o[nextKey];
-                        }
-                    }
-                }
-            }
-        });
-    return to as T;
-}
-
-export function primitivesEqual(o1: primitiveTypes, o2: primitiveTypes) {
-    let normalize = (oo: any) => {
-        if (isNullOrUndefined(oo))
-            return null;
-        else if (isDate(oo))
-            return oo.getTime();
-        return oo;
-    };
-    o1 = normalize(o1);
-    o2 = normalize(o2);
-
-    return o1 === o2;
-}
-export function objectsEqual<T extends object>(o1: T, o2: T, ignoreKeys?: string[]) {
-    let isPrimitive1 = isPrimitiveValue(o1);
-    let isPrimitive2 = isPrimitiveValue(o2);
-
-    if (isPrimitive1 !== isPrimitive2) return false;//one primitive other not?
-    if (isPrimitive1)
-        return primitivesEqual(o1 as unknown as primitiveTypes, o2 as unknown as primitiveTypes);
-
-    if (isFunction(o1) || isFunction(o2)) {
-        try {
-            return o1.toString() === o2.toString();
-        } catch (e) {
-            return false;
-        }
-    }
-
-    ignoreKeys = ignoreKeys || [];
-    let allKeys = makeUniqueArray(Object.keys(o1).concat(Object.keys(o2))).filter(key => !ignoreKeys.includes(key));
-    for (let i = 0; i < allKeys.length; i++) {
-        let key = allKeys[i];
-        if (!objectsEqual(o1[key], o2[key], ignoreKeys))
-            return false;
-    }
-    return true;
-}
-export function jsonClone<T>(obj: T): T {
-    //todo: check if assign utility method is faster
-    if (isNullOrUndefined(obj)) return null;
-    let result = obj;
-    try { result = jsonParse<T>(JSON.stringify(obj)); }
-    catch (e) {
-        if (isNotEmptyArray(obj))
-            result = (obj as any).slice();
-        else
-            result = obj;
-    }
-
-    //clone date objects
-    try { cloneDatesOnObjectRecursivily(obj, result); } catch (e) { }
-    return result;
-}
-
-function cloneDatesOnObjectRecursivily(obj1, obj2) {
-    Object.keys(obj1).forEach(key => {
-        let v = obj1[key];
-        if (v === null)
-            obj2[key] = null;
-        else if (isDate(v))
-            obj2[key] = new Date(v.getTime());
-        else if (isObject(v) && Object.keys(v).length) {
-            let v2 = obj2[key];
-            if (isObject(v2))
-                cloneDatesOnObjectRecursivily(v, v2);
-        }
-    });
-}
-
-/** if an object in this path doesnt exist under parent - creates it.*/
-export function ensureObjectPath(objectPath: string, defaultValue: any = {}, parent: any = $w) {
-    if (isNullOrEmptyString(objectPath)) return;
-    let parts = objectPath.split('.');
-    for (let i = 0; i < parts.length; i++) {
-        let partName = parts[i];
-        if (i === parts.length - 1)//last
-        {
-            if (isNullOrUndefined(parent[partName]))
-                parent[partName] = defaultValue;
-        }
-        else {
-            if (isNullOrUndefined(parent[partName]))
-                parent[partName] = {};
-            parent = parent[partName];
-        }
-    }
-}
-
-/** If o has propb and not propa - will copy propb into propa and remove propb */
-export function keepOne(o: any, propa: string, propb: string) {
-    /* using the unkown type doesn't work in modern apps project */
-    if (isObject(o)) {
-        if (!hasOwnProperty(o, propa) && hasOwnProperty(o, propb)) {
-            o[propa] = o[propb];
-            delete o[propb];
-        }
-    }
-}
-
-/**return all members and functions of an object, including inherited ones from its base class, excluding the constructor
- * send prototypeLevels to limit the number of prototype climbs to get functions from. 0 means unlimited.
- */
-export function getAllMemberNames(instance: any, prototypeLevels: number): string[] {
-    let props: string[] = [];
-    let obj = instance;
-    let level = 0;
-    let unlimitedLevels = prototypeLevels < 0;
-
-    do {
-        props.push(...Object.getOwnPropertyNames(obj));
-        obj = Object.getPrototypeOf(obj);
-        level++;
-    }
-    while (unlimitedLevels ? !!obj : !!obj && level <= prototypeLevels);
-
-    return makeUniqueArray(props.filter(p => p !== 'constructor' && p !== 'dispose'));
-}
-/**return all functions of an object, including inherited ones from its base class, excluding the constructor
- * send prototypeLevels to limit the number of prototype climbs to get functions from. 0 means unlimited.
- */
-export function getAllFunctionNames(instance: any, prototypeLevels: number): string[] {
-    return getAllMemberNames(instance, prototypeLevels).filter(p => isFunction(instance[p]));
-}
-
-/** generic implementation of Object.values */
-export function objectValues<T = any>(obj: any): T[] {
-    return Object.keys(obj).map((key) => {
-        return obj[key];
-    }) as T[];
-}
-
-export class DefaultProp<T> {
-    private _value: T;
-    private _defaultValue: T | (() => T);
-    private isValid: (value: T) => boolean;
-    public set value(newValue: T) { this._value = newValue; }
-    public get value() {
-        if (!this.isValid(this._value)) {
-            this._value = isFunction(this._defaultValue)
-                ? (this._defaultValue as () => T)()
-                : this._defaultValue;
-        }
-        return this._value;
-    }
-    public constructor(defaultValue: T | (() => T), initialValue?: T, isValid?: (value: T) => boolean) {
-        this._defaultValue = defaultValue;
-        this._value = initialValue;
-        this.isValid = isFunction(isValid) ? isValid : v => !isNullOrUndefined(v);
-    }
-}
-/** creates a safe property, if the value is null/undefined or empty string - it will return the default value. */
-export function GetDefaultProp<T>(defaultValue: T | (() => T), initialValue?: T, isValid?: (value: T) => boolean) {
-    return new DefaultProp(defaultValue, initialValue, isValid);
-}
-
-/** Get string error message from an error object */
-export function GetError(error: any, defaultError: string = "Unknown error"): string {
-    const err = isNullOrUndefined(error)
-        ? defaultError
-        : isString(error)
-            ? error
-            : isString((error as Error).message)
-                ? error.message
-                : defaultError;
-    return err.length > 0 ? err : defaultError;
-}

package/src/helpers/promises.test.js

@@ -1,38 +0,0 @@
-import assert from 'assert/strict';
-import test from 'node:test';
-import { promiseLock, promiseOnce, sleepAsync } from './promises';
-
-
-test('promiseOnce', async t => {
-    let promiseOnceTester = promiseOnce("promiseOnceTester", async() => {
-        return Date.now();
-    });
-
-    let value = await promiseOnceTester;
-    await t.test("First call", t => assert.strictEqual(value > 0, true));
-    //check cache
-    let value2 = await promiseOnceTester;
-    await t.test("Second call", t => assert.strictEqual(value === value2, true));
-    let value3 = await promiseOnceTester;
-    await t.test("Third call", t => assert.strictEqual(value === value3, true));
-});
-
-test('promisLock', async t => {
-
-    let promiseLockTester = async() => {
-        return new Date().getTime();
-    };
-
-    let p1 = promiseLock("promiseLockTest", promiseLockTester);
-    let p2 = promiseLock("promiseLockTest", promiseLockTester);
-
-    let v1 = await p1;
-    let v2 = await p2;
-
-    await sleepAsync(1);
-
-    let v3 = await promiseLock("promiseLockTest", promiseLockTester);
-
-    await t.test("During lock", t => assert.strictEqual(v1 === v2, true));
-    await t.test("After lock", t => assert.strictEqual(v1 === v3, false));
-});

package/src/helpers/promises.ts

@@ -1,166 +0,0 @@
-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 +0,0 @@
-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/exports-index.ts

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

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

@@ -1,104 +0,0 @@
-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));
-});