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

package/lib/jwt/jwt-ratchet.js

@@ -1,164 +0,0 @@
-import jwt from 'jsonwebtoken';
-import { RequireRatchet } from '../lang/require-ratchet.js';
-import { Logger } from '../logger/logger.js';
-import { StringRatchet } from '../lang/string-ratchet.js';
-import { DurationRatchet } from '../lang/duration-ratchet.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-import { ExpiredJwtHandling } from './expired-jwt-handling.js';
-export class JwtRatchet {
-    _encryptionKeyPromise;
-    _decryptKeysPromise;
-    _jtiGenerator;
-    _decryptOnlyKeyUseLogLevel;
-    _parseFailureLogLevel;
-    static EXPIRED_FLAG_NAME = '__jwtServiceExpiredFlag';
-    constructor(_encryptionKeyPromise, _decryptKeysPromise, _jtiGenerator = StringRatchet.createType4Guid, _decryptOnlyKeyUseLogLevel = LoggerLevelName.info, _parseFailureLogLevel = LoggerLevelName.debug) {
-        this._encryptionKeyPromise = _encryptionKeyPromise;
-        this._decryptKeysPromise = _decryptKeysPromise;
-        this._jtiGenerator = _jtiGenerator;
-        this._decryptOnlyKeyUseLogLevel = _decryptOnlyKeyUseLogLevel;
-        this._parseFailureLogLevel = _parseFailureLogLevel;
-        RequireRatchet.notNullOrUndefined(_encryptionKeyPromise, 'encryptionKeyPromise');
-    }
-    get encryptionKeyPromise() {
-        return this._encryptionKeyPromise;
-    }
-    get decryptKeysPromise() {
-        return this._decryptKeysPromise;
-    }
-    get jtiGenerator() {
-        return this._jtiGenerator;
-    }
-    get decryptOnlyKeyUseLogLevel() {
-        return this._decryptOnlyKeyUseLogLevel;
-    }
-    get parseFailureLogLevel() {
-        return this._parseFailureLogLevel;
-    }
-    static hasExpiredFlag(ob) {
-        return ob && ob[JwtRatchet.EXPIRED_FLAG_NAME] === true;
-    }
-    static async invalidSafeDecode(payloadString, decryptKey, logLevel = LoggerLevelName.silly) {
-        let rval = null;
-        try {
-            rval = jwt.verify(payloadString, decryptKey, { ignoreExpiration: true });
-        }
-        catch (err) {
-            Logger.logByLevel(logLevel, 'Caught %s - ignoring', err);
-        }
-        return rval;
-    }
-    static async secondsRemainingUntilExpiration(payloadString) {
-        let rval = null;
-        if (StringRatchet.trimToNull(payloadString)) {
-            const output = await JwtRatchet.decodeTokenNoVerify(payloadString);
-            const nowSecond = Math.floor(Date.now() / 1000);
-            if (output.exp) {
-                const expSeconds = output.exp > nowSecond * 100 ? Math.floor(output.exp / 1000) : output.exp;
-                rval = Math.max(0, expSeconds - nowSecond);
-            }
-        }
-        return rval;
-    }
-    static async msRemainingUntilExpiration(payloadString) {
-        const secs = await JwtRatchet.secondsRemainingUntilExpiration(payloadString);
-        let rval = null;
-        if (secs !== null && secs !== undefined) {
-            rval = secs * 1000;
-        }
-        return rval;
-    }
-    async decodeToken(payloadString, expiredHandling = ExpiredJwtHandling.RETURN_NULL) {
-        const encKeys = await this.encryptionKeyArray();
-        let decKeys = Object.assign([], encKeys);
-        if (this.decryptKeysPromise) {
-            decKeys = decKeys.concat(await this.decryptKeysPromise);
-        }
-        const keysTried = [];
-        let payload = null;
-        for (let i = 0; i < decKeys.length && !payload; i++) {
-            keysTried.push(StringRatchet.obscure(decKeys[i], 1, 1));
-            const logLevel = i === decKeys.length - 1 && this.parseFailureLogLevel ? this.parseFailureLogLevel : LoggerLevelName.silly;
-            payload = await JwtRatchet.invalidSafeDecode(payloadString, decKeys[i], logLevel);
-            if (payload && i >= encKeys.length) {
-                Logger.logByLevel(this.decryptOnlyKeyUseLogLevel, 'Used old key to decode token : %s', StringRatchet.obscure(decKeys[i], 2));
-            }
-        }
-        if (payload) {
-            const nowSeconds = Math.floor(Date.now() / 1000);
-            const expSeconds = payload?.exp && payload.exp > nowSeconds * 100 ? Math.floor(payload.exp / 1000) : payload?.exp;
-            const nbfSeconds = payload?.nbf && payload.nbf > nowSeconds * 100 ? Math.floor(payload.nbf / 1000) : payload?.nbf;
-            if ((expSeconds && nowSeconds >= expSeconds) || (nbfSeconds && nowSeconds <= nbfSeconds)) {
-                const age = nowSeconds - expSeconds;
-                Logger.debug('JWT token expired or before NBF : on %d, %s ago', payload.exp, DurationRatchet.formatMsDuration(age * 1000));
-                switch (expiredHandling) {
-                    case ExpiredJwtHandling.THROW_EXCEPTION:
-                        throw new Error('JWT Token was expired');
-                    case ExpiredJwtHandling.ADD_FLAG:
-                        payload[JwtRatchet.EXPIRED_FLAG_NAME] = true;
-                        break;
-                    default:
-                        payload = null;
-                        break;
-                }
-            }
-        }
-        else {
-            Logger.warn('Unable to parse a payload (Tried %j) from : %s', keysTried, payloadString);
-        }
-        return payload;
-    }
-    async encryptionKeyArray() {
-        const encKey = await this.encryptionKeyPromise;
-        const rval = Array.isArray(encKey) ? encKey : [encKey];
-        if (rval.length < 1) {
-            throw new Error('Cannot create JwtRatchet with empty encryption key set');
-        }
-        return rval;
-    }
-    async selectRandomEncryptionKey() {
-        const encKey = await this.encryptionKeyArray();
-        const rval = encKey[Math.floor(Math.random() * encKey.length)];
-        return rval;
-    }
-    async createTokenString(payload, expirationSeconds, overrideEncryptionKey) {
-        const encKey = StringRatchet.trimToNull(overrideEncryptionKey)
-            ? StringRatchet.trimToNull(overrideEncryptionKey)
-            : await this.selectRandomEncryptionKey();
-        RequireRatchet.notNullOrUndefined(payload, 'payload');
-        payload.jti = this.jtiGenerator ? this.jtiGenerator() : null;
-        if (expirationSeconds) {
-            const nowSeconds = Math.floor(Date.now() / 1000);
-            const expires = nowSeconds + expirationSeconds;
-            Logger.debug('Forcing expiration to %d', expires);
-            payload.exp = expires;
-        }
-        const token = jwt.sign(payload, encKey);
-        return token;
-    }
-    async refreshJWTString(tokenString, allowExpired, expirationSeconds) {
-        const handling = allowExpired ? ExpiredJwtHandling.ADD_FLAG : ExpiredJwtHandling.THROW_EXCEPTION;
-        const payload = await this.decodeToken(tokenString, handling);
-        const originalDurationSeconds = payload.exp && payload.iat ? payload.exp - payload.iat : null;
-        const newExpirationSeconds = expirationSeconds || originalDurationSeconds;
-        JwtRatchet.removeJwtFields(payload);
-        JwtRatchet.removeExpiredFlag(payload);
-        const token = await this.createTokenString(payload, newExpirationSeconds);
-        return token;
-    }
-    static decodeTokenNoVerify(token) {
-        return jwt.decode(token);
-    }
-    static removeJwtFields(ob) {
-        if (ob) {
-            ['iss', 'sub', 'aud', 'exp', 'nbf', 'iat', 'jti'].forEach((k) => {
-                delete ob[k];
-            });
-        }
-    }
-    static removeExpiredFlag(ob) {
-        if (ob) {
-            delete ob[JwtRatchet.EXPIRED_FLAG_NAME];
-        }
-    }
-}

