@bitblit/ratchet-common 4.0.80-alpha

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseRatchet = void 0;
+const logger_1 = require("../logger/logger");
+const array_ratchet_1 = require("./array-ratchet");
+const timeout_token_1 = require("./timeout-token");
+const stop_watch_1 = require("./stop-watch");
+const logger_level_name_1 = require("../logger/logger-level-name");
+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 timeout_token_1.TimeoutToken(title, timeoutMS);
+                resolve(rval);
+            }, timeoutMS);
+        });
+    }
+    static async wait(time) {
+        await PromiseRatchet.createTimeoutPromise('Wait ' + time, time);
+        logger_1.Logger.silly('Finished wait of %d ms', time);
+    }
+    static dumpResult(result, autoDebug = false) {
+        logger_1.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_1.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_1.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_1.Logger.warn('%s: Invalid configuration for waitFor - exiting immediately', label);
+            logger_1.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_1.Logger.warn('%s: Caught error while waiting, giving up', label);
+            return false;
+        }
+        if (curVal === null) {
+            logger_1.Logger.debug('%s:CurVal was null - aborting', label);
+            return false;
+        }
+        else if (curVal == expectedValue) {
+            logger_1.Logger.debug('%s:Found expected value', label);
+            return true;
+        }
+        else if (count > maxCycles) {
+            logger_1.Logger.debug('%s:Exceeded max cycles, giving up', label);
+            return false;
+        }
+        else {
+            logger_1.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 = logger_level_name_1.LoggerLevelName.debug) {
+        const sw = new stop_watch_1.StopWatch();
+        let rval = [];
+        let remain = params;
+        logger_1.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_1.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 = logger_level_name_1.LoggerLevelName.debug) {
+        const wrappedParams = array_ratchet_1.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() {
+    }
+}
+exports.PromiseRatchet = PromiseRatchet;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireRatchet = void 0;
+const error_ratchet_1 = require("./error-ratchet");
+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) {
+            error_ratchet_1.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])) {
+                error_ratchet_1.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) {
+            error_ratchet_1.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])) {
+                error_ratchet_1.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);
+    }
+}
+exports.RequireRatchet = RequireRatchet;

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopWatch = void 0;
+const duration_ratchet_1 = require("./duration-ratchet");
+const string_ratchet_1 = require("./string-ratchet");
+const require_ratchet_1 = require("./require-ratchet");
+const logger_level_name_1 = require("../logger/logger-level-name");
+const logger_1 = require("../logger/logger");
+class StopWatch {
+    constructor(label = string_ratchet_1.StringRatchet.createRandomHexString(4)) {
+        this.label = label;
+        this.starts = new Map();
+        this.ends = new Map();
+        this.createTime = Date.now();
+    }
+    start(name) {
+        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        const now = Date.now();
+        this.starts.set(string_ratchet_1.StringRatchet.trimToNull(name), now);
+        return now;
+    }
+    stop(name) {
+        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        const now = Date.now();
+        this.ends.set(string_ratchet_1.StringRatchet.trimToNull(name), now);
+        return now;
+    }
+    reset(name) {
+        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        this.starts.delete(string_ratchet_1.StringRatchet.trimToNull(name));
+        this.ends.delete(string_ratchet_1.StringRatchet.trimToNull(name));
+    }
+    hasTimer(name) {
+        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+        return this.starts.has(name);
+    }
+    log(name, shortForm, logLevel = logger_level_name_1.LoggerLevelName.info) {
+        logger_1.Logger.logByLevel(logLevel, this.dump(name, shortForm));
+    }
+    logExpected(pctComplete, name, shortForm, logLevel = logger_level_name_1.LoggerLevelName.info) {
+        logger_1.Logger.logByLevel(logLevel, this.dumpExpected(pctComplete, name, shortForm));
+    }
+    dump(name, shortForm) {
+        let rval = this.label + ' ';
+        const cleanName = string_ratchet_1.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 ' + duration_ratchet_1.DurationRatchet.formatMsDuration(end - start, !shortForm);
+            }
+            else if (!!start) {
+                rval += 'running for ' + duration_ratchet_1.DurationRatchet.formatMsDuration(Date.now() - start, !shortForm);
+            }
+        }
+        return rval;
+    }
+    dumpExpected(pctComplete, name, shortForm) {
+        let rval = this.label + ' ';
+        const cleanName = string_ratchet_1.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 ' + duration_ratchet_1.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 ' +
+                            duration_ratchet_1.DurationRatchet.formatMsDuration(elapsedMS, !shortForm) +
+                            ' approx ' +
+                            duration_ratchet_1.DurationRatchet.formatMsDuration(remainMS, !shortForm) +
+                            ' remaining';
+                }
+            }
+        }
+        return rval;
+    }
+    elapsedMS(name) {
+        let rval = null;
+        const cleanName = string_ratchet_1.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;
+    }
+}
+exports.StopWatch = StopWatch;

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringRatchet = void 0;
+const require_ratchet_1 = require("./require-ratchet");
+class StringRatchet {
+    static stringToUint8Array(val) {
+        return val ? new TextEncoder().encode(val) : null;
+    }
+    static uint8ArrayToString(val) {
+        return val ? new TextDecoder().decode(val) : null;
+    }
+    static attemptJsonParse(val) {
+        let rval = null;
+        if (StringRatchet.trimToNull(val)) {
+            try {
+                rval = JSON.parse(val);
+            }
+            catch (err) {
+                rval = null;
+            }
+        }
+        return rval;
+    }
+    static canParseAsJson(val) {
+        return !!StringRatchet.attemptJsonParse(val);
+    }
+    static allUnique(input) {
+        let rval = true;
+        if (input) {
+            const check = new Set();
+            for (let i = 0; i < input.length && rval; i++) {
+                const test = input.charAt(i);
+                rval = !check.has(test);
+                check.add(test);
+            }
+        }
+        return rval;
+    }
+    static allPermutationsOfLength(len, alphabet) {
+        const rval = [];
+        if (len > 0 && alphabet && alphabet.length > 0) {
+            require_ratchet_1.RequireRatchet.true(StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
+            const step = len === 1 ? [''] : StringRatchet.allPermutationsOfLength(len - 1, alphabet);
+            for (let i = 0; i < alphabet.length; i++) {
+                step.forEach((s) => rval.push(alphabet.charAt(i) + s));
+            }
+        }
+        return rval;
+    }
+    static createType4Guid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static createRandomHexString(len = 10) {
+        let r = '';
+        for (let i = 0; i < len; i++) {
+            r += Math.floor(Math.random() * 16).toString(16);
+        }
+        return r;
+    }
+    static canonicalize(value) {
+        let rval = value ? value.toLowerCase() : '';
+        rval = rval.replace(' ', '-');
+        StringRatchet.RFC_3986_RESERVED.forEach((s) => {
+            rval = rval.replace(s, '');
+        });
+        return rval;
+    }
+    static formatBytes(bytes, decimals = 2) {
+        if (bytes == 0)
+            return '0 Bytes';
+        const k = 1024, dm = decimals || 2, sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+    }
+    static safeString(input) {
+        let rval = null;
+        if (input != null) {
+            const type = typeof input;
+            if (type == 'string') {
+                rval = input;
+            }
+            else {
+                rval = String(input);
+            }
+        }
+        return rval;
+    }
+    static stringContainsOnlyNumbers(input) {
+        const rval = /^[0-9]+$/.test(input);
+        return rval;
+    }
+    static stringContainsOnlyAlphanumeric(input) {
+        const rval = /^[0-9a-zA-Z]+$/.test(input);
+        return rval;
+    }
+    static stringContainsOnlyHex(input) {
+        const rval = /^[0-9a-fA-F]+$/.test(input);
+        return rval;
+    }
+    static stringContainsOnly(inVal, validCharsIn) {
+        const input = !inVal ? '' : inVal;
+        const validChars = !validCharsIn ? '' : validCharsIn;
+        let rval = true;
+        for (let i = 0; i < input.length && rval; i++) {
+            rval = validChars.indexOf(input.charAt(i)) >= 0;
+        }
+        return rval;
+    }
+    static obscure(input, prefixLength = 2, suffixLength = 2) {
+        if (!input) {
+            return input;
+        }
+        const len = input.length;
+        let pl = prefixLength;
+        let sl = suffixLength;
+        while (len > 0 && len < pl + sl + 1) {
+            pl = Math.max(0, pl - 1);
+            sl = Math.max(0, sl - 1);
+        }
+        const rem = len - (pl + sl);
+        let rval = '';
+        rval += input.substring(0, pl);
+        for (let i = 0; i < rem; i++) {
+            rval += '*';
+        }
+        rval += input.substring(len - sl);
+        return rval;
+    }
+    static leadingZeros(inVal, size) {
+        const pad = '00000000000000000000000000000000000000000000000000';
+        let negative = false;
+        let sVal = String(inVal);
+        if (sVal.startsWith('-')) {
+            negative = true;
+            sVal = sVal.substring(1);
+        }
+        if (size > pad.length) {
+            throw new Error('Cannot format number that large');
+        }
+        let rval = (pad + sVal).slice(-1 * size);
+        if (negative) {
+            rval = '-' + rval;
+        }
+        return rval;
+    }
+    static trimToEmpty(input) {
+        const t = input ? StringRatchet.safeString(input) : '';
+        return t.trim();
+    }
+    static trimToNull(input) {
+        const x = StringRatchet.trimToEmpty(input);
+        return x.length > 0 ? x : null;
+    }
+    static trimAllStringPropertiesToNullInPlace(input) {
+        return StringRatchet.trimAllStringPropertiesInPlace(input, false);
+    }
+    static trimAllStringPropertiesToEmptyInPlace(input) {
+        return StringRatchet.trimAllStringPropertiesInPlace(input, true);
+    }
+    static trimAllStringPropertiesInPlace(input, toEmpty) {
+        const dealKeys = Object.keys(input);
+        dealKeys.forEach((key) => {
+            const val = input[key];
+            if (val != null && typeof val === 'string') {
+                input[key] = toEmpty ? StringRatchet.trimToEmpty(input[key]) : StringRatchet.trimToNull(input[key]);
+            }
+        });
+        return input;
+    }
+    static stripNonNumeric(input) {
+        let rval = input;
+        if (input != null && !StringRatchet.stringContainsOnlyNumbers(input)) {
+            rval = '';
+            for (let i = 0; i < input.length; i++) {
+                const c = input.charAt(i);
+                if (StringRatchet.stringContainsOnlyNumbers(c) || (i === 0 && c === '-')) {
+                    rval += c;
+                }
+            }
+        }
+        return rval;
+    }
+    static csvSafe(input) {
+        let rval = StringRatchet.trimToEmpty(StringRatchet.safeString(input));
+        rval.split('"').join('\\"');
+        if (rval.indexOf(',') !== -1 || rval.indexOf('"') !== -1 || rval.indexOf("'") !== -1) {
+            rval = '"' + rval + '"';
+        }
+        return rval;
+    }
+}
+exports.StringRatchet = StringRatchet;
+StringRatchet.RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];

