@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/lang/string-ratchet.spec.js

@@ -1,158 +0,0 @@
-import { StringRatchet } from './string-ratchet.js';
-describe('#formatBytes', function () {
-    it('should format 0 bytes correctly', function () {
-        const result = StringRatchet.formatBytes(0);
-        expect(result).toEqual('0 Bytes');
-    });
-    it('should format less than a Kb correctly', function () {
-        const result = StringRatchet.formatBytes(123);
-        expect(result).toEqual('123 Bytes');
-    });
-    it('should format less than a Mb correctly', function () {
-        const result = StringRatchet.formatBytes(1024);
-        expect(result).toEqual('1 KB');
-    });
-    it('should format less than a Mb correctly with 3 decimals', function () {
-        const result = StringRatchet.formatBytes(1234, 3);
-        expect(result).toEqual('1.205 KB');
-    });
-});
-describe('#safeToString', function () {
-    it('should return "asdf"', function () {
-        const result = StringRatchet.safeString('asdf');
-        expect(result).toEqual('asdf');
-    });
-    it('should return "55"', function () {
-        const result = StringRatchet.safeString(55);
-        expect(result).toEqual('55');
-    });
-});
-describe('#obscure', function () {
-    it('should return "pa****rd"', function () {
-        const result = StringRatchet.obscure('password', 2, 2);
-        expect(result).toEqual('pa****rd');
-    });
-    it('should return null', function () {
-        const result = StringRatchet.obscure(null, 2, 2);
-        expect(result).toBeNull();
-    });
-    it('should return "p**s"', function () {
-        const result = StringRatchet.obscure('pass', 2, 2);
-        expect(result).toEqual('p**s');
-    });
-    it('should return "****"', function () {
-        const result = StringRatchet.obscure('pass', 0, 0);
-        expect(result).toEqual('****');
-    });
-    it('should return "p***"', function () {
-        const result = StringRatchet.obscure('pass', 1, 0);
-        expect(result).toEqual('p***');
-    });
-    it('should return "***s"', function () {
-        const result = StringRatchet.obscure('pass', 0, 1);
-        expect(result).toEqual('***s');
-    });
-});
-describe('#guid', function () {
-    it('should generate a guid"', function () {
-        const result = StringRatchet.createType4Guid();
-        expect(result).toBeTruthy();
-    });
-});
-describe('#randomHexString', function () {
-    it('should generate a random hex string"', function () {
-        const result = StringRatchet.createRandomHexString(12);
-        expect(result).toBeTruthy();
-        expect(result.length).toEqual(12);
-    });
-});
-describe('#leadingZeros', function () {
-    it('should generate string with leading zeros"', function () {
-        const result = StringRatchet.leadingZeros(25, 4);
-        expect(result).toEqual('0025');
-    });
-    it('should generate string with leading zeros and a negative sign"', function () {
-        const result = StringRatchet.leadingZeros(-8, 2);
-        expect(result).toEqual('-08');
-    });
-});
-describe('#stripNonNumeric', function () {
-    it('should return a string containing only numbers"', function () {
-        const result = StringRatchet.stripNonNumeric('702-555-1212');
-        expect(result).toEqual('7025551212');
-    });
-});
-describe('#stringContainsOnly', function () {
-    it('should check string contains only valid chars"', function () {
-        expect(StringRatchet.stringContainsOnly('test', 'tes')).toBeTruthy();
-        expect(StringRatchet.stringContainsOnly('test', 'teg')).toBeFalsy();
-        expect(StringRatchet.stringContainsOnlyAlphanumeric('test')).toBeTruthy();
-        expect(StringRatchet.stringContainsOnlyAlphanumeric('tes-')).toBeFalsy();
-        expect(StringRatchet.stringContainsOnlyHex('1a3')).toBeTruthy();
-        expect(StringRatchet.stringContainsOnlyHex('test')).toBeFalsy();
-    });
-});
-describe('#stringCsvSafe', function () {
-    it('should make values safe to place in a CSV"', function () {
-        expect(StringRatchet.csvSafe('test')).toEqual('test');
-        expect(StringRatchet.csvSafe('test,and 1')).toEqual('"test,and 1"');
-        expect(StringRatchet.csvSafe(1)).toEqual('1');
-        expect(StringRatchet.csvSafe("test'blah")).toEqual('"test\'blah"');
-    });
-});
-describe('#trimToEmpty', function () {
-    it('should return an empty string for null"', function () {
-        const result = StringRatchet.trimToEmpty(null);
-        expect(result).toEqual('');
-    });
-    it('should return an empty string for undefined"', function () {
-        const result = StringRatchet.trimToEmpty(undefined);
-        expect(result).toEqual('');
-    });
-    it('should return an empty string"', function () {
-        const result = StringRatchet.trimToEmpty('     ');
-        expect(result).toEqual('');
-    });
-    it('should return an abc"', function () {
-        const result = StringRatchet.trimToEmpty('abc   ');
-        expect(result).toEqual('abc');
-    });
-    it('should return string "5"', function () {
-        const result = StringRatchet.trimToEmpty(5);
-        expect(result).toEqual('5');
-    });
-});
-describe('#trimStringPropertiesInPlace', function () {
-    it('should trim properties to null"', function () {
-        const test = {
-            a: 'test   ',
-            b: 1,
-            c: '    test',
-            d: null,
-            e: '     ',
-        };
-        const nullResult = StringRatchet.trimAllStringPropertiesToNullInPlace(test);
-        expect(nullResult).not.toBeNull();
-        expect(nullResult['a']).toEqual('test');
-        expect(nullResult['b']).toEqual(1);
-        expect(nullResult['c']).toEqual('test');
-        expect(nullResult['d']).toEqual(null);
-        expect(nullResult['e']).toEqual(null);
-    });
-    it('should trim properties to empty"', function () {
-        const test = {
-            a: 'test   ',
-            b: 1,
-            c: '    test',
-            d: null,
-            e: '     ',
-        };
-        const emptyResult = StringRatchet.trimAllStringPropertiesToEmptyInPlace(test);
-        expect(emptyResult).not.toBeNull();
-        expect(emptyResult['a']).toEqual('test');
-        expect(emptyResult['b']).toEqual(1);
-        expect(emptyResult['c']).toEqual('test');
-        expect(emptyResult['d']).toEqual(null);
-        expect(emptyResult['e']).toEqual('');
-    });
-});