package/lib/jwt/jwt-ratchet.spec.js

@@ -1,49 +0,0 @@
-import { JwtRatchet } from './jwt-ratchet.js';
-import { ExpiredJwtHandling } from './expired-jwt-handling.js';
-describe('#jwtRatchet', function () {
-    it('should test expiration flag for a token with millisecond expiration', async () => {
-        const jwt = new JwtRatchet(Promise.resolve('test1234'), Promise.resolve([]));
-        const token1 = await jwt.createTokenString({ test: 1, exp: Date.now() - 100 }, null);
-        const output = await jwt.decodeToken(token1, ExpiredJwtHandling.ADD_FLAG);
-        expect(output).not.toBeNull();
-        expect(JwtRatchet.hasExpiredFlag(output)).toBeTruthy();
-    });
-    it('should test expiration calculation for a token', async () => {
-        const jwt = new JwtRatchet(Promise.resolve('test1234'), Promise.resolve([]));
-        const token1 = await jwt.createTokenString({ test: 1 }, 120);
-        const output = await JwtRatchet.secondsRemainingUntilExpiration(token1);
-        expect(output).not.toBeNull();
-        expect(output).toBeLessThan(121);
-        expect(output).toBeGreaterThan(115);
-    });
-    it('should test round-trip for a token', async () => {
-        const jwt = new JwtRatchet(Promise.resolve('test1234'), Promise.resolve([]));
-        const token1 = await jwt.createTokenString({ test: 1 }, 120);
-        const output = await jwt.decodeToken(token1);
-        expect(output).not.toBeNull();
-        expect(output['test']).toEqual(1);
-    });
-    it('should test round-trip for a token with array enc keys', async () => {
-        const jwt = new JwtRatchet(Promise.resolve(['test1234', 'test5678']), Promise.resolve([]));
-        const token1 = await jwt.createTokenString({ test: 1 }, 120);
-        const token2 = await jwt.createTokenString({ test: 1 }, 120);
-        const token3 = await jwt.createTokenString({ test: 1 }, 120);
-        const output1 = await jwt.decodeToken(token1);
-        const output2 = await jwt.decodeToken(token2);
-        const output3 = await jwt.decodeToken(token3);
-        expect(output1).not.toBeNull();
-        expect(output1['test']).toEqual(1);
-        expect(output2).not.toBeNull();
-        expect(output2['test']).toEqual(1);
-        expect(output3).not.toBeNull();
-        expect(output3['test']).toEqual(1);
-    });
-    it('should decode with a decode key', async () => {
-        const jwtOld = new JwtRatchet(Promise.resolve('oldKey'), Promise.resolve([]));
-        const jwtNew = new JwtRatchet(Promise.resolve('newKey'), Promise.resolve(['oldKey']));
-        const token1 = await jwtOld.createTokenString({ test: 1 }, 120);
-        const output = await jwtNew.decodeToken(token1);
-        expect(output).not.toBeNull();
-        expect(output['test']).toEqual(1);
-    });
-});