package/dist/cjs/lang/time-zone-ratchet.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeZoneRatchet = void 0;
+const luxon_1 = require("luxon");
+class TimeZoneRatchet {
+    constructor(timezone) {
+        if (!timezone) {
+            throw 'Timezone cannot be null';
+        }
+        this.timezone = timezone;
+    }
+    currentHour() {
+        const rval = luxon_1.DateTime.local().setZone(this.timezone).hour;
+        return rval;
+    }
+    toEpochSeconds(dt) {
+        return Math.round(dt.toMillis() / 1000);
+    }
+    startOfTodayEpochSeconds() {
+        const startOfToday = this.toEpochSeconds(luxon_1.DateTime.local().setZone(this.timezone).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }));
+        return startOfToday;
+    }
+    startOfMatchingDayEpochSeconds(inputTS) {
+        const startOfToday = this.toEpochSeconds(luxon_1.DateTime.fromMillis(inputTS).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }));
+        return startOfToday;
+    }
+    startOfMatchingDayEpochMS(inputTS) {
+        return this.startOfMatchingDayEpochSeconds(inputTS) * 1000;
+    }
+    startOfCurrentHourEpochSeconds() {
+        const rval = this.toEpochSeconds(luxon_1.DateTime.local().setZone(this.timezone).set({ minute: 0, second: 0, millisecond: 0 }));
+        return rval;
+    }
+    startOfCurrentMinuteEpochSeconds() {
+        const rval = this.toEpochSeconds(luxon_1.DateTime.local().setZone(this.timezone).set({ second: 0, millisecond: 0 }));
+        return rval;
+    }
+    startOfCurrentSecondEpochSeconds() {
+        const rval = this.toEpochSeconds(luxon_1.DateTime.local().setZone(this.timezone).set({ millisecond: 0 }));
+        return rval;
+    }
+    startOfTodayEpochMS() {
+        const startOfToday = luxon_1.DateTime.local().setZone(this.timezone).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toMillis();
+        return startOfToday;
+    }
+    dailySlotCount(slotWidthMs) {
+        return Math.ceil(86400000 / slotWidthMs);
+    }
+    currentTimeSlotIdx(slotWidthMs) {
+        if (slotWidthMs < 1) {
+            throw new Error('Cannot process with slot less than one ms wide');
+        }
+        const startOfToday = this.startOfTodayEpochMS();
+        const now = new Date().getTime();
+        const delta = now - startOfToday;
+        const idx = Math.floor(delta / slotWidthMs);
+        return idx;
+    }
+    matchingTimeSlotIdx(timestamp, slotWidthMs) {
+        if (slotWidthMs < 1) {
+            throw new Error('Cannot process with slot less than one ms wide');
+        }
+        const startOfDay = this.startOfMatchingDayEpochMS(timestamp);
+        const delta = timestamp - startOfDay;
+        const idx = Math.floor(delta / slotWidthMs);
+        return idx;
+    }
+    startOfCurrentSlotEpochMS(slotWidthMs) {
+        const startOfToday = this.startOfTodayEpochMS();
+        const currentIdx = this.currentTimeSlotIdx(slotWidthMs);
+        return startOfToday + currentIdx * slotWidthMs;
+    }
+    startOfMatchingSlotEpochMS(timestamp, slotWidthMs) {
+        const startOfDay = this.startOfMatchingDayEpochMS(timestamp);
+        const currentIdx = this.matchingTimeSlotIdx(timestamp, slotWidthMs);
+        return startOfDay + currentIdx * slotWidthMs;
+    }
+}
+exports.TimeZoneRatchet = TimeZoneRatchet;
+TimeZoneRatchet.PACIFIC = new TimeZoneRatchet('America/Los_Angeles');