package/lib/lang/time-zone-ratchet.js

@@ -1,77 +0,0 @@
-import { DateTime } from 'luxon';
-export class TimeZoneRatchet {
-    static PACIFIC = new TimeZoneRatchet('America/Los_Angeles');
-    timezone;
-    constructor(timezone) {
-        if (!timezone) {
-            throw 'Timezone cannot be null';
-        }
-        this.timezone = timezone;
-    }
-    currentHour() {
-        const rval = DateTime.local().setZone(this.timezone).hour;
-        return rval;
-    }
-    toEpochSeconds(dt) {
-        return Math.round(dt.toMillis() / 1000);
-    }
-    startOfTodayEpochSeconds() {
-        const startOfToday = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }));
-        return startOfToday;
-    }
-    startOfMatchingDayEpochSeconds(inputTS) {
-        const startOfToday = this.toEpochSeconds(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(DateTime.local().setZone(this.timezone).set({ minute: 0, second: 0, millisecond: 0 }));
-        return rval;
-    }
-    startOfCurrentMinuteEpochSeconds() {
-        const rval = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ second: 0, millisecond: 0 }));
-        return rval;
-    }
-    startOfCurrentSecondEpochSeconds() {
-        const rval = this.toEpochSeconds(DateTime.local().setZone(this.timezone).set({ millisecond: 0 }));
-        return rval;
-    }
-    startOfTodayEpochMS() {
-        const startOfToday = 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;
-    }
-}

package/lib/lang/time-zone-ratchet.spec.js

@@ -1,40 +0,0 @@
-import { TimeZoneRatchet } from './time-zone-ratchet.js';
-const tz = TimeZoneRatchet.PACIFIC;
-describe('#currentHour', function () {
-    it('should return 0- 23', function () {
-        const result = tz.currentHour();
-        expect(result).toBeGreaterThanOrEqual(0);
-        expect(result).toBeLessThanOrEqual(23);
-    });
-});
-describe('#startOfTodayEpochSeconds', function () {
-    it('should never be more than now or more than 86400 seconds in the past', function () {
-        const now = Math.floor(new Date().getTime() / 1000);
-        const start = tz.startOfTodayEpochSeconds();
-        const result = now - start;
-        expect(result).toBeGreaterThanOrEqual(0);
-        expect(result).toBeLessThanOrEqual(86400);
-    });
-});
-describe('#dailySlotCount', function () {
-    it('should return 86400', function () {
-        const result = tz.dailySlotCount(1000);
-        expect(result).toEqual(86400);
-    });
-});
-describe('#currentTimeSlotIdx', function () {
-    xit('should return same as current hour', function () {
-        const curHour = tz.currentHour();
-        const hourSlot = 1000 * 60 * 60;
-        const curSlot = tz.currentTimeSlotIdx(hourSlot);
-        expect(curSlot).toEqual(curHour);
-    });
-});
-describe('#matchingTimeSlotIdx', function () {
-    xit('should return same as current hour', function () {
-        const curHour = tz.currentHour();
-        const hourSlot = 1000 * 60 * 60;
-        const matchSlot = tz.matchingTimeSlotIdx(new Date().getTime(), hourSlot);
-        expect(matchSlot).toEqual(curHour);
-    });
-});

