@bitblit/ratchet-common 4.0.80-alpha

package/dist/cjs/lang/array-ratchet.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayRatchet = void 0;
+const require_ratchet_1 = require("./require-ratchet");
+const map_ratchet_1 = require("./map-ratchet");
+class ArrayRatchet {
+    static wrapElementsInArray(input) {
+        return input.map((i) => [i]);
+    }
+    static compareTwoArrays(ar1, ar2, fn) {
+        ar1.sort(fn);
+        ar2.sort(fn);
+        let id1 = 0;
+        let id2 = 0;
+        const rval = {
+            matching: [],
+            setOneOnly: [],
+            setTwoOnly: [],
+        };
+        while (id1 < ar1.length && id2 < ar2.length) {
+            const aVal = ar1[id1];
+            const pVal = ar2[id2];
+            const comp = fn(aVal, pVal);
+            if (comp === 0) {
+                rval.matching.push(aVal);
+                id1++;
+                id2++;
+            }
+            else if (comp < 0) {
+                rval.setOneOnly.push(aVal);
+                id1++;
+            }
+            else {
+                rval.setTwoOnly.push(pVal);
+                id2++;
+            }
+        }
+        if (id1 < ar1.length - 1) {
+            rval.setOneOnly = rval.setOneOnly.concat(ar1.slice(id1));
+        }
+        if (id2 < ar2.length - 1) {
+            rval.setTwoOnly = rval.setTwoOnly.concat(ar2.slice(id2));
+        }
+        return rval;
+    }
+    static extractSubarrayFromSortedByNumberField(input, fieldDotPath, minInclusive, maxExclusive) {
+        if (!input || input.length === 0) {
+            return input;
+        }
+        let bottomIdx = minInclusive === null ? 0 : ArrayRatchet.findSplit(input, fieldDotPath, minInclusive) || 0;
+        const topIdx = maxExclusive === null ? input.length : ArrayRatchet.findSplit(input, fieldDotPath, maxExclusive);
+        const bottomValue = map_ratchet_1.MapRatchet.findValueDotPath(input[bottomIdx], fieldDotPath);
+        if (bottomIdx === input.length - 1 && bottomValue < minInclusive) {
+            return [];
+        }
+        if (bottomIdx < input.length && bottomIdx < topIdx && bottomValue < minInclusive) {
+            bottomIdx++;
+        }
+        return input.slice(bottomIdx, topIdx + 1);
+    }
+    static findSplit(input, fieldDotPath, target) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(input);
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(fieldDotPath);
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(target);
+        if (input.length === 0 || map_ratchet_1.MapRatchet.findValueDotPath(input[0], fieldDotPath) > target) {
+            return null;
+        }
+        let min = 0;
+        let max = input.length;
+        let rval = null;
+        while (rval === null) {
+            const curIdx = Math.floor((min + max) / 2);
+            const curVal = map_ratchet_1.MapRatchet.findValueDotPath(input[curIdx], fieldDotPath);
+            if (min === max || min === max - 1) {
+                rval = min;
+            }
+            else if (curVal <= target) {
+                min = curIdx;
+            }
+            else {
+                max = curIdx;
+            }
+        }
+        return rval;
+    }
+}
+exports.ArrayRatchet = ArrayRatchet;

package/dist/cjs/lang/base64-ratchet.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64Ratchet = void 0;
+const logger_1 = require("../logger/logger");
+class Base64Ratchet {
+    static safeObjectToBase64JSON(input) {
+        return !!input ? Base64Ratchet.generateBase64VersionOfString(JSON.stringify(input)) : null;
+    }
+    static safeBase64JSONParse(input) {
+        let rval = {};
+        try {
+            if (input) {
+                rval = JSON.parse(Base64Ratchet.base64StringToString(input));
+            }
+        }
+        catch (err) {
+            logger_1.Logger.warn('Error parsing b64/json : %s as json, got %s', input, err, err);
+            rval = {};
+        }
+        return rval;
+    }
+    static generateBase64VersionOfBlob(blob) {
+        return new Promise(function (resolve, reject) {
+            if (!blob || blob.size == 0) {
+                reject('Wont convert null or non-blob or empty blob');
+            }
+            else {
+                const reader = new FileReader();
+                reader.onloadend = function () {
+                    resolve(reader.result.toString());
+                };
+                reader.readAsDataURL(blob);
+            }
+        });
+    }
+    static generateBase64VersionOfString(input) {
+        return Base64Ratchet.generateBase64VersionOfBuffer(Buffer.from(input));
+    }
+    static generateBase64VersionOfBuffer(input) {
+        return input.toString('base64');
+    }
+    static base64StringToBuffer(input) {
+        return Buffer.from(input, 'base64');
+    }
+    static base64StringToString(input, encoding = 'utf8') {
+        return Buffer.from(input, 'base64').toString(encoding);
+    }
+}
+exports.Base64Ratchet = Base64Ratchet;

