@bitblit/ratchet-common 4.0.80-alpha

package/dist/es/lang/map-ratchet.js

@@ -0,0 +1,164 @@
+import { Logger } from '../logger/logger';
+import { ErrorRatchet } from './error-ratchet';
+import { set } from 'lodash';
+export class MapRatchet {
+    static expandNestedKeys(src) {
+        const rval = {};
+        Object.keys(src).forEach((k) => {
+            set(rval, k, src[k]);
+        });
+        return rval;
+    }
+    static mapByUniqueProperty(input, propName) {
+        if (!input || !propName) {
+            throw new Error('Neither input nor propName can be null');
+        }
+        const rval = new Map();
+        input.forEach((i) => {
+            const val = !!i ? i[propName] : null;
+            if (val === null || val === undefined) {
+                throw new Error('No value for ' + propName + ' found in ' + JSON.stringify(i));
+            }
+            if (rval.has(val)) {
+                throw new Error('Multiple values found for ' + val);
+            }
+            rval.set(val, i);
+        });
+        return rval;
+    }
+    static groupByProperty(input, propName) {
+        if (!input || !propName) {
+            throw new Error('Neither input nor propName can be null');
+        }
+        const rval = new Map();
+        input.forEach((i) => {
+            const val = !!i ? i[propName] : null;
+            if (val === null || val === undefined) {
+                throw ErrorRatchet.fErr('No value for %s found in %j', propName, i);
+            }
+            if (!rval.has(val)) {
+                rval.set(val, []);
+            }
+            rval.get(val).push(i);
+        });
+        return rval;
+    }
+    static findValue(toSearch, path) {
+        if (!path || path.length == 0) {
+            return toSearch;
+        }
+        else {
+            if (toSearch) {
+                return MapRatchet.findValue(toSearch[path[0]], path.slice(1));
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    static findValueDotPath(toSearch, dotPath) {
+        if (!dotPath || dotPath.length == 0) {
+            return toSearch;
+        }
+        else {
+            if (toSearch) {
+                return MapRatchet.findValue(toSearch, dotPath.split('.'));
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    static simpleDeepCompare(object1, object2) {
+        if (object1 == null && object2 == null)
+            return true;
+        if (object1 == null || object2 == null)
+            return false;
+        return JSON.stringify(object1) == JSON.stringify(object2);
+    }
+    static toKeyValueList(value) {
+        const returnArray = [];
+        for (const k of Object.keys(value)) {
+            returnArray.push({
+                key: k,
+                value: value[k],
+            });
+        }
+        return returnArray;
+    }
+    static fromKeyValueList(list) {
+        const rval = {};
+        list.forEach((a) => (rval[a.key] = a.value));
+        return rval;
+    }
+    static cleanup(obj, stripZero = false, stripNull = true, stripUndefined = true, stripEmptyString = true) {
+        if (obj === null || obj === undefined || typeof obj !== 'object') {
+            return obj;
+        }
+        const o = JSON.parse(JSON.stringify(obj));
+        Object.keys(o).forEach((key) => {
+            if (o[key] && typeof o[key] === 'object') {
+                if (Array.isArray(o[key])) {
+                    for (let i = 0; i < o[key].length; i++) {
+                        o[key][i] = MapRatchet.cleanup(o[key][i]);
+                    }
+                }
+                else {
+                    o[key] = MapRatchet.cleanup(o[key]);
+                }
+            }
+            else if ((o[key] === undefined && stripUndefined) ||
+                (o[key] === null && stripNull) ||
+                (o[key] === '' && stripEmptyString) ||
+                (o[key] === 0 && stripZero)) {
+                delete o[key];
+            }
+            else {
+                o[key] = o[key];
+            }
+        });
+        return o;
+    }
+    static extractValueFromMapIgnoreCase(src, key) {
+        let rval = null;
+        if (src && key) {
+            const finder = key.toLowerCase();
+            Object.keys(src).forEach((s) => {
+                if (s.toLowerCase() === finder) {
+                    const newVal = src[s];
+                    if (rval) {
+                        Logger.warn('Multiple entries found for %s (replacing %s with %s', key, rval, newVal);
+                    }
+                    rval = newVal;
+                }
+            });
+        }
+        return rval;
+    }
+    static safeCallFunction(ob, fnName) {
+        let rval = false;
+        if (!!ob && !!ob[fnName] && typeof ob[fnName] === 'function') {
+            try {
+                ob[fnName]();
+                rval = true;
+            }
+            catch (err) {
+                Logger.warn('Error calling %s on %s : %s', fnName, ob, err, err);
+            }
+        }
+        return rval;
+    }
+    static caseInsensitiveAccess(ob, keyName) {
+        let rval = null;
+        if (!!ob && !!keyName) {
+            rval = ob[keyName];
+            if (!rval) {
+                const keyNameCI = Object.keys(ob).find((f) => f.toLowerCase() === keyName.toLowerCase());
+                if (!!keyNameCI) {
+                    rval = ob[keyNameCI];
+                }
+            }
+        }
+        return rval;
+    }
+}

package/dist/es/lang/no.js

@@ -0,0 +1,4 @@
+export class No {
+    static op(...args) {
+    }
+}

package/dist/es/lang/number-ratchet.js

@@ -0,0 +1,152 @@
+import { Logger } from '../logger/logger';
+import { RequireRatchet } from './require-ratchet';
+export class NumberRatchet {
+    static toFixedDecimalNumber(input, placesAfterPoint) {
+        const v = NumberRatchet.safeNumber(input);
+        return v === null || v === undefined ? v : NumberRatchet.safeNumber(v.toFixed(placesAfterPoint));
+    }
+    static leadingZeros(val, size) {
+        const sVal = String(val);
+        if (sVal.length < size) {
+            let pad = '0000';
+            if (size > NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH) {
+                throw 'Cannot format number that large (max length is ' + NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH + ')';
+            }
+            while (pad.length < size) {
+                pad = pad + pad;
+            }
+            return (pad + sVal).slice(-1 * size);
+        }
+        else {
+            return sVal;
+        }
+    }
+    static between(inTest, inP1, inP2) {
+        const test = NumberRatchet.safeNumber(inTest);
+        const p1 = NumberRatchet.safeNumber(inP1);
+        const p2 = NumberRatchet.safeNumber(inP2);
+        return (test >= p1 && test <= p2) || (test >= p2 && test <= p1);
+    }
+    static safeNumber(input, ifNotNumber = null) {
+        let rval = null;
+        if (input != null) {
+            const type = typeof input;
+            if (type == 'number') {
+                rval = input;
+            }
+            else if (type == 'string') {
+                if (input.trim().length === 0) {
+                    rval = ifNotNumber;
+                }
+                else {
+                    rval = Number.parseFloat(input);
+                }
+            }
+            else {
+                Logger.warn('Value is of type %s, returning default', type);
+                rval = ifNotNumber;
+            }
+            if (isNaN(rval)) {
+                Logger.debug('Parsed string to NaN - using NaN value from param');
+                rval = ifNotNumber;
+            }
+        }
+        return rval;
+    }
+    static numberCSVToList(inputCSV) {
+        let rval = null;
+        if (inputCSV) {
+            rval = inputCSV.split(',').map((s) => {
+                return NumberRatchet.safeNumber(s.trim());
+            });
+            rval = rval.filter((r) => typeof r === 'number' && !isNaN(r));
+        }
+        return rval;
+    }
+    static fitToWindow(val, b1, b2) {
+        let rval = val;
+        if (val === null || b1 === null || b2 === null || b1 < 0 || b2 < 0 || val < 0) {
+            throw new Error('All values must be non-null and larger than 0');
+        }
+        const low = Math.min(b1, b2);
+        const high = Math.max(b1, b2);
+        const windowSize = high - low;
+        if (high === low) {
+            rval = high;
+        }
+        else {
+            while (rval < low) {
+                rval += windowSize;
+            }
+            while (rval > high) {
+                rval -= windowSize;
+            }
+        }
+        return rval;
+    }
+    static groupNumbersIntoContiguousRanges(inputData, minRangeSize = 3) {
+        RequireRatchet.notNullOrUndefined(inputData);
+        const input = Object.assign([], inputData);
+        input.sort((a, b) => a - b);
+        const singles = [];
+        const ranges = [];
+        let start = 0;
+        for (let i = 1; i < input.length; i++) {
+            if (input[i] === input[i - 1] + 1) {
+            }
+            else {
+                if (start === i - 1) {
+                    singles.push(input[i - 1]);
+                }
+                else {
+                    const rangeSize = i - start;
+                    if (rangeSize < minRangeSize) {
+                        for (let j = start; j < i; j++) {
+                            singles.push(input[j]);
+                        }
+                    }
+                    else {
+                        ranges.push({
+                            min: input[start],
+                            max: input[i - 1],
+                        });
+                    }
+                }
+                start = i;
+            }
+        }
+        return {
+            singles: singles,
+            ranges: ranges,
+        };
+    }
+    static distributeItemsEvenly(items, buckets) {
+        RequireRatchet.notNullOrUndefined(items, 'items');
+        RequireRatchet.notNullOrUndefined(buckets, 'buckets');
+        RequireRatchet.true(items > 0 && items === Math.floor(items), 'Items integer larger than 0');
+        RequireRatchet.true(buckets > 0 && buckets === Math.floor(buckets), 'Buckets integer larger than 0');
+        const offset = buckets / items;
+        const rval = [];
+        for (let i = 0; i < buckets; i++) {
+            rval.push(0);
+        }
+        let loc = 0;
+        let rem = items;
+        while (rem > 0) {
+            rval[Math.floor(loc) % buckets]++;
+            rem--;
+            loc += offset;
+        }
+        return rval;
+    }
+    static createRange(minInclusive, maxExclusive, step = 1) {
+        const rval = [];
+        let val = minInclusive;
+        while (val < maxExclusive) {
+            rval.push(val);
+            val += step;
+        }
+        return rval;
+    }
+}
+NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH = 1000;

package/dist/es/lang/parsed-url.js

@@ -0,0 +1 @@
+export {};

package/dist/es/lang/promise-ratchet.js

@@ -0,0 +1,138 @@
+import { Logger } from '../logger/logger';
+import { ArrayRatchet } from './array-ratchet';
+import { TimeoutToken } from './timeout-token';
+import { StopWatch } from './stop-watch';
+import { LoggerLevelName } from '../logger/logger-level-name';
+export class PromiseRatchet {
+    static resolveOnEvent(evtSrc, okEvtNames, errEvtNames = [], rval = null) {
+        if (!evtSrc || !okEvtNames || okEvtNames.length === 0 || !evtSrc['on']) {
+            Promise.reject('Cannot continue - missing source object or name, or the object is not an event source');
+        }
+        return new Promise((res, rej) => {
+            okEvtNames.forEach((e) => {
+                evtSrc.on(e, () => {
+                    res(rval);
+                });
+            });
+            if (!!errEvtNames) {
+                errEvtNames.forEach((e) => {
+                    evtSrc.on(e, (err) => {
+                        rej(err);
+                    });
+                });
+            }
+        });
+    }
+    static timeout(srcPromise, title, timeoutMS) {
+        return Promise.race([srcPromise, PromiseRatchet.createTimeoutPromise(title, timeoutMS)]);
+    }
+    static createTimeoutPromise(title, timeoutMS) {
+        return new Promise((resolve, reject) => {
+            const id = setTimeout(() => {
+                clearTimeout(id);
+                const rval = new TimeoutToken(title, timeoutMS);
+                resolve(rval);
+            }, timeoutMS);
+        });
+    }
+    static async wait(time) {
+        await PromiseRatchet.createTimeoutPromise('Wait ' + time, time);
+        Logger.silly('Finished wait of %d ms', time);
+    }
+    static dumpResult(result, autoDebug = false) {
+        Logger.info('Success, result was : \n\n%s\n\n', JSON.stringify(result));
+        if (autoDebug) {
+            debugger;
+        }
+        process.exit(0);
+    }
+    static dumpError(err, autoDebug = false) {
+        Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
+        console.trace();
+        if (autoDebug) {
+            debugger;
+        }
+        process.exit(1);
+    }
+    static logErrorAndReturnNull(err, autoDebug = false) {
+        Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
+        if (autoDebug) {
+            debugger;
+        }
+        return null;
+    }
+    static runPromiseAndDump(promise) {
+        promise.then(PromiseRatchet.dumpResult).catch(PromiseRatchet.dumpError);
+    }
+    static async waitFor(testFunction, expectedValue, intervalMS, maxCycles, label = 'waitFor', count = 0) {
+        if (expectedValue == null || intervalMS < 50 || maxCycles < 1 || count < 0 || typeof testFunction != 'function') {
+            Logger.warn('%s: Invalid configuration for waitFor - exiting immediately', label);
+            Logger.warn('ExpectedValue : %s ; interval: %d ; maxCycles: %d ; test : %s', expectedValue, intervalMS, maxCycles, typeof testFunction);
+            return false;
+        }
+        let curVal = null;
+        try {
+            curVal = testFunction(count);
+        }
+        catch (err) {
+            Logger.warn('%s: Caught error while waiting, giving up', label);
+            return false;
+        }
+        if (curVal === null) {
+            Logger.debug('%s:CurVal was null - aborting', label);
+            return false;
+        }
+        else if (curVal == expectedValue) {
+            Logger.debug('%s:Found expected value', label);
+            return true;
+        }
+        else if (count > maxCycles) {
+            Logger.debug('%s:Exceeded max cycles, giving up', label);
+            return false;
+        }
+        else {
+            Logger.debug('%s : value not reached yet, waiting (count = %d of %d)', label, count, maxCycles);
+            await PromiseRatchet.wait(intervalMS);
+            return PromiseRatchet.waitFor(testFunction, expectedValue, intervalMS, maxCycles, label, count + 1);
+        }
+    }
+    static async runBoundedParallel(promiseFn, params, context, maxConcurrent = 1, logLevel = LoggerLevelName.debug) {
+        const sw = new StopWatch();
+        let rval = [];
+        let remain = params;
+        Logger.logByLevel(logLevel, 'Processing %d total elements %d at a time', params.length, maxConcurrent);
+        const ctx = context || this;
+        let processed = 0;
+        const totalCount = remain.length;
+        while (remain.length > 0) {
+            const curBatch = remain.slice(0, Math.min(remain.length, maxConcurrent));
+            remain = remain.slice(curBatch.length);
+            const proms = curBatch.map((c) => promiseFn.apply(ctx, c));
+            const output = await Promise.all(proms);
+            processed += proms.length;
+            rval = rval.concat(output);
+            const pct = processed / totalCount;
+            Logger.logByLevel(logLevel, '%d elements remain : %s', remain.length, sw.dumpExpected(pct));
+        }
+        sw.log();
+        return rval;
+    }
+    static async runBoundedParallelSingleParam(promiseFn, params, context, maxConcurrent = 1, logLevel = LoggerLevelName.debug) {
+        const wrappedParams = ArrayRatchet.wrapElementsInArray(params);
+        return PromiseRatchet.runBoundedParallel(promiseFn, wrappedParams, context, maxConcurrent, logLevel);
+    }
+    static async asyncForEachSerial(array, callback) {
+        for (let index = 0; index < array.length; index++) {
+            await callback(array[index], index, array);
+        }
+    }
+    static async asyncForEachParallel(array, callback) {
+        const proms = [];
+        for (let index = 0; index < array.length; index++) {
+            proms.push(callback(array[index], index, array));
+        }
+        await Promise.all(proms);
+    }
+    constructor() {
+    }
+}

package/dist/es/lang/require-ratchet.js

@@ -0,0 +1,56 @@
+import { ErrorRatchet } from './error-ratchet';
+export class RequireRatchet {
+    static isNullOrUndefined(ob) {
+        return ob === null || ob === undefined;
+    }
+    static notNullOrUndefined(ob, name = 'object') {
+        if (RequireRatchet.isNullOrUndefined(ob)) {
+            throw new Error(name + ' may not be null or undefined');
+        }
+    }
+    static notNullUndefinedOrOnlyWhitespaceString(ob, name = 'string') {
+        if (RequireRatchet.isNullOrUndefined(ob) || ob.trim() === '') {
+            throw new Error(name + ' may not be null or undefined or only whitespace string');
+        }
+    }
+    static notNullUndefinedOrEmptyArray(ob, name = 'string') {
+        if (RequireRatchet.isNullOrUndefined(ob) || ob.length === 0) {
+            throw new Error(name + ' may not be null or undefined or an empty array');
+        }
+    }
+    static equal(ob1, ob2, message = 'Values must be equal') {
+        if (ob1 !== ob2) {
+            throw new Error(message);
+        }
+    }
+    static true(ob, message = 'Value must be true') {
+        RequireRatchet.equal(ob, true, message);
+    }
+    static noNullOrUndefinedValuesInArray(arr, expectedLength = null, customMsg = null) {
+        RequireRatchet.notNullOrUndefined(arr, 'Source array may not be null');
+        if (expectedLength !== null && arr.length !== expectedLength) {
+            ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d %s', expectedLength, arr.length, customMsg);
+        }
+        for (let i = 0; i < arr.length; i++) {
+            if (RequireRatchet.isNullOrUndefined(arr[i])) {
+                ErrorRatchet.throwFormattedErr('Array index %d was null or undefined %s', i, customMsg);
+            }
+        }
+    }
+    static noNullOrUndefinedValuesInRestArgs(expectedLength, ...restArgs) {
+        RequireRatchet.notNullOrUndefined(restArgs, 'Source array may not be null');
+        if (expectedLength !== null && restArgs.length !== expectedLength) {
+            ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d', expectedLength, restArgs.length);
+        }
+        for (let i = 0; i < restArgs.length; i++) {
+            if (RequireRatchet.isNullOrUndefined(restArgs[i])) {
+                ErrorRatchet.throwFormattedErr('Array index %d was null or undefined', i);
+            }
+        }
+    }
+    static constructorArgumentsMatchLengthAndAreNonNull() {
+        const args = Array.from(arguments);
+        const len = this.constructor.length;
+        return RequireRatchet.noNullOrUndefinedValuesInArray(args, len);
+    }
+}

package/dist/es/lang/stop-watch.js

@@ -0,0 +1,113 @@
+import { DurationRatchet } from './duration-ratchet';
+import { StringRatchet } from './string-ratchet';
+import { RequireRatchet } from './require-ratchet';
+import { LoggerLevelName } from '../logger/logger-level-name';
+import { Logger } from '../logger/logger';
+export class StopWatch {
+    constructor(label = StringRatchet.createRandomHexString(4)) {
+        this.label = label;
+        this.starts = new Map();
+        this.ends = new Map();
+        this.createTime = Date.now();
+    }
+    start(name) {
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        const now = Date.now();
+        this.starts.set(StringRatchet.trimToNull(name), now);
+        return now;
+    }
+    stop(name) {
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        const now = Date.now();
+        this.ends.set(StringRatchet.trimToNull(name), now);
+        return now;
+    }
+    reset(name) {
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        this.starts.delete(StringRatchet.trimToNull(name));
+        this.ends.delete(StringRatchet.trimToNull(name));
+    }
+    hasTimer(name) {
+        RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        return this.starts.has(name);
+    }
+    log(name, shortForm, logLevel = LoggerLevelName.info) {
+        Logger.logByLevel(logLevel, this.dump(name, shortForm));
+    }
+    logExpected(pctComplete, name, shortForm, logLevel = LoggerLevelName.info) {
+        Logger.logByLevel(logLevel, this.dumpExpected(pctComplete, name, shortForm));
+    }
+    dump(name, shortForm) {
+        let rval = this.label + ' ';
+        const cleanName = StringRatchet.trimToNull(name);
+        if (cleanName && !this.hasTimer(cleanName)) {
+            rval += 'No such timer : ' + cleanName;
+        }
+        else {
+            const start = name ? this.starts.get(cleanName) : this.createTime;
+            const end = name ? this.ends.get(cleanName) : Date.now();
+            rval += (cleanName || 'Default') + ' ';
+            if (!!start && !!end) {
+                rval += 'completed in ' + DurationRatchet.formatMsDuration(end - start, !shortForm);
+            }
+            else if (!!start) {
+                rval += 'running for ' + DurationRatchet.formatMsDuration(Date.now() - start, !shortForm);
+            }
+        }
+        return rval;
+    }
+    dumpExpected(pctComplete, name, shortForm) {
+        let rval = this.label + ' ';
+        const cleanName = StringRatchet.trimToNull(name);
+        if (cleanName && !this.hasTimer(cleanName)) {
+            rval += 'No such timer : ' + cleanName;
+        }
+        else {
+            if (!pctComplete || pctComplete <= 0) {
+                rval += 'Cannot generate output for 0 percent complete';
+            }
+            else if (pctComplete > 1) {
+                rval += 'Cannot generate output for percent > 1';
+            }
+            else {
+                rval += (cleanName || 'Default') + ' ';
+                const start = name ? this.starts.get(cleanName) : this.createTime;
+                const end = name ? this.ends.get(cleanName) : Date.now();
+                if (!!start && !!end) {
+                    rval += 'completed in ' + DurationRatchet.formatMsDuration(end - start, !shortForm);
+                }
+                else if (!!start) {
+                    const now = Date.now();
+                    const elapsedMS = now - start;
+                    const expectedTotalMS = elapsedMS / pctComplete;
+                    const remainMS = expectedTotalMS - elapsedMS;
+                    rval +=
+                        'running for ' +
+                            DurationRatchet.formatMsDuration(elapsedMS, !shortForm) +
+                            ' approx ' +
+                            DurationRatchet.formatMsDuration(remainMS, !shortForm) +
+                            ' remaining';
+                }
+            }
+        }
+        return rval;
+    }
+    elapsedMS(name) {
+        let rval = null;
+        const cleanName = StringRatchet.trimToNull(name);
+        if (cleanName && !this.hasTimer(cleanName)) {
+            rval = null;
+        }
+        else {
+            const start = name ? this.starts.get(cleanName) : this.createTime;
+            const end = name ? this.ends.get(cleanName) : Date.now();
+            if (!!start && !!end) {
+                rval = end - start;
+            }
+            else if (!!start) {
+                rval = Date.now() - start;
+            }
+        }
+        return rval;
+    }
+}