package/dist/cjs/lang/timeout-token.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutToken = void 0;
+const logger_1 = require("../logger/logger");
+const logger_level_name_1 = require("../logger/logger-level-name");
+class TimeoutToken {
+    constructor(title, timeoutMS) {
+        this.title = title;
+        this.timeoutMS = timeoutMS;
+        this.__timeoutTokenFlagField = true;
+    }
+    writeToLog(logLevel = logger_level_name_1.LoggerLevelName.warn) {
+        logger_1.Logger.logByLevel(logLevel, 'Timed out after %d ms waiting for results of %s', this.timeoutMS, this.title);
+    }
+    static isTimeoutToken(value) {
+        return !!value && !!value['__timeoutTokenFlagField'];
+    }
+}
+exports.TimeoutToken = TimeoutToken;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformRatchet = void 0;
+const logger_1 = require("../logger/logger");
+class TransformRatchet {
+    static transform(toTransform, rules = []) {
+        return TransformRatchet.transformGeneric(toTransform, rules, false, null);
+    }
+    static transformGeneric(toTransform, rules = [], isKey, context) {
+        let rval = null;
+        const type = typeof toTransform;
+        switch (type) {
+            case 'undefined':
+            case 'symbol':
+            case 'function':
+                rval = toTransform;
+                break;
+            case 'number':
+            case 'string':
+            case 'boolean':
+                rval = TransformRatchet.applyTransformToPrimitive(toTransform, rules, isKey, context);
+                break;
+            case 'object':
+                rval = TransformRatchet.applyTransformToObject(toTransform, rules, isKey, context);
+                break;
+            default:
+                throw new Error('Unrecognized type ' + type);
+        }
+        return rval;
+    }
+    static applyTransformToObject(toTransform, rules = [], isKey, context = null) {
+        logger_1.Logger.silly('Tranform: %j, %s, %j', toTransform, isKey, context);
+        let rval = null;
+        if (toTransform != null) {
+            if (Array.isArray(toTransform)) {
+                rval = [];
+                toTransform.forEach((val) => {
+                    const newVal = TransformRatchet.transformGeneric(val, rules, isKey, toTransform);
+                    if (newVal != null) {
+                        rval.push(newVal);
+                    }
+                });
+            }
+            else {
+                rval = {};
+                Object.keys(toTransform).forEach((k) => {
+                    const oldValue = toTransform[k];
+                    const newKey = TransformRatchet.applyTransformToPrimitive(k, rules, true, toTransform);
+                    if (newKey != null) {
+                        let newValue = TransformRatchet.transformGeneric(oldValue, rules, false, toTransform);
+                        newValue = TransformRatchet.applyTransformToPrimitive(newValue, rules, false, toTransform);
+                        if (newValue != null) {
+                            rval[newKey] = newValue;
+                        }
+                    }
+                });
+                rval = TransformRatchet.applyTransformToPrimitive(rval, rules, false, toTransform);
+            }
+        }
+        return rval;
+    }
+    static applyTransformToPrimitive(toTransform, rules = [], isKey, context) {
+        let rval = toTransform;
+        rules.forEach((r) => {
+            rval = rval == null ? null : r.transform(rval, isKey, context);
+        });
+        return rval;
+    }
+}
+exports.TransformRatchet = TransformRatchet;