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

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

@@ -0,0 +1,39 @@
+import { DurationRatchet } from './duration-ratchet.js';
+import { DateTime } from 'luxon';
+describe('#formatMsDuration', function () {
+    it('should format less than one second', function () {
+        const result = DurationRatchet.formatMsDuration(409, true);
+        expect(result).toEqual('00h00m00.409s');
+    });
+    it('should format more than one day', function () {
+        const result = DurationRatchet.formatMsDuration(1000 * 60 * 60 * 123, true);
+        expect(result).toEqual('5d03h00m00.000s');
+    });
+});
+describe('#colonFormatMsDuration', function () {
+    it('should format less than one second', function () {
+        const result = DurationRatchet.colonFormatMsDuration(409, true);
+        expect(result).toEqual('00:00:00.409');
+    });
+    it('should format more than ten hours', function () {
+        const result = DurationRatchet.colonFormatMsDuration(1000 * 60 * 60 * 11, false);
+        expect(result).toEqual('11:00:00');
+    });
+    it('should format more than one hundred hours', function () {
+        const result = DurationRatchet.colonFormatMsDuration(1000 * 60 * 60 * 123, false);
+        expect(result).toEqual('123:00:00');
+    });
+    it('should format 15 seconds', function () {
+        const result = DurationRatchet.colonFormatMsDuration(15000, false);
+        expect(result).toEqual('00:00:15');
+    });
+});
+describe('#createSteps', function () {
+    it('should create steps', function () {
+        const tt = DateTime.fromFormat('2019-01-01', 'yyyy-MM-dd');
+        const startEpochMS = DateTime.fromFormat('2019-01-01', 'yyyy-MM-dd').toJSDate().getTime();
+        const endEpochMS = DateTime.fromFormat('2019-01-05', 'yyyy-MM-dd').toJSDate().getTime();
+        const steps = DurationRatchet.createSteps(startEpochMS, endEpochMS, 'etc/GMT', 'yyyy-MM-dd', { days: 1 });
+        expect(steps.length).toEqual(4);
+    });
+});

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

@@ -0,0 +1,5 @@
+export declare class EnumRatchet {
+    static listEnumKeys(enumeration: any): string[];
+    static keyToEnum<T>(enumeration: any, val: string, caseSensitive?: boolean): T;
+    static parseCsvToEnumArray<T>(enumeration: any, input: string): T[];
+}

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

@@ -1,5 +1,5 @@
 import { $enum } from 'ts-enum-util';
