@bitblit/ratchet-common 4.0.99-alpha → 4.0.102-alpha

package/dist/{es/lang → lang}/promise-ratchet.js

@@ -1,8 +1,8 @@
-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';
+import { Logger } from '../logger/logger.js';
+import { ArrayRatchet } from './array-ratchet.js';
+import { TimeoutToken } from './timeout-token.js';
+import { StopWatch } from './stop-watch.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export class PromiseRatchet {
     static resolveOnEvent(evtSrc, okEvtNames, errEvtNames = [], rval = null) {
         if (!evtSrc || !okEvtNames || okEvtNames.length === 0 || !evtSrc['on']) {

package/dist/lang/promise-ratchet.spec.d.ts

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

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

@@ -0,0 +1,74 @@
+import { PromiseRatchet } from './promise-ratchet.js';
+import { Logger } from '../logger/logger.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+const fnFalse = (ignored) => {
+    return false;
+};
+const fnOn3 = (t) => {
+    Logger.info('t=%d', t);
+    return t == 3;
+};
+const waitAndPrint = async (t1, t2) => {
+    Logger.info('Running: %s', t2);
+    await PromiseRatchet.wait(t1 * 2);
+    return t1 * 2;
+};
+describe('#promiseRatchet', function () {
+    it('should timeout eventually', async () => {
+        try {
+            Logger.setLevel(LoggerLevelName.silly);
+            const result = await PromiseRatchet.waitFor(fnFalse, true, 100, 2);
+            Logger.info('Got : %s', result);
+            expect(result).toEqual(false);
+        }
+        catch (err) {
+            Logger.warn('Error: %s', err, err);
+        }
+    });
+    it('should succeed on 3rd try', async () => {
+        const promise = PromiseRatchet.waitFor(fnOn3, true, 100, 4);
+        const result = await promise;
+        expect(result).toEqual(true);
+    });
+    it('should run 10 elements, 2 at a time', async () => {
+        Logger.setLevel(LoggerLevelName.debug);
+        const elements = [
+            [100, 'Test1'],
+            [200, 'Test2'],
+            [300, 'Test3'],
+            [400, 'Test4'],
+            [500, 'Test5'],
+            [600, 'Test6'],
+            [700, 'Test7'],
+            [800, 'Test8'],
+            [900, 'Test9'],
+            [1000, 'Test10'],
+        ];
+        const results = await PromiseRatchet.runBoundedParallel(waitAndPrint, elements, this, 2);
+        Logger.info('Final results %j', results);
+        expect(results).toBeTruthy();
+        expect(results.length).toEqual(10);
+    }, 30000);
+    it('should run 10 waits, 2 at a time', async () => {
+        Logger.setLevel(LoggerLevelName.debug);
+        const elements = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000];
+        const results = await PromiseRatchet.runBoundedParallelSingleParam(PromiseRatchet.wait, elements, this, 2);
+        Logger.info('Final results %j', results);
+        expect(results).toBeTruthy();
+        expect(results.length).toEqual(10);
+    });
+    xit('should run an async function as a for/each', async () => {
+        Logger.setLevel(LoggerLevelName.debug);
+        const elements = [1001, 1002, 2000];
+        const pfn = async (v) => {
+            Logger.info('Waiting %s', v);
+            await PromiseRatchet.wait(v);
+            Logger.info('Finished %s', v);
+        };
+        Logger.info('Serial test');
+        await PromiseRatchet.asyncForEachSerial(elements, pfn);
+        Logger.info('Parallel test');
+        await PromiseRatchet.asyncForEachParallel(elements, pfn);
+        Logger.info('Done');
+    });
+});

package/dist/{es/lang → lang}/require-ratchet.js