package/dist/cjs/lang/boolean-ratchet.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanRatchet = void 0;
+const number_ratchet_1 = require("./number-ratchet");
+class BooleanRatchet {
+    static allTrue(vals, emptyArraysReturn = false) {
+        let rval = null;
+        if (!!vals) {
+            if (vals.length > 0) {
+                rval = vals.reduce((a, i) => a && i, true);
+            }
+            else {
+                rval = emptyArraysReturn;
+            }
+        }
+        else {
+            rval = false;
+        }
+        return rval;
+    }
+    static anyTrue(vals, emptyArraysReturn = false) {
+        let rval = null;
+        if (!!vals) {
+            if (vals.length > 0) {
+                rval = vals.reduce((a, i) => a || i, false);
+            }
+            else {
+                rval = emptyArraysReturn;
+            }
+        }
+        else {
+            rval = false;
+        }
+        return rval;
+    }
+    static parseBool(val) {
+        return val === true || (val !== null && val !== undefined && typeof val === 'string' && val.toLowerCase() === 'true');
+    }
+    static intToBool(val) {
+        if (val === null || val === undefined) {
+            return false;
+        }
+        return number_ratchet_1.NumberRatchet.safeNumber(val) !== 0;
+    }
+    static boolToInt(val) {
+        return BooleanRatchet.parseBool(val) ? 1 : 0;
+    }
+}
+exports.BooleanRatchet = BooleanRatchet;

package/dist/cjs/lang/composite-last-success-provider.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeLastSuccessProvider = void 0;
+class CompositeLastSuccessProvider {
+    constructor(src, mostRecentSrc = true) {
+        if (!src || src.length == 0) {
+            throw Error('Cannot create composite provider with null/empty sources');
+        }
+        this.sources = src;
+        this.mostRecent = mostRecentSrc;
+    }
+    lastSuccess() {
+        let rval = null;
+        this.sources.forEach((s) => {
+            const val = s.lastSuccess();
+            if (val != null) {
+                if (rval == null) {
+                    rval = val;
+                }
+                else {
+                    rval = (val > rval && this.mostRecent) || (val < rval && !this.mostRecent) ? val : rval;
+                }
+            }
+        });
+        return rval;
+    }
+}
+exports.CompositeLastSuccessProvider = CompositeLastSuccessProvider;

package/dist/cjs/lang/date-ratchet.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateRatchet = void 0;
+const luxon_1 = require("luxon");
+class DateRatchet {
+    static formatFullDate(input) {
+        return luxon_1.DateTime.fromJSDate(input).toFormat(DateRatchet.FULL_DATE_FORMAT);
+    }
+    static formatDefaultDateOnly(input) {
+        return luxon_1.DateTime.fromJSDate(input).toFormat(DateRatchet.DEFAULT_DATE_FORMAT);
+    }
+    static parseDefaultDate(input) {
+        const rval = luxon_1.DateTime.fromFormat(input, DateRatchet.DEFAULT_DATE_FORMAT).toJSDate();
+        return rval;
+    }
+    static parseCommonUsDate(input) {
+        let rval = null;
+        if (!!input) {
+            let templ = DateRatchet.COMMON_US_DATE_FORMAT;
+            if (input.indexOf('-') === 2) {
+                templ = templ.split('/').join('-');
+            }
+            rval = luxon_1.DateTime.fromFormat(input, templ).toJSDate();
+        }
+        return rval;
+    }
+}
+exports.DateRatchet = DateRatchet;
+DateRatchet.COMMON_US_DATE_FORMAT = 'MM/dd/yyyy';
+DateRatchet.DEFAULT_DATE_FORMAT = 'yyyy-MM-dd';
+DateRatchet.FULL_DATE_FORMAT = 'yyyy-MM-dd_HH_mm_ss';
+DateRatchet.PACIFIC_TIME_ZONE = 'America/Los_Angeles';
+DateRatchet.UTC_TIME_ZONE = 'etc/UTC';