package/lib/jwt/jwt-token-base.js

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

package/lib/lang/array-ratchet.js

@@ -1,83 +0,0 @@
-import { RequireRatchet } from './require-ratchet.js';
-import { MapRatchet } from './map-ratchet.js';
-export 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 = 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) {
-        RequireRatchet.notNullOrUndefined(input);
-        RequireRatchet.notNullOrUndefined(fieldDotPath);
-        RequireRatchet.notNullOrUndefined(target);
-        if (input.length === 0 || 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 = MapRatchet.findValueDotPath(input[curIdx], fieldDotPath);
-            if (min === max || min === max - 1) {
-                rval = min;
-            }
-            else if (curVal <= target) {
-                min = curIdx;
-            }
-            else {
-                max = curIdx;
-            }
-        }
-        return rval;
-    }
-}

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

@@ -1,68 +0,0 @@
-import { ArrayRatchet } from './array-ratchet.js';
-const sortedArr = [
-    {
-        n: 'test1',
-        v: 1,
-    },
-    {
-        n: 'test1',
-        v: 2,
-    },
-    {
-        n: 'test1',
-        v: 4,
-    },
-    {
-        n: 'test1',
-        v: 4,
-    },
-    {
-        n: 'test1',
-        v: 7,
-    },
-    {
-        n: 'test1',
-        v: 12,
-    },
-    {
-        n: 'test1',
-        v: 25,
-    },
-    {
-        n: 'test1',
-        v: 30,
-    },
-];
-describe('#extractSubarrayFromSortedByNumberField', function () {
-    it('should extract the subarray', function () {
-        const subArr1 = ArrayRatchet.extractSubarrayFromSortedByNumberField(sortedArr, 'v', 5, 14);
-        expect(subArr1.length).toEqual(2);
-        const subArr2 = ArrayRatchet.extractSubarrayFromSortedByNumberField(sortedArr, 'v', null, 4);
-        expect(subArr2.length).toEqual(4);
-        const subArr3 = ArrayRatchet.extractSubarrayFromSortedByNumberField(sortedArr, 'v', 7, null);
-        expect(subArr3.length).toEqual(4);
-    });
-});
-describe('#compareTwoArrays', function () {
-    it('should create a match report', function () {
-        const arr1 = ['a', 'b', 'c'];
-        const arr2 = ['a', 'e', 'i', 'o', 'u'];
-        const report = ArrayRatchet.compareTwoArrays(arr1, arr2, (a, b) => a.localeCompare(b));
-        expect(report).toBeTruthy();
-        expect(report.setOneOnly.length).toEqual(2);
-        expect(report.setTwoOnly.length).toEqual(4);
-        expect(report.matching.length).toEqual(1);
-    });
-});
-describe('#findSplit', function () {
-    it('should find the split', function () {
-        const split10 = ArrayRatchet.findSplit(sortedArr, 'v', 10);
-        const split4 = ArrayRatchet.findSplit(sortedArr, 'v', 4);
-        const split0 = ArrayRatchet.findSplit(sortedArr, 'v', 0);
-        const split32 = ArrayRatchet.findSplit(sortedArr, 'v', 32);
-        expect(split10).toEqual(4);
-        expect(split4).toEqual(3);
-        expect(split0).toEqual(null);
-        expect(split32).toEqual(7);
-    });
-});