@@ -1,4 +1,4 @@
-import { ErrorRatchet } from './error-ratchet';
+import { ErrorRatchet } from './error-ratchet.js';
 export class RequireRatchet {
     static isNullOrUndefined(ob) {
         return ob === null || ob === undefined;

package/dist/lang/require-ratchet.spec.d.ts

@@ -0,0 +1,3 @@
+export declare class ConstructorTester {
+    constructor(testVal1: string, testVal2: string);
+}

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

@@ -0,0 +1,80 @@
+import { RequireRatchet } from './require-ratchet.js';
+import { fail } from 'assert';
+import { Logger } from '../logger/logger.js';
+describe('#standardCases', function () {
+    it('should throw exception on null value', function () {
+        try {
+            RequireRatchet.notNullOrUndefined(null, 'test1');
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+        try {
+            RequireRatchet.notNullOrUndefined(undefined, 'test2');
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+    });
+    it('should throw exception on whitespace value', function () {
+        try {
+            RequireRatchet.notNullUndefinedOrOnlyWhitespaceString('', 'test1');
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+        try {
+            RequireRatchet.notNullUndefinedOrOnlyWhitespaceString('    ', 'test2');
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+    });
+});
+describe('#noNullOrUndefinedValuesInArray', function () {
+    it('should throw exception on null value', function () {
+        const arr = [1, null, 'a'];
+        try {
+            RequireRatchet.noNullOrUndefinedValuesInArray(arr);
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+    });
+    it('throw exception on bad length', function () {
+        const arr = [1, 2, 'a'];
+        try {
+            RequireRatchet.noNullOrUndefinedValuesInArray(arr, 4);
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+    });
+    it('should not throw exception on good values', function () {
+        const arr = [1, 2, 'a'];
+        RequireRatchet.noNullOrUndefinedValuesInArray(arr, 3);
+    });
+    it('should not throw exception on good constructor values', function () {
+        const test = new ConstructorTester('a', 'b');
+    });
+    it('throw exception on null constructor param', function () {
+        try {
+            const test = new ConstructorTester('a', null);
+            fail('Should have thrown exception');
+        }
+        catch (err) {
+            Logger.debug('Correctly threw exception : %s', err);
+        }
+    });
+});
+export class ConstructorTester {
+    constructor(testVal1, testVal2) {
+        Logger.info('Args : %j', this.constructor);
+    }
+}

package/dist/{types/lang → lang}/stop-watch.d.ts

@@ -1,4 +1,4 @@
-import { LoggerLevelName } from '../logger/logger-level-name';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export declare class StopWatch {
     private label;
     private starts;

package/dist/{es/lang → lang}/stop-watch.js

@@ -1,14 +1,15 @@
-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';
+import { DurationRatchet } from './duration-ratchet.js';
+import { StringRatchet } from './string-ratchet.js';
+import { RequireRatchet } from './require-ratchet.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { Logger } from '../logger/logger.js';
 export class StopWatch {
+    label;
+    starts = new Map();
+    ends = new Map();
+    createTime = Date.now();
     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');

package/dist/{es/lang → lang}/string-ratchet.js

@@ -1,5 +1,6 @@
-import { RequireRatchet } from './require-ratchet';
+import { RequireRatchet } from './require-ratchet.js';
 export class StringRatchet {
+    static RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];
     static stringToUint8Array(val) {
         return val ? new TextEncoder().encode(val) : null;
     }
@@ -188,4 +189,3 @@ export class StringRatchet {
         return rval;
     }
 }
-StringRatchet.RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];

package/dist/lang/string-ratchet.spec.d.ts

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

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

@@ -0,0 +1,158 @@
+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/dist/lang/time-zone-ratchet.d.ts

@@ -0,0 +1,19 @@
+export declare class TimeZoneRatchet {
+    static PACIFIC: TimeZoneRatchet;
+    private timezone;
+    constructor(timezone: string);
+    currentHour(): number;
+    private toEpochSeconds;
+    startOfTodayEpochSeconds(): number;
+    startOfMatchingDayEpochSeconds(inputTS: number): number;
+    startOfMatchingDayEpochMS(inputTS: number): number;
+    startOfCurrentHourEpochSeconds(): number;
+    startOfCurrentMinuteEpochSeconds(): number;
+    startOfCurrentSecondEpochSeconds(): number;
+    startOfTodayEpochMS(): number;
+    dailySlotCount(slotWidthMs: number): number;
+    currentTimeSlotIdx(slotWidthMs: number): number;
+    matchingTimeSlotIdx(timestamp: number, slotWidthMs: number): number;
+    startOfCurrentSlotEpochMS(slotWidthMs: number): number;
+    startOfMatchingSlotEpochMS(timestamp: number, slotWidthMs: number): number;
+}

package/dist/{es/lang → lang}/time-zone-ratchet.js

@@ -1,5 +1,7 @@
 import { DateTime } from 'luxon';
 export class TimeZoneRatchet {
+    static PACIFIC = new TimeZoneRatchet('America/Los_Angeles');
+    timezone;
     constructor(timezone) {
         if (!timezone) {
             throw 'Timezone cannot be null';
@@ -73,4 +75,3 @@ export class TimeZoneRatchet {
         return startOfDay + currentIdx * slotWidthMs;
     }
 }
-TimeZoneRatchet.PACIFIC = new TimeZoneRatchet('America/Los_Angeles');

package/dist/lang/time-zone-ratchet.spec.d.ts

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

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

@@ -0,0 +1,40 @@
+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/dist/{types/lang → lang}/timeout-token.d.ts

@@ -1,4 +1,4 @@
-import { LoggerLevelName } from '../logger/logger-level-name';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export declare class TimeoutToken {
     private title;
     private timeoutMS;

package/dist/{es/lang → lang}/timeout-token.js

@@ -1,10 +1,12 @@
-import { Logger } from '../logger/logger';
-import { LoggerLevelName } from '../logger/logger-level-name';
+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;
-        this.__timeoutTokenFlagField = true;
     }
     writeToLog(logLevel = LoggerLevelName.warn) {
         Logger.logByLevel(logLevel, 'Timed out after %d ms waiting for results of %s', this.timeoutMS, this.title);

package/dist/lang/timeout-token.spec.d.ts

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

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

@@ -0,0 +1,9 @@
+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/dist/{types/lang → lang}/transform-ratchet.d.ts

@@ -1,4 +1,4 @@
-import { TransformRule } from '../transform/transform-rule';
+import { TransformRule } from '../transform/transform-rule.js';
 export declare class TransformRatchet {
     static transform(toTransform: any, rules?: TransformRule[]): any;
     private static transformGeneric;

package/dist/{es/lang → lang}/transform-ratchet.js

@@ -1,4 +1,4 @@
-import { Logger } from '../logger/logger';
+import { Logger } from '../logger/logger.js';
 export class TransformRatchet {
     static transform(toTransform, rules = []) {
         return TransformRatchet.transformGeneric(toTransform, rules, false, null);

package/dist/lang/transform-ratchet.spec.d.ts

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

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

@@ -0,0 +1,118 @@
+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/dist/logger/classic-single-line-log-message-formatter.d.ts

@@ -0,0 +1,6 @@
+import { LogMessage } from './log-message.js';
+import { LogMessageFormatter } from './log-message-formatter.js';
+import { LoggerMeta } from './logger-meta.js';
+export declare class ClassicSingleLineLogMessageFormatter implements LogMessageFormatter {
+    formatMessage(msg: LogMessage, meta: LoggerMeta): string;
+}

package/dist/{types/logger → logger}/log-message-builder.d.ts

@@ -1,5 +1,5 @@
-import { LoggerLevelName } from './logger-level-name';
-import { LogMessage } from './log-message';
+import { LoggerLevelName } from './logger-level-name.js';
+import { LogMessage } from './log-message.js';
 export declare class LogMessageBuilder {
     private wrapped;
     constructor(lvl: LoggerLevelName, messageSource?: string);