package/dist/cjs/lang/duration-ratchet.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationRatchet = void 0;
+const luxon_1 = require("luxon");
+const number_ratchet_1 = require("./number-ratchet");
+class DurationRatchet {
+    static formatMsDuration(ms, includeMS = false) {
+        const rem_ms = Math.floor(ms % 1000);
+        const seconds = Math.floor(ms / 1000) % 60;
+        const minutes = Math.floor(ms / (1000 * 60)) % 60;
+        const hours = Math.floor(ms / (1000 * 60 * 60)) % 24;
+        const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+        const f = number_ratchet_1.NumberRatchet.leadingZeros;
+        let rval = f(hours, 2) + 'h' + f(minutes, 2) + 'm';
+        rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) + 's' : f(seconds, 2) + 's';
+        if (days > 0) {
+            rval = days + 'd' + rval;
+        }
+        return rval;
+    }
+    static colonFormatMsDuration(ms, includeMS = false) {
+        const rem_ms = ms % 1000;
+        const seconds = Math.floor(ms / 1000) % 60;
+        const minutes = Math.floor(ms / (1000 * 60)) % 60;
+        const hours = Math.floor(ms / (1000 * 60 * 60));
+        const f = number_ratchet_1.NumberRatchet.leadingZeros;
+        let rval = f(hours, 2) + ':' + f(minutes, 2) + ':';
+        rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) : f(seconds, 2);
+        return rval;
+    }
+    static daysBetween(d1, d2) {
+        const dur = luxon_1.DateTime.fromJSDate(d1).diff(luxon_1.DateTime.fromJSDate(d2));
+        return dur.days;
+    }
+    static createSteps(startEpochMS, endEpochMS, timezone, outputFormat, stepUnit) {
+        let curDate = luxon_1.DateTime.fromMillis(startEpochMS).setZone(timezone);
+        const endDate = luxon_1.DateTime.fromMillis(endEpochMS);
+        const rval = [];
+        while (curDate < endDate) {
+            rval.push(curDate.toFormat(outputFormat));
+            curDate = curDate.plus(stepUnit);
+        }
+        return rval;
+    }
+}
+exports.DurationRatchet = DurationRatchet;

package/dist/cjs/lang/enum-ratchet.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumRatchet = void 0;
+const ts_enum_util_1 = require("ts-enum-util");
+const string_ratchet_1 = require("./string-ratchet");
+class EnumRatchet {
+    static listEnumKeys(enumeration) {
+        const rval = (0, ts_enum_util_1.$enum)(enumeration).getValues();
+        return rval;
+    }
+    static keyToEnum(enumeration, val, caseSensitive = false) {
+        const e = (0, ts_enum_util_1.$enum)(enumeration);
+        let rval = null;
+        if (!!val) {
+            rval = e.asValueOrDefault(val, null);
+            if (!rval && !caseSensitive) {
+                const keys = EnumRatchet.listEnumKeys(enumeration);
+                const mKey = keys.find((k) => k.toUpperCase() === val.toUpperCase());
+                if (!!mKey) {
+                    rval = e.asValueOrDefault(mKey, null);
+                }
+            }
+        }
+        return rval;
+    }
+    static parseCsvToEnumArray(enumeration, input) {
+        const split = string_ratchet_1.StringRatchet.trimToEmpty(input)
+            .split(',')
+            .map((s) => s.trim());
+        const rval = split.map((s) => EnumRatchet.keyToEnum(enumeration, s)).filter((s) => !!s);
+        return rval;
+    }
+}
+exports.EnumRatchet = EnumRatchet;

