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

package/{dist/types → lib}/2d/line-2d.d.ts

@@ -1,4 +1,4 @@
-import { Point2d } from './point-2d';
+import { Point2d } from './point-2d.js';
 export interface Line2d {
     p1: Point2d;
     p2: Point2d;

package/{dist/types → lib}/2d/poly-line-2d.d.ts

@@ -1,4 +1,4 @@
-import { Point2d } from './point-2d';
+import { Point2d } from './point-2d.js';
 export interface PolyLine2d {
     pts: Point2d[];
 }

package/{dist/types → lib}/2d/ratchet-2d.d.ts

@@ -1,7 +1,7 @@
-import { Point2d } from './point-2d';
-import { Plane2d } from './plane-2d';
-import { Line2d } from './line-2d';
-import { PolyLine2d } from './poly-line-2d';
+import { Point2d } from './point-2d.js';
+import { Plane2d } from './plane-2d.js';
+import { Line2d } from './line-2d.js';
+import { PolyLine2d } from './poly-line-2d.js';
 export declare class Ratchet2d {
     private constructor();
     static translateToOriginVector(points: Point2d[]): Point2d;

package/{dist/es → lib}/2d/ratchet-2d.js

@@ -1,4 +1,4 @@
-import { BooleanRatchet } from '../lang/boolean-ratchet';
+import { BooleanRatchet } from '../lang/boolean-ratchet.js';
 export class Ratchet2d {
     constructor() { }
     static translateToOriginVector(points) {

package/lib/2d/ratchet-2d.spec.js

@@ -0,0 +1,117 @@
+import { Ratchet2d } from './ratchet-2d.js';
+describe('#ratchet2d', function () {
+    it('should check for valid planes', function () {
+        expect(Ratchet2d.validPlane(null)).toEqual(false);
+        expect(Ratchet2d.validPlane({ width: null, height: null })).toEqual(false);
+        expect(Ratchet2d.validPlane({ width: 0, height: null })).toEqual(false);
+        expect(Ratchet2d.validPlane({ width: 0, height: 2 })).toEqual(false);
+        expect(Ratchet2d.validPlane({ width: 1, height: 7 })).toEqual(true);
+    });
+    it('should check for valid lines', function () {
+        expect(Ratchet2d.validLine(null)).toEqual(false);
+        expect(Ratchet2d.validLine({ p1: null, p2: null })).toEqual(false);
+        expect(Ratchet2d.validLine({ p1: { x: null, y: 0 }, p2: null })).toEqual(false);
+        expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: null } })).toEqual(false);
+        expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: 0 } })).toEqual(true);
+        expect(Ratchet2d.validLine({ p1: { x: 1, y: 0 }, p2: { x: 1, y: 0 } })).toEqual(false);
+        expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: 13 } })).toEqual(true);
+    });
+    it('should transform points from one plane to another (scale)', function () {
+        const plane1 = { height: 10, width: 10 };
+        const plane2 = { height: 100, width: 50 };
+        const p1 = { x: 5, y: 5 };
+        const out1 = Ratchet2d.transformPointToNewPlane(p1, plane1, plane2);
+        const out2 = Ratchet2d.transformPointToNewPlane(out1, plane2, plane1);
+        expect(out1.x).toEqual(25);
+        expect(out1.y).toEqual(50);
+        expect(out2.x).toEqual(p1.x);
+        expect(out2.y).toEqual(p1.y);
+    });
+    it('should transform points from one plane to another (mirror)', function () {
+        const plane1 = { height: 10, width: 10 };
+        const plane2 = { height: 10, width: 10, rightToLeft: true, topToBottom: true };
+        const p1 = { x: 2, y: 8 };
+        const out1 = Ratchet2d.transformPointToNewPlane(p1, plane1, plane2);
+        const out2 = Ratchet2d.transformPointToNewPlane(out1, plane2, plane1);
+        expect(out1.x).toEqual(7);
+        expect(out1.y).toEqual(1);
+        expect(out2.x).toEqual(p1.x);
+        expect(out2.y).toEqual(p1.y);
+    });
+    it('should check for containment', function () {
+        const plane = {
+            width: 100,
+            height: 100,
+        };
+        expect(Ratchet2d.planeContainsPoint({ x: -1, y: 10 }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoint({ x: 101, y: 10 }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoint({ x: 1, y: -10 }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoint({ x: 10, y: 101 }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoint({ x: 10, y: 100 }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoint({ x: 1, y: 10 }, plane)).toEqual(true);
+        expect(Ratchet2d.planeContainsPoint({ x: 10, y: 10 }, plane)).toEqual(true);
+        expect(Ratchet2d.planeContainsPoints([
+            { x: 10, y: 10 },
+            { x: 100, y: 10 },
+        ], plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsPoints([
+            { x: 10, y: 10 },
+            { x: 11, y: 10 },
+        ], plane)).toEqual(true);
+        expect(Ratchet2d.planeContainsLine({
+            p1: { x: 10, y: 10 },
+            p2: { x: 100, y: 10 },
+        }, plane)).toEqual(false);
+        expect(Ratchet2d.planeContainsLine({
+            p1: { x: 10, y: 10 },
+            p2: { x: 11, y: 10 },
+        }, plane)).toEqual(true);
+    });
+    it('should fit input to curve', function () {
+        const curve = [
+            { x: 0, y: 50 },
+            { x: 0.5, y: 50 },
+            { x: 0.8, y: 60 },
+            { x: 1, y: 70 },
+            { x: 1.2, y: 80 },
+            { x: 1.5, y: 90 },
+            { x: 1.6, y: 91 },
+            { x: 1.7, y: 92 },
+            { x: 1.8, y: 93 },
+            { x: 1.9, y: 94 },
+            { x: 2, y: 95 },
+            {
+                x: 3,
+                y: 98,
+            },
+            { x: 4, y: 99 },
+            { x: 5, y: 100 },
+        ];
+        expect(Ratchet2d.fitCurve(curve, -1)).toEqual(50);
+        expect(Ratchet2d.fitCurve(curve, 0)).toEqual(50);
+        expect(Ratchet2d.fitCurve(curve, 0.3)).toEqual(50);
+        expect(Ratchet2d.fitCurve(curve, 0.5)).toEqual(50);
+        expect(Ratchet2d.fitCurve(curve, 0.8)).toEqual(60);
+        expect(Ratchet2d.fitCurve(curve, 1)).toEqual(70);
+        expect(Ratchet2d.fitCurve(curve, 5)).toEqual(100);
+        expect(Ratchet2d.fitCurve(curve, 6)).toEqual(100);
+        expect(Ratchet2d.fitCurve(curve, 1.65)).toEqual(91.5);
+    });
+    it('rotate about origin', function () {
+        const points = [
+            { x: 1, y: 0 },
+            { x: 2, y: 1 },
+            { x: 3, y: 2 },
+            { x: 4, y: 3 },
+            { x: 4, y: 1 },
+            { x: 6, y: 1 },
+        ];
+        const r1 = Ratchet2d.rotateRightAboutOrigin90Degrees(points);
+        expect(r1.length).toEqual(6);
+        const r3 = Ratchet2d.rotateRightAboutOrigin90Degrees(points, 3);
+        const r2 = Ratchet2d.rotateRightAboutOrigin90Degrees(points, 4);
+        expect(r2.length).toEqual(6);
+        expect(r2[0].x).toEqual(points[0].x);
+        expect(r2[0].y).toEqual(points[0].y);
+    });
+});

package/{dist/types → lib}/build/ratchet-common-info.d.ts

@@ -1,4 +1,4 @@
-import { BuildInformation } from './build-information';
+import { BuildInformation } from './build-information.js';
 export declare class RatchetInfo {
     private constructor();
     static buildInformation(): BuildInformation;

package/{dist/types → lib}/histogram/histogram.d.ts

@@ -1,7 +1,4 @@
-import { HistogramEntry } from './histogram-entry';
-/**
- * Implements a simple histogram (for each object, how many times does it appear)
- */
+import { HistogramEntry } from './histogram-entry.js';
 export declare class Histogram<T> {
     private entries;
     update(val: T, addValue?: number): void;

package/{dist/es → lib}/histogram/histogram.js

@@ -1,7 +1,5 @@
 export class Histogram {
-    constructor() {
-        this.entries = [];
-    }
+    entries = [];
     update(val, addValue = 1) {
         if (val) {
             const entry = this.entries.find((e) => e.item === val);

package/lib/histogram/histogram.spec.js

@@ -0,0 +1,19 @@
+import { Histogram } from './histogram.js';
+describe('#histogram', function () {
+    it('should count the values correctly', function () {
+        const histogram = new Histogram();
+        histogram.update('a');
+        histogram.update('a');
+        histogram.update('b');
+        histogram.update('c');
+        expect(histogram.getTotalCount()).toEqual(4);
+        expect(histogram.countForValue('a')).toEqual(2);
+        expect(histogram.countForValue('b')).toEqual(1);
+        expect(histogram.countForValue('c')).toEqual(1);
+        expect(histogram.countForValue('d')).toEqual(0);
+        expect(histogram.percentForValue('a')).toEqual(0.5);
+        expect(histogram.percentForValue('b')).toEqual(0.25);
+        expect(histogram.percentForValue('c')).toEqual(0.25);
+        expect(histogram.percentForValue('d')).toEqual(0);
+    });
+});

package/lib/jwt/common-jwt-token.d.ts

@@ -0,0 +1,6 @@
+import { JwtTokenBase } from './jwt-token-base.js';
+export interface CommonJwtToken<T> extends JwtTokenBase {
+    user: T;
+    proxy: T;
+    roles: string[];
+}

package/{dist/types → lib}/jwt/jwt-ratchet-like.d.ts

@@ -1,9 +1,6 @@
-import { JwtTokenBase } from './jwt-token-base';
-import { LoggerLevelName } from '../logger/logger-level-name';
-import { ExpiredJwtHandling } from './expired-jwt-handling';
-/**
- * Classes implementing this interface have Functions to help with creating and decoding JWTs
- */
+import { JwtTokenBase } from './jwt-token-base.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { ExpiredJwtHandling } from './expired-jwt-handling.js';
 export interface JwtRatchetLike {
     get encryptionKeyPromise(): Promise<string | string[]>;
     get decryptKeysPromise(): Promise<string[]>;

package/{dist/types → lib}/jwt/jwt-ratchet.d.ts

@@ -1,16 +1,7 @@
-import { JwtTokenBase } from './jwt-token-base';
-import { LoggerLevelName } from '../logger/logger-level-name';
-import { ExpiredJwtHandling } from './expired-jwt-handling';
-import { JwtRatchetLike } from './jwt-ratchet-like';
-/**
- * Functions to help with creating and decoding JWTs
- *
- * JWTRatchet accepts promises for its inputs for the simple reason that best practice dictates that the keys
- * should never be in the code, which means it is likely somewhere else.  That MIGHT be somewhere synchronous
- * like an environmental variable, but it could very likely be someplace remote like a secure key store.  By
- * accepting promises here, we make it easy to do JwtRatchet construction in a place (like an IOT container)
- * that itself must be synchronous
- */
+import { JwtTokenBase } from './jwt-token-base.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { ExpiredJwtHandling } from './expired-jwt-handling.js';
+import { JwtRatchetLike } from './jwt-ratchet-like.js';
 export declare class JwtRatchet implements JwtRatchetLike {
     private _encryptionKeyPromise;
     private _decryptKeysPromise?;

package/{dist/es → lib}/jwt/jwt-ratchet.js

@@ -1,11 +1,17 @@
 import jwt from 'jsonwebtoken';
-import { RequireRatchet } from '../lang/require-ratchet';
-import { Logger } from '../logger/logger';
-import { StringRatchet } from '../lang/string-ratchet';
-import { DurationRatchet } from '../lang/duration-ratchet';
-import { LoggerLevelName } from '../logger/logger-level-name';
-import { ExpiredJwtHandling } from './expired-jwt-handling';
+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;
@@ -156,4 +162,3 @@ export class JwtRatchet {
         }
     }
 }
-JwtRatchet.EXPIRED_FLAG_NAME = '__jwtServiceExpiredFlag';

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

@@ -0,0 +1,49 @@
+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/{dist/types → lib}/jwt/jwt-token-base.d.ts

@@ -1,7 +1,3 @@
-/**
- * Defines the common fields expected in a JWT token according to the RFC
- * https://www.rfc-editor.org/rfc/rfc7519.html
- */
 export interface JwtTokenBase {
     iss?: string;
     sub?: string;

package/lib/lang/array-ratchet.d.ts

@@ -0,0 +1,14 @@
+export declare class ArrayRatchet {
+    static wrapElementsInArray(input: any[]): any[][];
+    static compareTwoArrays<T>(ar1: T[], ar2: T[], fn: ComparisonFunction<T>): MatchReport<T>;
+    static extractSubarrayFromSortedByNumberField<T>(input: T[], fieldDotPath: string, minInclusive: number, maxExclusive: number): T[];
+    static findSplit(input: any[], fieldDotPath: string, target: number): number;
+}
+export interface ComparisonFunction<T> {
+    (t1: T, t2: T): number;
+}
+export interface MatchReport<T> {
+    matching: T[];
+    setOneOnly: T[];
+    setTwoOnly: T[];
+}

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

@@ -1,5 +1,5 @@
-import { RequireRatchet } from './require-ratchet';
-import { MapRatchet } from './map-ratchet';
+import { RequireRatchet } from './require-ratchet.js';
+import { MapRatchet } from './map-ratchet.js';
 export class ArrayRatchet {
     static wrapElementsInArray(input) {
         return input.map((i) => [i]);

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

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

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
 export declare class Base64Ratchet {
     static safeObjectToBase64JSON(input: any): any;
     static safeBase64JSONParse(input: string): any;

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

@@ -1,4 +1,4 @@
-import { Logger } from '../logger/logger';
+import { Logger } from '../logger/logger.js';
 export class Base64Ratchet {
     static safeObjectToBase64JSON(input) {
         return !!input ? Base64Ratchet.generateBase64VersionOfString(JSON.stringify(input)) : null;

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

@@ -0,0 +1,28 @@
+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/{dist/es → lib}/lang/boolean-ratchet.js

@@ -1,4 +1,4 @@
-import { NumberRatchet } from './number-ratchet';
+import { NumberRatchet } from './number-ratchet.js';
 export class BooleanRatchet {
     static allTrue(vals, emptyArraysReturn = false) {
         let rval = null;

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

@@ -0,0 +1,81 @@
+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/{dist/types → lib}/lang/composite-last-success-provider.d.ts

@@ -1,5 +1,4 @@
-/** Classes implementing this interface return a timestamp of their last success **/
-import { LastSuccessProvider } from './last-success-provider';
+import { LastSuccessProvider } from './last-success-provider.js';
 export declare class CompositeLastSuccessProvider implements LastSuccessProvider {
     private sources;
     private mostRecent;

package/{dist/es → lib}/lang/composite-last-success-provider.js

@@ -1,4 +1,6 @@
 export class CompositeLastSuccessProvider {
+    sources;
+    mostRecent;
     constructor(src, mostRecentSrc = true) {
         if (!src || src.length == 0) {
             throw Error('Cannot create composite provider with null/empty sources');

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

@@ -0,0 +1,26 @@
+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/{dist/es → lib}/lang/date-ratchet.js

@@ -1,5 +1,10 @@
 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);
     }
@@ -22,8 +27,3 @@ export class DateRatchet {
         return rval;
     }
 }
-DateRatchet.COMMON_US_DATE_FORMAT = 'MM/dd/yyyy';
-DateRatchet.DEFAULT_DATE_FORMAT = 'yyyy-MM-dd';
-DateRatchet.FULL_DATE_FORMAT = 'yyyy-MM-dd_HH_mm_ss';
-DateRatchet.PACIFIC_TIME_ZONE = 'America/Los_Angeles';
-DateRatchet.UTC_TIME_ZONE = 'etc/UTC';

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

@@ -0,0 +1,21 @@
+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);
+    });
+});

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

@@ -1,5 +1,5 @@
 import { DateTime } from 'luxon';
-import { NumberRatchet } from './number-ratchet';
+import { NumberRatchet } from './number-ratchet.js';
 export class DurationRatchet {
     static formatMsDuration(ms, includeMS = false) {
         const rem_ms = Math.floor(ms % 1000);