package/lib/lang/base64-ratchet.js

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

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

@@ -1,28 +0,0 @@
-import { Base64Ratchet } from './base64-ratchet.js';
-describe('#base64', function () {
-    it('should parse a buffer from base64', function () {
-        const result = Base64Ratchet.base64StringToBuffer('dGVzdHVzZXI6dGVzdHBhc3M=');
-        expect(result).toBeTruthy();
-        expect(result.length).toEqual(17);
-    });
-    it('should parse a string from base64', function () {
-        const result = Base64Ratchet.base64StringToString('dGVzdHVzZXI6dGVzdHBhc3M=');
-        expect(result).toBeTruthy();
-        expect(result.length).toEqual(17);
-    });
-    it('should round-trip a string', function () {
-        const testString = 'teststring';
-        const enc = Base64Ratchet.generateBase64VersionOfString(testString);
-        const result = Base64Ratchet.base64StringToString(enc);
-        expect(result).toBeTruthy();
-        expect(result).toEqual(testString);
-    });
-    it('should round-trip an object', function () {
-        const testOb = { a: 'teststring', b: 27 };
-        const enc = Base64Ratchet.safeObjectToBase64JSON(testOb);
-        const result = Base64Ratchet.safeBase64JSONParse(enc);
-        expect(result).toBeTruthy();
-        expect(result.a).toEqual(testOb.a);
-        expect(result.b).toEqual(testOb.b);
-    });
-});