package/dist/cjs/lang/error-ratchet.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorRatchet = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = require("../logger/logger");
+const util_1 = tslib_1.__importDefault(require("util"));
+class ErrorRatchet {
+    static safeStringifyErr(err, log = true) {
+        let rval = 'ERR WAS NULL';
+        if (err) {
+            if (err['message']) {
+                rval = err['message'];
+            }
+            else {
+                try {
+                    rval = JSON.stringify(err);
+                }
+                catch (err2) {
+                    logger_1.Logger.error('Failed to json stringify');
+                    rval = String(err);
+                }
+            }
+        }
+        if (log) {
+            logger_1.Logger.error('%s', rval, err);
+        }
+        return rval;
+    }
+    static asErr(input) {
+        let rval = null;
+        if (input) {
+            if (input instanceof Error) {
+                rval = input;
+            }
+            else {
+                rval = new Error('Force-Cast to error : ' + String(input));
+            }
+        }
+        return rval;
+    }
+    static fErr(format, ...input) {
+        const msg = util_1.default.format(format, ...input);
+        return new Error(msg);
+    }
+    static throwFormattedErr(format, ...input) {
+        throw ErrorRatchet.fErr(format, ...input);
+    }
+}
+exports.ErrorRatchet = ErrorRatchet;

package/dist/cjs/lang/expiring-object.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiringObjectConfig = exports.ExpiringObject = void 0;
+const logger_1 = require("../logger/logger");
+const error_ratchet_1 = require("./error-ratchet");
+const logger_level_name_1 = require("../logger/logger-level-name");
+class ExpiringObject {
+    constructor(inputConfig) {
+        this._config = Object.assign({}, this.defaultConfig(), inputConfig || {});
+        if (this._config.overrideTimeRemainingMS && this._config.timeToLiveMS) {
+            error_ratchet_1.ErrorRatchet.throwFormattedErr('Cannot define both time to live and overrideTimeRemainingMS');
+        }
+        if (!this._config.overrideTimeRemainingMS && !this._config.timeToLiveMS) {
+            error_ratchet_1.ErrorRatchet.throwFormattedErr('Must define exactly one of timeToLiveMS or overrideTimeRemainingMS');
+        }
+        if (this._config.initialValue) {
+            this.update(this._config.initialValue);
+        }
+        this._timeRemainingMS = this._config.overrideTimeRemainingMS || this.defaultTimeRemainingMS;
+    }
+    defaultConfig() {
+        const rval = {
+            generator: null,
+            initialValue: null,
+            logLevel: logger_level_name_1.LoggerLevelName.debug,
+            overrideTimeRemainingMS: null,
+            timeToLiveMS: 1000 * 60,
+        };
+        return rval;
+    }
+    async defaultTimeRemainingMS(lastUpdatedEpochMS) {
+        let rval = 0;
+        if (lastUpdatedEpochMS) {
+            const ageMS = new Date().getTime() - lastUpdatedEpochMS;
+            rval = Math.max(0, this._config.timeToLiveMS - ageMS);
+        }
+        return rval;
+    }
+    update(newValue, doNotUpdateClock = false) {
+        this._cacheObject = newValue;
+        if (!doNotUpdateClock) {
+            this._lastUpdatedEpochMS = new Date().getTime();
+        }
+        logger_1.Logger.logByLevel(this._config.logLevel, 'Updated cache value to %j', newValue);
+    }
+    async fetchCacheObjectTimeRemainingMS() {
+        return this._timeRemainingMS(this._lastUpdatedEpochMS);
+    }
+    async fetch() {
+        const remainMS = await this._timeRemainingMS(this._lastUpdatedEpochMS);
+        if (!remainMS) {
+            this._cacheObject = null;
+            this._lastUpdatedEpochMS = null;
+        }
+        if (!this._cacheObject) {
+            if (this._config.generator) {
+                const newValue = await this._config.generator();
+                logger_1.Logger.logByLevel(this._config.logLevel, 'Auto call to generator returned %j', newValue);
+                this.update(newValue);
+            }
+        }
+        return this._cacheObject;
+    }
+}
+exports.ExpiringObject = ExpiringObject;
+class ExpiringObjectConfig {
+}
+exports.ExpiringObjectConfig = ExpiringObjectConfig;