-import { StringRatchet } from './string-ratchet';
+import { StringRatchet } from './string-ratchet.js';
 export class EnumRatchet {
     static listEnumKeys(enumeration) {
         const rval = $enum(enumeration).getValues();

package/lib/lang/enum-ratchet.spec.d.ts

@@ -0,0 +1,5 @@
+export declare enum TestEnum {
+    A = "a",
+    B = "b",
+    C = "c"
+}

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

@@ -0,0 +1,31 @@
+import { EnumRatchet } from './enum-ratchet.js';
+describe('#enumRatchet', function () {
+    it('should list keys', async () => {
+        const keys = EnumRatchet.listEnumKeys(TestEnum);
+        expect(keys).toBeTruthy();
+        expect(keys.length).toBeGreaterThan(1);
+    });
+    it('should find key case insensitive', async () => {
+        const t1 = EnumRatchet.keyToEnum(TestEnum, 'a');
+        const t2 = EnumRatchet.keyToEnum(TestEnum, 'b');
+        const t3 = EnumRatchet.keyToEnum(TestEnum, 'A', true);
+        const t4 = EnumRatchet.keyToEnum(TestEnum, 'A');
+        const fixed = TestEnum.A;
+        expect(t1).toBeTruthy();
+        expect(t2).toBeTruthy();
+        expect(t3).toBeNull();
+        expect(t4).toEqual(fixed);
+        expect(t4 === fixed).toBeTruthy();
+    });
+    it('should parse a csv of enums', async () => {
+        const vals = EnumRatchet.parseCsvToEnumArray(TestEnum, 'a, b');
+        expect(vals).toBeTruthy();
+        expect(vals.length).toEqual(2);
+    });
+});
+export var TestEnum;
+(function (TestEnum) {
+    TestEnum["A"] = "a";
+    TestEnum["B"] = "b";
+    TestEnum["C"] = "c";
+})(TestEnum || (TestEnum = {}));

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

@@ -1,4 +1,4 @@
-import { Logger } from '../logger/logger';
+import { Logger } from '../logger/logger.js';
 import util from 'util';
 export class ErrorRatchet {
     static safeStringifyErr(err, log = true) {

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

@@ -0,0 +1,20 @@
+import { ErrorRatchet } from './error-ratchet.js';
+describe('#errorRatchet', function () {
+    it('should cast to error', async () => {
+        const e1 = new Error('test1');
+        const e2 = 'test2';
+        const e1p = ErrorRatchet.asErr(e1);
+        const e2p = ErrorRatchet.asErr(e2);
+        const en = ErrorRatchet.asErr(null);
+        expect(en).toBeNull();
+        expect(e1p).toEqual(e1);
+        expect(e2p).not.toEqual(e2);
+        expect(e2p instanceof Error).toBeTruthy();
+    });
+    it('should correctly stringify', async () => {
+        const flag = 'test1';
+        const e1 = new Error(flag);
+        const out = ErrorRatchet.safeStringifyErr(e1);
+        expect(out).toEqual(flag);
+    });
+});

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

@@ -0,0 +1,4 @@
+export declare class EsmRatchet {
+    static fetchDirName(): string;
+    static fetchFileName(): string;
+}

package/lib/lang/esm-ratchet.js

@@ -0,0 +1,11 @@
+import url from 'url';
+export class EsmRatchet {
+    static fetchDirName() {
+        const rval = url.fileURLToPath(new URL('.', import.meta.url));
+        return rval;
+    }
+    static fetchFileName() {
+        const rval = url.fileURLToPath(import.meta.url);
+        return rval;
+    }
+}

package/{dist/types → lib}/lang/expiring-object.d.ts

@@ -1,4 +1,4 @@
-import { LoggerLevelName } from '../logger/logger-level-name';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export declare class ExpiringObject<T> {
     private _config;
     private _cacheObject;

package/{dist/es → lib}/lang/expiring-object.js

@@ -1,7 +1,11 @@
-import { Logger } from '../logger/logger';
-import { ErrorRatchet } from './error-ratchet';
-import { LoggerLevelName } from '../logger/logger-level-name';
+import { Logger } from '../logger/logger.js';
+import { ErrorRatchet } from './error-ratchet.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
 export class ExpiringObject {
+    _config;
+    _cacheObject;
+    _lastUpdatedEpochMS;
+    _timeRemainingMS;
     constructor(inputConfig) {
         this._config = Object.assign({}, this.defaultConfig(), inputConfig || {});
         if (this._config.overrideTimeRemainingMS && this._config.timeToLiveMS) {
@@ -21,7 +25,7 @@ export class ExpiringObject {
             initialValue: null,
             logLevel: LoggerLevelName.debug,
             overrideTimeRemainingMS: null,
-            timeToLiveMS: 1000 * 60,
+            timeToLiveMS: 1_000 * 60,
         };
         return rval;
     }
@@ -60,4 +64,9 @@ export class ExpiringObject {
     }
 }
 export class ExpiringObjectConfig {
+    timeToLiveMS;
+    generator;
+    initialValue;
+    logLevel;
+    overrideTimeRemainingMS;
 }

package/lib/lang/expiring-object.spec.js

@@ -0,0 +1,51 @@
+import { ExpiringObject } from './expiring-object.js';
+import { PromiseRatchet } from './promise-ratchet.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+describe('#expiringObject', function () {
+    it('should default the object', async () => {
+        const expObject = new ExpiringObject({
+            initialValue: 7,
+            timeToLiveMS: 50_000,
+            logLevel: LoggerLevelName.info,
+        });
+        const val = await expObject.fetch();
+        expect(val).toEqual(7);
+    });
+    it('should expire the object', async () => {
+        const expObject = new ExpiringObject({
+            initialValue: 7,
+            timeToLiveMS: 100,
+            logLevel: LoggerLevelName.info,
+        });
+        const val = await expObject.fetch();
+        expect(val).toEqual(7);
+        await PromiseRatchet.wait(101);
+        const val2 = await expObject.fetch();
+        expect(val2).toBeNull();
+    });
+    it('should regen the object', async () => {
+        const expObject = new ExpiringObject({
+            initialValue: 7,
+            timeToLiveMS: 100,
+            generator: async () => 8,
+            logLevel: LoggerLevelName.info,
+        });
+        const val = await expObject.fetch();
+        expect(val).toEqual(7);
+        await PromiseRatchet.wait(101);
+        const val2 = await expObject.fetch();
+        expect(val2).toEqual(8);
+    });
+    it('should return time remaining', async () => {
+        const expObject = new ExpiringObject({
+            initialValue: 7,
+            timeToLiveMS: 10_000,
+            logLevel: LoggerLevelName.info,
+        });
+        const val = await expObject.fetch();
+        expect(val).toEqual(7);
+        const rem = await expObject.fetchCacheObjectTimeRemainingMS();
+        expect(rem).toBeGreaterThan(0);
+        expect(rem).toBeLessThanOrEqual(10_000);
+    });
+});

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

@@ -1,7 +1,7 @@
-import { RequireRatchet } from './require-ratchet';
-import { NumberRatchet } from './number-ratchet';
-import { ErrorRatchet } from './error-ratchet';
-import { Logger } from '../logger/logger';
+import { RequireRatchet } from './require-ratchet.js';
+import { NumberRatchet } from './number-ratchet.js';
+import { ErrorRatchet } from './error-ratchet.js';
+import { Logger } from '../logger/logger.js';
 export class GeolocationRatchet {
     constructor() { }
     static distanceBetweenLocations(lat1, lon1, lat2, lon2, unit = 'M') {

package/lib/lang/geolocation-ratchet.spec.d.ts

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

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

@@ -0,0 +1,74 @@
+import { GeolocationRatchet } from './geolocation-ratchet.js';
+import fs from 'fs';
+import { NumberRatchet } from './number-ratchet.js';
+import path from 'path';
+import { EsmRatchet } from './esm-ratchet.js';
+describe('#geolocationRatchet', function () {
+    it('should canonicalize', function () {
+        expect(GeolocationRatchet.combineBounds([])).toBeNull();
+        expect(GeolocationRatchet.combineBounds(null)).toBeNull();
+    });
+    it('should canonicalize', function () {
+        const bounds = {
+            origin: {
+                lat: 4,
+                lng: 3,
+            },
+            extent: {
+                lat: 2,
+                lng: 5,
+            },
+        };
+        const result = GeolocationRatchet.canonicalizeBounds(bounds);
+        expect(result.origin.lat).toEqual(2);
+        expect(result.origin.lng).toEqual(3);
+        expect(result.extent.lat).toEqual(4);
+        expect(result.extent.lng).toEqual(5);
+    });
+    it('should calc point in bounds', function () {
+        const input = fs
+            .readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/sample_geo_locations.csv'))
+            .toString();
+        const locations = input
+            .split('\n')
+            .map((line) => {
+            const vals = line.split(',');
+            if (!!vals && vals.length === 2) {
+                return {
+                    lat: NumberRatchet.safeNumber(vals[0]),
+                    lng: NumberRatchet.safeNumber(vals[1]),
+                };
+            }
+            else {
+                return null;
+            }
+        })
+            .filter((s) => !!s);
+        const bounds = locations.map((l) => GeolocationRatchet.locationToBounds(l, 10));
+        const mapping = GeolocationRatchet.buildRatchetLocationBoundsMap(bounds);
+        const testPoint1 = locations[100];
+        const testPoint2 = { lng: 5, lat: 5 };
+        const testPoint3 = {
+            lat: 40.7566,
+            lng: -73.9887,
+        };
+        const testPoint4 = {
+            lat: 33.74616,
+            lng: -84.3708,
+        };
+        const testPoint5 = {
+            lat: 37.790336,
+            lng: -122.405399,
+        };
+        const pt1In = GeolocationRatchet.pointInAnyBound(testPoint1, bounds);
+        const pt2In = GeolocationRatchet.pointInAnyBound(testPoint2, bounds);
+        const pt3In = GeolocationRatchet.pointInAnyBound(testPoint3, bounds);
+        const pt4In = GeolocationRatchet.pointInAnyBound(testPoint4, bounds);
+        const pt5In = GeolocationRatchet.pointInRatchetLocationBoundsMap(testPoint5, mapping);
+        expect(pt1In).toBeTruthy();
+        expect(pt2In).toBeFalsy();
+        expect(pt3In).toBeTruthy();
+        expect(pt4In).toBeTruthy();
+        expect(pt5In).toBeTruthy();
+    });
+});

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

@@ -1,6 +1,6 @@
-import { ErrorRatchet } from './error-ratchet';
-import { RequireRatchet } from './require-ratchet';
-import { Logger } from '../logger/logger';
+import { ErrorRatchet } from './error-ratchet.js';
+import { RequireRatchet } from './require-ratchet.js';
+import { Logger } from '../logger/logger.js';
 export class GlobalRatchet {
     constructor() { }
     static fetchGlobalRecord(returnNullOnNone) {

package/lib/lang/global-ratchet.spec.d.ts

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

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

@@ -0,0 +1,14 @@
+import { GlobalRatchet } from './global-ratchet.js';
+import { StringRatchet } from './string-ratchet.js';
+describe('#globalRatchet', function () {
+    it('fetch and set global variables', async () => {
+        const tester = StringRatchet.createType4Guid();
+        const tester2 = StringRatchet.createType4Guid();
+        process.env['GLOBALTEST'] = tester;
+        const value = GlobalRatchet.fetchGlobalVar('GLOBALTEST');
+        expect(value).toEqual(tester);
+        GlobalRatchet.setGlobalVar('GLOBALTEST', tester2);
+        const value2 = GlobalRatchet.fetchGlobalVar('GLOBALTEST');
+        expect(value2).toEqual(tester2);
+    });
+});

package/{dist/es → lib}/lang/key-value.js

@@ -1,2 +1,4 @@
 export class KeyValue {
+    key;
+    value;
 }

package/lib/lang/last-success-provider.d.ts

@@ -0,0 +1,3 @@
+export interface LastSuccessProvider {
+    lastSuccess(): number;
+}

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

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

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

@@ -1,4 +1,4 @@
-import { KeyValue } from './key-value';
+import { KeyValue } from './key-value.js';
 export declare class MapRatchet {
     static expandNestedKeys<T>(src: any): T;
     static mapByUniqueProperty<T, R>(input: T[], propName: string): Map<R, T>;

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

@@ -1,6 +1,6 @@
-import { Logger } from '../logger/logger';
-import { ErrorRatchet } from './error-ratchet';
-import { set } from 'lodash';
+import { Logger } from '../logger/logger.js';
+import { ErrorRatchet } from './error-ratchet.js';
+import { set } from 'lodash-es';
 export class MapRatchet {
     static expandNestedKeys(src) {
         const rval = {};

package/lib/lang/map-ratchet.spec.d.ts

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

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

@@ -0,0 +1,90 @@
+import { MapRatchet } from './map-ratchet.js';
+describe('#toKeyValueList', function () {
+    it('should expand a maps nested keys', function () {
+        const test = { 'a.b': 'c', 'c.d[0].e': 2 };
+        const out = MapRatchet.expandNestedKeys(test);
+        expect(out).toBeTruthy();
+        expect(out.a).toBeTruthy();
+        expect(out.a.b).toBeTruthy();
+        expect(out.a.b).toEqual('c');
+        expect(out.c).toBeTruthy();
+        expect(out.c.d).toBeTruthy();
+        expect(out.c.d.length).toEqual(1);
+        expect(out.c.d[0].e).toBeTruthy();
+        expect(out.c.d[0].e).toEqual(2);
+    });
+    it('should convert a map to a key-value list and back', function () {
+        const test = { key1: 'value1', key2: 'value2' };
+        const kvl = MapRatchet.toKeyValueList(test);
+        expect(kvl.length).toEqual(2);
+        const back = MapRatchet.fromKeyValueList(kvl);
+        expect(back['key1']).toEqual('value1');
+        expect(back['key2']).toEqual('value2');
+    });
+    it('should remove null and empty strings but not 0', function () {
+        const test = {
+            key1: '',
+            key2: null,
+            key3: 0,
+            key4: 'fine',
+            key5: {
+                key6: null,
+                key7: 'also_fine',
+            },
+        };
+        const clean = MapRatchet.cleanup(test);
+        expect(Object.keys(clean).length).toEqual(3);
+        expect(Object.keys(clean).indexOf('key1')).toEqual(-1);
+        expect(Object.keys(clean).indexOf('key2')).toEqual(-1);
+        expect(Object.keys(clean).indexOf('key3')).toBeGreaterThan(-1);
+        expect(Object.keys(clean).indexOf('key4')).toBeGreaterThan(-1);
+        expect(Object.keys(clean).indexOf('key5')).toBeGreaterThan(-1);
+        expect(clean['key5']['key7']).toEqual('also_fine');
+    });
+    it('should extract values ignoring case', function () {
+        const test = {
+            'this-Test': 'a',
+            test22: 'b',
+        };
+        expect(MapRatchet.extractValueFromMapIgnoreCase(test, 'THIS-TEST')).toEqual('a');
+        expect(MapRatchet.extractValueFromMapIgnoreCase(test, 'tEst22')).toEqual('b');
+    });
+    it('should group values', function () {
+        const test = [
+            {
+                id: 1,
+                type: 'a',
+            },
+            {
+                id: 2,
+                type: 'a',
+            },
+            {
+                id: 3,
+                type: 'b',
+            },
+        ];
+        const grouped = MapRatchet.groupByProperty(test, 'type');
+        expect(grouped).toBeTruthy();
+        const aGroup = grouped.get('a');
+        expect(aGroup).toBeTruthy();
+        expect(aGroup.length).toEqual(2);
+        expect(grouped.has('b')).toBeTruthy();
+        expect(grouped.has('c')).toBeFalsy();
+    });
+    it('should fetch a value with a case-insensitive key', function () {
+        const testOb = {
+            test1: 'a',
+            Test2: 'b',
+            test3: 'c',
+            Test3: 'd',
+        };
+        expect(MapRatchet.caseInsensitiveAccess(null, null)).toBeNull();
+        expect(MapRatchet.caseInsensitiveAccess({}, null)).toBeNull();
+        expect(MapRatchet.caseInsensitiveAccess(null, 'a')).toBeNull();
+        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test1')).toEqual('a');
+        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test2')).toEqual('b');
+        expect(MapRatchet.caseInsensitiveAccess(testOb, 'TEST2')).toEqual('b');
+        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test3')).toEqual('c');
+    });
+});

package/lib/lang/no.spec.d.ts

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

package/lib/lang/no.spec.js

@@ -0,0 +1,7 @@
+import { PromiseRatchet } from './promise-ratchet.js';
+import { No } from './no.js';
+describe('#no', function () {
+    it('should do nothing', () => {
+        PromiseRatchet.wait(100).then(No.op);
+    });
+});

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

@@ -1,6 +1,7 @@
-import { Logger } from '../logger/logger';
-import { RequireRatchet } from './require-ratchet';
+import { Logger } from '../logger/logger.js';
+import { RequireRatchet } from './require-ratchet.js';
 export class NumberRatchet {
+    static MAX_LEADING_ZEROS_FORMAT_LENGTH = 1000;
     static toFixedDecimalNumber(input, placesAfterPoint) {
         const v = NumberRatchet.safeNumber(input);
         return v === null || v === undefined ? v : NumberRatchet.safeNumber(v.toFixed(placesAfterPoint));
@@ -152,4 +153,3 @@ export class NumberRatchet {
         return rval;
     }
 }
-NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH = 1000;

package/lib/lang/number-ratchet.spec.d.ts

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

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

@@ -0,0 +1,118 @@
+import { NumberRatchet } from './number-ratchet.js';
+import fs from 'fs';
+import path from 'path';
+import { EsmRatchet } from './esm-ratchet.js';
+describe('#toFixedDecimalNumber', function () {
+    it('should convert "5.1234 to 5.12', function () {
+        expect(NumberRatchet.toFixedDecimalNumber(5.1234, 2)).toEqual(5.12);
+        expect(NumberRatchet.toFixedDecimalNumber('5.1234', 2)).toEqual(5.12);
+    });
+    it('should convert "5.5678 to 5.57', function () {
+        expect(NumberRatchet.toFixedDecimalNumber(5.5678, 2)).toEqual(5.57);
+        expect(NumberRatchet.toFixedDecimalNumber('5.5678', 2)).toEqual(5.57);
+    });
+});
+describe('#leadingZeros', function () {
+    it('should convert "5" to 05', function () {
+        const result = NumberRatchet.leadingZeros('5', 2);
+        expect(result).toEqual('05');
+    });
+    it('should leave 166 alone', function () {
+        const result = NumberRatchet.leadingZeros('166', 2);
+        expect(result).toEqual('166');
+    });
+});
+describe('#safeToNumber', function () {
+    it('should convert "55" to 55', function () {
+        const result = NumberRatchet.safeNumber('55');
+        expect(result).toEqual(55);
+    });
+    it('should leave 66 alone', function () {
+        const result = NumberRatchet.safeNumber(66);
+        expect(result).toEqual(66);
+    });
+    it('should return the default when it cannot parse', function () {
+        const result = NumberRatchet.safeNumber({ test: 'test' }, 42);
+        expect(result).toEqual(42);
+    });
+    it('should return the default for the empty string', function () {
+        const result = NumberRatchet.safeNumber({ test: '' }, 42);
+        expect(result).toEqual(42);
+    });
+    it('should return the default for null/undefined if set true', function () {
+        const result = NumberRatchet.safeNumber(null, 42, true);
+        expect(result).toEqual(42);
+        const result2 = NumberRatchet.safeNumber(undefined, 46, true);
+        expect(result2).toEqual(46);
+    });
+    it('should return the passed value for null/undefined if set false', function () {
+        const result = NumberRatchet.safeNumber(null, 42, false);
+        expect(result).toEqual(null);
+        const result2 = NumberRatchet.safeNumber(undefined, 46, false);
+        expect(result2).toEqual(undefined);
+    });
+    it('should return the passed value for null/undefined if not set', function () {
+        const result = NumberRatchet.safeNumber(null, 42);
+        expect(result).toEqual(null);
+        const result2 = NumberRatchet.safeNumber(undefined, 46);
+        expect(result2).toEqual(undefined);
+    });
+});
+describe('#parseCSV', function () {
+    it('should convert "1,2,3" to [1,2,3]', function () {
+        const result = NumberRatchet.numberCSVToList('1,2,3');
+        expect(result.length).toEqual(3);
+    });
+    it('should convert " 1, 2,3  " to [1,2,3]', function () {
+        const result = NumberRatchet.numberCSVToList(' 1, 2,3 ');
+        expect(result.length).toEqual(3);
+    });
+    it('should convert " a1, 2,b  " to [2]', function () {
+        const result = NumberRatchet.numberCSVToList(' a1, 2,b  ');
+        expect(result.length).toEqual(1);
+        expect(result[0]).toEqual(2);
+    });
+});
+describe('#fitToWindow', function () {
+    it('should fit input to the window', function () {
+        expect(NumberRatchet.fitToWindow(5, 8, 10)).toEqual(9);
+        expect(NumberRatchet.fitToWindow(8, 2, 10)).toEqual(8);
+        expect(NumberRatchet.fitToWindow(8, 9, 9)).toEqual(9);
+        expect(NumberRatchet.fitToWindow(12, 2, 10)).toEqual(4);
+    });
+});
+describe('#groupNumbersIntoContiguousRanges', function () {
+    it('should group numbers', function () {
+        let input = JSON.parse(fs.readFileSync(path.join(EsmRatchet.fetchDirName(), '../../../../test-data/number_set.json')).toString());
+        input = input.map((i) => NumberRatchet.safeNumber(i));
+        const grouped = NumberRatchet.groupNumbersIntoContiguousRanges(input, 5);
+        expect(grouped).toBeTruthy();
+    });
+});
+describe('#distributeItemsEvenly', function () {
+    it('should distribute evenly', function () {
+        const test1 = NumberRatchet.distributeItemsEvenly(4, 6);
+        expect(test1).toBeTruthy();
+        const test2 = NumberRatchet.distributeItemsEvenly(12, 6);
+        expect(test2).toBeTruthy();
+        const test3 = NumberRatchet.distributeItemsEvenly(5, 6);
+        expect(test3).toBeTruthy();
+        const test4 = NumberRatchet.distributeItemsEvenly(192, 11);
+        expect(test4).toBeTruthy();
+        const test5 = NumberRatchet.distributeItemsEvenly(11, 192);
+        expect(test5).toBeTruthy();
+    });
+});
+describe('#createRange', function () {
+    it('should create ranges', function () {
+        const test1 = NumberRatchet.createRange(0, 5, 1);
+        expect(test1).toBeTruthy();
+        expect(test1.length).toEqual(5);
+        const test2 = NumberRatchet.createRange(1, 5, 1);
+        expect(test2).toBeTruthy();
+        expect(test2.length).toEqual(4);
+        const test3 = NumberRatchet.createRange(0, 10, 2);
+        expect(test3).toBeTruthy();
+        expect(test3.length).toEqual(5);
+    });
+});

package/lib/lang/parsed-url.js

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

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

@@ -0,0 +1,18 @@
+import { TimeoutToken } from './timeout-token.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+export declare class PromiseRatchet {
+    static resolveOnEvent<T>(evtSrc: any, okEvtNames: string[], errEvtNames?: string[], rval?: T): Promise<T>;
+    static timeout<T>(srcPromise: Promise<T>, title: string, timeoutMS: number): Promise<T | TimeoutToken>;
+    static createTimeoutPromise(title: string, timeoutMS: number): Promise<TimeoutToken>;
+    static wait(time: number): Promise<void>;
+    static dumpResult(result: any, autoDebug?: boolean): void;
+    static dumpError(err: any, autoDebug?: boolean): void;
+    static logErrorAndReturnNull(err: any, autoDebug?: boolean): void;
+    static runPromiseAndDump<T>(promise: Promise<T>): void;
+    static waitFor(testFunction: (n: number) => any, expectedValue: any, intervalMS: number, maxCycles: number, label?: string, count?: number): Promise<boolean>;
+    static runBoundedParallel<T>(promiseFn: Function, params: any[][], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static runBoundedParallelSingleParam<T>(promiseFn: Function, params: any[], context: any, maxConcurrent?: number, logLevel?: LoggerLevelName): Promise<T[]>;
+    static asyncForEachSerial(array: any[], callback: Function): Promise<void>;
+    static asyncForEachParallel(array: any[], callback: Function): Promise<void>;
+    private constructor();
+}