package/lib/lang/boolean-ratchet.js

@@ -1,45 +0,0 @@
-import { NumberRatchet } from './number-ratchet.js';
-export 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 NumberRatchet.safeNumber(val) !== 0;
-    }
-    static boolToInt(val) {
-        return BooleanRatchet.parseBool(val) ? 1 : 0;
-    }
-}

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

@@ -1,81 +0,0 @@
-import { BooleanRatchet } from './boolean-ratchet.js';
-import { NumberRatchet } from './number-ratchet.js';
-describe('#parseBool', function () {
-    it('should check all true', function () {
-        expect(BooleanRatchet.allTrue(null)).toEqual(false);
-        expect(BooleanRatchet.allTrue([])).toEqual(false);
-        expect(BooleanRatchet.allTrue([], true)).toEqual(true);
-        expect(BooleanRatchet.allTrue([true])).toEqual(true);
-        expect(BooleanRatchet.allTrue([true, true])).toEqual(true);
-        expect(BooleanRatchet.allTrue([true, false, true])).toEqual(false);
-        expect(BooleanRatchet.allTrue([false])).toEqual(false);
-        expect(BooleanRatchet.allTrue([false, false])).toEqual(false);
-    });
-    it('should check any true', function () {
-        expect(BooleanRatchet.anyTrue(null)).toEqual(false);
-        expect(BooleanRatchet.anyTrue([])).toEqual(false);
-        expect(BooleanRatchet.anyTrue([], true)).toEqual(true);
-        expect(BooleanRatchet.anyTrue([true])).toEqual(true);
-        expect(BooleanRatchet.anyTrue([true, true])).toEqual(true);
-        expect(BooleanRatchet.anyTrue([true, false, true])).toEqual(true);
-        expect(BooleanRatchet.anyTrue([false])).toEqual(false);
-        expect(BooleanRatchet.anyTrue([false, false])).toEqual(false);
-    });
-    it('should xxx', function () {
-        const val = 'false';
-        const r1 = BooleanRatchet.parseBool(val);
-        const r2 = BooleanRatchet.intToBool(val);
-        const result = BooleanRatchet.parseBool(val) || BooleanRatchet.intToBool(NumberRatchet.safeNumber(val));
-        expect(result).toEqual(false);
-    });
-    it('should parse the string true as true', function () {
-        const result = BooleanRatchet.parseBool('true');
-        expect(result).toEqual(true);
-    });
-    it('should parse the string TRUE as true', function () {
-        const result = BooleanRatchet.parseBool('TRUE');
-        expect(result).toEqual(true);
-    });
-    it('should parse the boolean true as true', function () {
-        const result = BooleanRatchet.parseBool(true);
-        expect(result).toEqual(true);
-    });
-    it('should parse the empty string as false', function () {
-        const result = BooleanRatchet.parseBool('');
-        expect(result).toEqual(false);
-    });
-    it('should parse null as false', function () {
-        const result = BooleanRatchet.parseBool(null);
-        expect(result).toEqual(false);
-    });
-    it('should parse "asdf" as false', function () {
-        const result = BooleanRatchet.parseBool('asdf');
-        expect(result).toEqual(false);
-    });
-});
-describe('#intToBool', function () {
-    it('should parse null as false', function () {
-        const result = BooleanRatchet.intToBool(null);
-        expect(result).toEqual(false);
-    });
-    it('should parse 0 as false', function () {
-        const result = BooleanRatchet.intToBool(0);
-        expect(result).toEqual(false);
-    });
-    it('should parse "0" as false', function () {
-        const result = BooleanRatchet.intToBool('0');
-        expect(result).toEqual(false);
-    });
-    it('should parse 1 as true', function () {
-        const result = BooleanRatchet.intToBool(1);
-        expect(result).toEqual(true);
-    });
-    it('should parse "1" as true', function () {
-        const result = BooleanRatchet.intToBool('1');
-        expect(result).toEqual(true);
-    });
-    it('should parse "2" as true', function () {
-        const result = BooleanRatchet.intToBool('2');
-        expect(result).toEqual(true);
-    });
-});