package/lib/lang/timeout-token.js

@@ -1,17 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-export class TimeoutToken {
-    title;
-    timeoutMS;
-    __timeoutTokenFlagField = true;
-    constructor(title, timeoutMS) {
-        this.title = title;
-        this.timeoutMS = timeoutMS;
-    }
-    writeToLog(logLevel = LoggerLevelName.warn) {
-        Logger.logByLevel(logLevel, 'Timed out after %d ms waiting for results of %s', this.timeoutMS, this.title);
-    }
-    static isTimeoutToken(value) {
-        return !!value && !!value['__timeoutTokenFlagField'];
-    }
-}

package/lib/lang/timeout-token.spec.js

@@ -1,9 +0,0 @@
-import { TimeoutToken } from './timeout-token.js';
-describe('#timeoutToken', function () {
-    it('should return the correct value for isTimeoutToken', function () {
-        const tt = new TimeoutToken('title', 20000);
-        const ntt = { a: 'b' };
-        expect(TimeoutToken.isTimeoutToken(tt)).toBeTruthy();
-        expect(TimeoutToken.isTimeoutToken(ntt)).toBeFalsy();
-    });
-});

package/lib/lang/transform-ratchet.js

@@ -1,66 +0,0 @@
-import { Logger } from '../logger/logger.js';
-export 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.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;
-    }
-}

package/lib/lang/transform-ratchet.spec.js

@@ -1,118 +0,0 @@
-import { TransformRatchet } from './transform-ratchet.js';
-import { BuiltInTransforms } from '../transform/built-in-transforms.js';
-describe('#formatBytes', function () {
-    const srcData = {
-        key1: 'value1',
-        key2: 'value2',
-        dateKey1: '1995-02-01',
-        intKey1: 0,
-        intKey2: 1,
-        boolKey1: true,
-        boolKey2: false,
-        camelSnake: 'this is a camel case',
-        subKey: {
-            key1: 'subValue1',
-            key2: 'subValue2',
-            convertToNumberInner: '42',
-        },
-        convertToNumber: '1',
-        convertToNumberAlso: '20',
-    };
-    const srcUnderData = {
-        new_key_1: 'value1',
-        sub_key: {
-            new_key_2: 'value2',
-        },
-    };
-    it('should convert camel to snakecase', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.camelToSnakeCase())]);
-        expect(result['dateKey1']).toBeUndefined();
-        expect(result['intKey1']).toBeUndefined();
-        expect(result['intKey2']).toBeUndefined();
-        expect(result['boolKey1']).toBeUndefined();
-        expect(result['boolKey2']).toBeUndefined();
-        expect(result['subKey']).toBeUndefined();
-        expect(result['date_key1']).toBeTruthy();
-        expect(result['int_key1']).toEqual(0);
-        expect(result['int_key2']).toBeTruthy();
-        expect(result['bool_key1']).toBeTruthy();
-        expect(result['bool_key1']).toBeTruthy();
-        expect(result['sub_key']).toBeTruthy();
-    });
-    it('should duplicate key1 into key3', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.makeDuplicateField('key1', 'key3')]);
-        expect(result.key1).toEqual('value1');
-        expect(result.key3).toEqual('value1');
-    });
-    it('should create a new field named key3', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.addField('key3', 'value3')]);
-        expect(result.key1).toEqual('value1');
-        expect(result.key3).toEqual('value3');
-    });
-    it('should reformat the date in dateField1 to MM-dd-yyyy', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.reformatDateFields(['dateKey1'], 'yyyy-MM-dd', 'MM/dd/yyyy')]);
-        expect(result.dateKey1).toEqual('02/01/1995');
-    });
-    it('should convert numbers to booleans', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.numberToBool(['intKey1', 'intKey2'])]);
-        expect(result.key1).toEqual('value1');
-        expect(result.intKey1).toEqual(false);
-        expect(result.intKey2).toEqual(true);
-    });
-    it('should convert booleans to number', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.boolToNumber(['boolKey1', 'boolKey2'])]);
-        expect(result.key1).toEqual('value1');
-        expect(result.boolKey1).toEqual(1);
-        expect(result.boolKey2).toEqual(0);
-    });
-    it('should concatenate key1 and key2 into key3', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.concatenateToNewField('key3', ['key1', 'key2'])]);
-        expect(result.key1).toBeUndefined();
-        expect(result.key2).toBeUndefined();
-        expect(result.key3).toEqual('value1value2');
-        expect(result.subKey.key1).toBeUndefined();
-        expect(result.subKey.key2).toBeUndefined();
-        expect(result.subKey.key3).toEqual('subValue1subValue2');
-    });
-    it('should strip a key correctly', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.stripStringTransform('key1')]);
-        expect(result.key1).toBeUndefined();
-    });
-    it('should rename a key correctly', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.stringReplaceTransform('key1', 'newKey1')]);
-        expect(result.key1).toBeUndefined();
-        expect(result.newKey1).toEqual('value1');
-        expect(result.subKey.key1).toBeUndefined();
-        expect(result.subKey.newKey1).toEqual('subValue1');
-    });
-    it('should retain only key1 and key2', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.retainAll(['key1', 'key2']))]);
-        expect(result.key1).toBeTruthy();
-        expect(result.key2).toBeTruthy();
-        expect(result.intKey1).toBeUndefined();
-        expect(result.boolKey1).toBeUndefined();
-        expect(result.subKey).toBeUndefined();
-    });
-    it('should remove only key1 and key2', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.keysOnly(BuiltInTransforms.removeAll(['key1', 'key2']))]);
-        expect(result.key1).toBeUndefined();
-        expect(result.key2).toBeUndefined();
-        expect(result.intKey1).toEqual(0);
-        expect(result.boolKey1).toBeTruthy();
-        expect(result.subKey).toBeTruthy();
-    });
-    it('should convert snake to camelcase', function () {
-        const result = TransformRatchet.transform(srcUnderData, [BuiltInTransforms.keysOnly(BuiltInTransforms.snakeToCamelCase())]);
-        expect(result['new_key_1']).toBeUndefined();
-        expect(result['sub_key']).toBeUndefined();
-        expect(result.newKey1).toBeTruthy();
-        expect(result.subKey).toBeTruthy();
-        expect(result.subKey.newKey2).toBeTruthy();
-    });
-    it('should convert strings to numbers', function () {
-        const result = TransformRatchet.transform(srcData, [BuiltInTransforms.valuesOnly(BuiltInTransforms.stringToNumber())]);
-        expect(result['convertToNumber']).toEqual(1);
-        expect(result['convertToNumberAlso']).toEqual(20);
-        expect(result['subKey']['convertToNumberInner']).toEqual(42);
-    });
-});