package/lib/lang/composite-last-success-provider.js

@@ -1,26 +0,0 @@
-export class CompositeLastSuccessProvider {
-    sources;
-    mostRecent;
-    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;
-    }
-}

package/lib/lang/composite-last-success-provider.spec.js

@@ -1,26 +0,0 @@
-import { CompositeLastSuccessProvider } from './composite-last-success-provider.js';
-describe('#lastSuccess', function () {
-    const last5 = {
-        lastSuccess() {
-            return 5;
-        },
-    };
-    const last4 = {
-        lastSuccess() {
-            return 4;
-        },
-    };
-    const lastNull = {
-        lastSuccess() {
-            return null;
-        },
-    };
-    it('should return 4 as last (min)', function () {
-        const result = new CompositeLastSuccessProvider([last5, last4, lastNull], false).lastSuccess();
-        expect(result).toEqual(4);
-    });
-    it('should return 5 as last (max)', function () {
-        const result = new CompositeLastSuccessProvider([last5, last4, lastNull], true).lastSuccess();
-        expect(result).toEqual(5);
-    });
-});

package/lib/lang/date-ratchet.js

@@ -1,29 +0,0 @@
-import { DateTime } from 'luxon';
-export class DateRatchet {
-    static COMMON_US_DATE_FORMAT = 'MM/dd/yyyy';
-    static DEFAULT_DATE_FORMAT = 'yyyy-MM-dd';
-    static FULL_DATE_FORMAT = 'yyyy-MM-dd_HH_mm_ss';
-    static PACIFIC_TIME_ZONE = 'America/Los_Angeles';
-    static UTC_TIME_ZONE = 'etc/UTC';
-    static formatFullDate(input) {
-        return DateTime.fromJSDate(input).toFormat(DateRatchet.FULL_DATE_FORMAT);
-    }
-    static formatDefaultDateOnly(input) {
-        return DateTime.fromJSDate(input).toFormat(DateRatchet.DEFAULT_DATE_FORMAT);
-    }
-    static parseDefaultDate(input) {
-        const rval = 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 = DateTime.fromFormat(input, templ).toJSDate();
-        }
-        return rval;
-    }
-}

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

@@ -1,21 +0,0 @@
-import { DateRatchet } from './date-ratchet.js';
-describe('#dateRatchet', function () {
-    it('should parse my common date format', function () {
-        const dt = DateRatchet.parseDefaultDate('1976-07-04');
-        expect(dt.getFullYear()).toEqual(1976);
-        expect(dt.getMonth()).toEqual(6);
-        expect(dt.getDate()).toEqual(4);
-    });
-    it('should parse us with slashes', function () {
-        const dt = DateRatchet.parseCommonUsDate('07/04/1976');
-        expect(dt.getFullYear()).toEqual(1976);
-        expect(dt.getMonth()).toEqual(6);
-        expect(dt.getDate()).toEqual(4);
-    });
-    it('should parse us with dashes', function () {
-        const dt = DateRatchet.parseCommonUsDate('07-04-1976');
-        expect(dt.getFullYear()).toEqual(1976);
-        expect(dt.getMonth()).toEqual(6);
-        expect(dt.getDate()).toEqual(4);
-    });
-});