package/lib/logger/classic-single-line-log-message-formatter.js

@@ -1,13 +0,0 @@
-import util from 'util';
-export class ClassicSingleLineLogMessageFormatter {
-    formatMessage(msg, meta) {
-        let tmp = null;
-        if (msg) {
-            tmp = '';
-            tmp += meta.options.trace ? meta.options.trace + ' ' : '';
-            tmp += '[' + msg.lvl + '] ';
-            tmp += util.format(msg.messageSource, ...msg.subsVars);
-        }
-        return tmp;
-    }
-}

package/lib/logger/log-message-builder.js

@@ -1,48 +0,0 @@
-export class LogMessageBuilder {
-    wrapped;
-    constructor(lvl, messageSource) {
-        if (!lvl) {
-            throw Error('Cannot set level to null/undefined');
-        }
-        this.wrapped = { lvl: lvl, timestamp: Date.now(), messageSource: messageSource };
-    }
-    clone() {
-        const rval = new LogMessageBuilder(this.wrapped.lvl, this.wrapped.messageSource);
-        rval.wrapped = Object.assign({}, this.wrapped);
-        return rval;
-    }
-    level(lvl) {
-        if (!lvl) {
-            throw Error('Cannot set level to null/undefined');
-        }
-        this.wrapped.lvl = lvl;
-        return this;
-    }
-    timestamp(val) {
-        if (!val) {
-            throw Error('Cannot set timestamp to null/undefined');
-        }
-        this.wrapped.timestamp = val;
-        return this;
-    }
-    messageSource(val) {
-        this.wrapped.messageSource = val;
-        return this;
-    }
-    subVars(val) {
-        this.wrapped.subsVars = val || [];
-        return this;
-    }
-    params(val) {
-        this.wrapped.params = val || {};
-        return this;
-    }
-    p(name, value) {
-        this.wrapped.params = this.wrapped.params || {};
-        this.wrapped.params[name] = value;
-        return this;
-    }
-    toMessage() {
-        return Object.assign({}, this.wrapped);
-    }
-}

package/lib/logger/log-message-format-type.js

@@ -1,6 +0,0 @@
-export var LogMessageFormatType;
-(function (LogMessageFormatType) {
-    LogMessageFormatType["ClassicSingleLine"] = "ClassicSingleLine";
-    LogMessageFormatType["StructuredJson"] = "StructuredJson";
-    LogMessageFormatType["None"] = "None";
-})(LogMessageFormatType || (LogMessageFormatType = {}));

package/lib/logger/log-message-formatter.js

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

package/lib/logger/log-message-processor.js

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

package/lib/logger/log-message.js

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

package/lib/logger/log-snapshot.js

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