@bitblit/ratchet-common 6.0.146-alpha → 6.0.148-alpha

package/src/lang/base64-ratchet.ts

@@ -0,0 +1,247 @@
+/*
+    Functions for working with base64
+*/
+
+import { Logger } from '../logger/logger.js';
+import { StringRatchet } from './string-ratchet.js';
+import { ErrorRatchet } from './error-ratchet.js';
+
+// We use uint8 arrays in here because the default javascript handling of base64 encoding/decoding is
+// broken for anything that isn't a normal ascii string
+
+// Base64 code in this class lifted straight from:
+// https://gist.githubusercontent.com/enepomnyaschih/72c423f727d395eeaa09697058238727/raw/74d3cbf82481545bc26c104de2419f4ee30c7dd7/base64.js
+// Since native javascript handling is so poor
+export class Base64Ratchet {
+
+  public static safeObjectToBase64JSON(input: any): any {
+    return input ? Base64Ratchet.generateBase64VersionOfString(JSON.stringify(input)) : null;
+  }
+
+  public static safeBase64JSONParse(input: string): any {
+    let rval: any = {};
+    try {
+      if (input) {
+        rval = JSON.parse(Base64Ratchet.base64StringToString(input, 'utf-8'));
+      }
+    } catch (err) {
+      Logger.warn('Error parsing b64/json : %s as json, got %s', input, err, err);
+      rval = {};
+    }
+    return rval;
+  }
+
+  public static generateBase64VersionOfBlob(blob: Blob): Promise<string> {
+    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);
+      }
+    });
+  }
+
+  public static generateBase64VersionOfString(input: string): string {
+    return Base64Ratchet.generateBase64VersionOfUint8Array(StringRatchet.stringToUint8Array(input));
+  }
+
+  public static generateBase64VersionOfUint8Array(input: Uint8Array): string {
+    return Base64Ratchet.uint8ArrayToBase64String(input);
+  }
+
+  public static base64StringToUint8Array(b64encoded: string): Uint8Array<ArrayBuffer> {
+    try {
+      const uint8: Uint8Array<ArrayBuffer> = Base64Ratchet.base64StringToBytes(b64encoded);
+      return uint8;
+    } catch (err) {
+      Logger.error('Failed to decode base64: %s', b64encoded);
+      throw err;
+    }
+  }
+
+  public static base64StringToString(input: string, encoding = 'utf8'): string {
+    return new TextDecoder(encoding).decode(Base64Ratchet.base64StringToUint8Array(input));
+  }
+
+  private static BASE64_ABC: string[] = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '+',
+    '/',
+  ];
+
+  /*
+  // This constant can also be computed with the following algorithm:
+  const l = 256, base64codes = new Uint8Array(l);
+  for (let i = 0; i < l; ++i) {
+      base64codes[i] = 255; // invalid character
+  }
+  base64abc.forEach((char, index) => {
+      base64codes[char.charCodeAt(0)] = index;
+  });
+  base64codes["=".charCodeAt(0)] = 0; // ignored anyway, so we just need to prevent an error
+  */
+  private static BASE64_CODES: number[] = [
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59,
+    60, 61, 255, 255, 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+    255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+  ];
+
+  public static getBase64Code(charCode: number): number {
+    if (charCode >= Base64Ratchet.BASE64_CODES.length) {
+      throw new Error('Unable to parse base64 string.');
+    }
+    const code: number = Base64Ratchet.BASE64_CODES[charCode];
+    if (code === 255) {
+      throw new Error('Unable to parse base64 string.');
+    }
+    return code;
+  }
+
+  public static uint8ArrayToBase64UrlString(bytes: Uint8Array): string {
+    let tmp: string = Base64Ratchet.uint8ArrayToBase64String(bytes);
+    tmp = tmp.split('+').join('-').split('/').join('_').split('=').join('');
+    return tmp;
+  }
+
+  public static uint8ArrayToBase64String(bytes: Uint8Array): string {
+    let result = '';
+    let i: number;
+    const l: number = bytes.length;
+    for (i = 2; i < l; i += 3) {
+      result += Base64Ratchet.BASE64_ABC[bytes[i - 2] >> 2];
+      result += Base64Ratchet.BASE64_ABC[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
+      result += Base64Ratchet.BASE64_ABC[((bytes[i - 1] & 0x0f) << 2) | (bytes[i] >> 6)];
+      result += Base64Ratchet.BASE64_ABC[bytes[i] & 0x3f];
+    }
+    if (i === l + 1) {
+      // 1 octet yet to write
+      result += Base64Ratchet.BASE64_ABC[bytes[i - 2] >> 2];
+      result += Base64Ratchet.BASE64_ABC[(bytes[i - 2] & 0x03) << 4];
+      result += '==';
+    }
+    if (i === l) {
+      // 2 octets yet to write
+      result += Base64Ratchet.BASE64_ABC[bytes[i - 2] >> 2];
+      result += Base64Ratchet.BASE64_ABC[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
+      result += Base64Ratchet.BASE64_ABC[(bytes[i - 1] & 0x0f) << 2];
+      result += '=';
+    }
+    return result;
+  }
+
+  public static base64StringToBytes(str: string): Uint8Array<ArrayBuffer> {
+    if (str.length % 4 !== 0) {
+      throw ErrorRatchet.fErr('Unable to parse base64 string, length: %s', str.length);
+    }
+    const index = str.indexOf('=');
+    if (index !== -1 && index < str.length - 2) {
+      throw ErrorRatchet.fErr('Unable to parse base64 string, index %s', index);
+    }
+    const missingOctets: number = str.endsWith('==') ? 2 : str.endsWith('=') ? 1 : 0;
+    const n: number = str.length;
+    const result: Uint8Array<ArrayBuffer> = new Uint8Array<ArrayBuffer>(new ArrayBuffer(3 * (n / 4)));
+    let buffer;
+    for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+      buffer =
+        (Base64Ratchet.getBase64Code(str.charCodeAt(i)) << 18) |
+        (Base64Ratchet.getBase64Code(str.charCodeAt(i + 1)) << 12) |
+        (Base64Ratchet.getBase64Code(str.charCodeAt(i + 2)) << 6) |
+        Base64Ratchet.getBase64Code(str.charCodeAt(i + 3));
+      result[j] = buffer >> 16;
+      result[j + 1] = (buffer >> 8) & 0xff;
+      result[j + 2] = buffer & 0xff;
+    }
+    return result.subarray(0, result.length - missingOctets);
+  }
+
+  public static base64UrlStringToBytes(str: string): Uint8Array<ArrayBuffer> {
+    let dec: string = str.split('-').join('+').split('_').join('/');
+    while (dec.length % 4 !== 0) {
+      dec += '=';
+    }
+    Logger.info('pre: %s post %s', str, dec);
+    return Base64Ratchet.base64StringToBytes(dec);
+  }
+
+  public static encodeStringToBase64String(str: string, encoder = new TextEncoder()): string {
+    return Base64Ratchet.uint8ArrayToBase64String(encoder.encode(str));
+  }
+
+  public static encodeStringToBase64UrlString(str: string, encoder = new TextEncoder()): string {
+    return Base64Ratchet.uint8ArrayToBase64UrlString(encoder.encode(str));
+  }
+
+  public static decodeBase64StringToString(str: string, decoder = new TextDecoder()): string {
+    return decoder.decode(Base64Ratchet.base64StringToBytes(str));
+  }
+
+  public static decodeBase64UrlStringToString(str: string, decoder = new TextDecoder()): string {
+    return decoder.decode(Base64Ratchet.base64UrlStringToBytes(str));
+  }
+}

package/src/lang/boolean-ratchet.spec.ts

@@ -0,0 +1,95 @@
+import { BooleanRatchet } from './boolean-ratchet.js';
+import { NumberRatchet } from './number-ratchet.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#parseBool', function () {
+  test('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);
+  });
+  test('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);
+  });
+
+  test('should xxx', function () {
+    const val = 'false';
+
+    const result: boolean = BooleanRatchet.parseBool(val) || BooleanRatchet.intToBool(NumberRatchet.safeNumber(val));
+    expect(result).toEqual(false);
+  });
+
+  test('should parse the string true as true', function () {
+    const result = BooleanRatchet.parseBool('true');
+    expect(result).toEqual(true);
+  });
+
+  test('should parse the string TRUE as true', function () {
+    const result = BooleanRatchet.parseBool('TRUE');
+    expect(result).toEqual(true);
+  });
+
+  test('should parse the boolean true as true', function () {
+    const result = BooleanRatchet.parseBool(true);
+    expect(result).toEqual(true);
+  });
+
+  test('should parse the empty string as false', function () {
+    const result = BooleanRatchet.parseBool('');
+    expect(result).toEqual(false);
+  });
+
+  test('should parse null as false', function () {
+    const result = BooleanRatchet.parseBool(null);
+    expect(result).toEqual(false);
+  });
+
+  test('should parse "asdf" as false', function () {
+    const result = BooleanRatchet.parseBool('asdf');
+    expect(result).toEqual(false);
+  });
+});
+
+describe('#intToBool', function () {
+  test('should parse null as false', function () {
+    const result = BooleanRatchet.intToBool(null);
+    expect(result).toEqual(false);
+  });
+
+  test('should parse 0 as false', function () {
+    const result = BooleanRatchet.intToBool(0);
+    expect(result).toEqual(false);
+  });
+
+  test('should parse "0" as false', function () {
+    const result = BooleanRatchet.intToBool('0');
+    expect(result).toEqual(false);
+  });
+
+  test('should parse 1 as true', function () {
+    const result = BooleanRatchet.intToBool(1);
+    expect(result).toEqual(true);
+  });
+
+  test('should parse "1" as true', function () {
+    const result = BooleanRatchet.intToBool('1');
+    expect(result).toEqual(true);
+  });
+
+  test('should parse "2" as true', function () {
+    const result = BooleanRatchet.intToBool('2');
+    expect(result).toEqual(true);
+  });
+});

package/src/lang/boolean-ratchet.ts

@@ -0,0 +1,52 @@
+/*
+    Functions for working with booleans
+*/
+
+import { NumberRatchet } from './number-ratchet.js';
+
+export class BooleanRatchet {
+  public static allTrue(vals: boolean[], emptyArraysReturn = false): boolean {
+    let rval: boolean = null;
+    if (vals) {
+      if (vals.length > 0) {
+        rval = vals.reduce((a, i) => a && i, true);
+      } else {
+        rval = emptyArraysReturn;
+      }
+    } else {
+      // Array was null
+      rval = false;
+    }
+    return rval;
+  }
+
+  public static anyTrue(vals: boolean[], emptyArraysReturn = false): boolean {
+    let rval: boolean = null;
+    if (vals) {
+      if (vals.length > 0) {
+        rval = vals.reduce((a, i) => a || i, false);
+      } else {
+        rval = emptyArraysReturn;
+      }
+    } else {
+      // Array was null
+      rval = false;
+    }
+    return rval;
+  }
+
+  public static parseBool(val: any): boolean {
+    return val === true || (val !== null && val !== undefined && typeof val === 'string' && val.toLowerCase() === 'true');
+  }
+
+  public static intToBool(val: any): boolean {
+    if (val === null || val === undefined) {
+      return false;
+    }
+    return NumberRatchet.safeNumber(val) !== 0;
+  }
+
+  public static boolToInt(val: any): number {
+    return BooleanRatchet.parseBool(val) ? 1 : 0;
+  }
+}

package/src/lang/composite-last-success-provider.spec.ts

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

package/src/lang/composite-last-success-provider.ts

@@ -0,0 +1,30 @@
+/** Classes implementing this interface return a timestamp of their last success **/
+import { LastSuccessProvider } from './last-success-provider.js';
+
+export class CompositeLastSuccessProvider implements LastSuccessProvider {
+  private sources: LastSuccessProvider[];
+  private mostRecent: boolean;
+
+  constructor(src: LastSuccessProvider[], mostRecentSrc = true) {
+    if (!src || src.length == 0) {
+      throw Error('Cannot create composite provider with null/empty sources');
+    }
+    this.sources = src;
+    this.mostRecent = mostRecentSrc;
+  }
+
+  public lastSuccess(): number {
+    let rval: number = null;
+    this.sources.forEach((s) => {
+      const val: number = 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/src/lang/currency-ratchet.ts

@@ -0,0 +1,29 @@
+import { Range } from './range';
+
+export class CurrencyRatchet {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static centToDollarFormat(cents: number, fractionDigits: number = 2): string {
+    return CurrencyRatchet.dollarFormat(cents / 100, fractionDigits);
+  }
+
+  public static dollarFormat(dollars: number, fractionDigits: number = 2): string {
+    const rval: string =
+      dollars === null || dollars === undefined
+        ? 'Null'
+        : '$' + dollars.toLocaleString('en-US', { minimumFractionDigits: fractionDigits, maximumFractionDigits: fractionDigits });
+    return rval;
+  }
+
+  public static dollarFormatNumberRange(range: Range<number>): string {
+    let rval: string = 'N/A';
+    if (range) {
+      rval = range.low ? CurrencyRatchet.dollarFormat(range.low) : ' ^ ';
+      rval += ' - ';
+      rval += range.high ? CurrencyRatchet.dollarFormat(range.high) : ' ^ ';
+    }
+    return rval;
+  }
+}

package/src/lang/date-ratchet.spec.ts

@@ -0,0 +1,27 @@
+import { DateRatchet } from './date-ratchet.js';
+import { describe, expect, test } from 'vitest';
+
+// CAW 2021-02-26 : I used to test 1776 here, but there was an odd off-by-8 seconds problem testing dates that
+// far in the past.  No doubt some kind of weird leap second thing.  Not fighting that today
+describe('#dateRatchet', function () {
+  test('should parse my common date format', function () {
+    const dt = DateRatchet.parseDefaultDate('1976-07-04');
+    expect(dt.getFullYear()).toEqual(1976);
+    expect(dt.getMonth()).toEqual(6); // 0 based
+    expect(dt.getDate()).toEqual(4);
+  });
+
+  test('should parse us with slashes', function () {
+    const dt = DateRatchet.parseCommonUsDate('07/04/1976');
+    expect(dt.getFullYear()).toEqual(1976);
+    expect(dt.getMonth()).toEqual(6); // 0 based
+    expect(dt.getDate()).toEqual(4);
+  });
+
+  test('should parse us with dashes', function () {
+    const dt = DateRatchet.parseCommonUsDate('07-04-1976');
+    expect(dt.getFullYear()).toEqual(1976);
+    expect(dt.getMonth()).toEqual(6); // 0 based
+    expect(dt.getDate()).toEqual(4);
+  });
+});

package/src/lang/date-ratchet.ts

@@ -0,0 +1,42 @@
+import { DateTime } from 'luxon';
+
+/*
+    Functions for working with dates/moments using my preferred date format, which
+    is yyyy-MM-dd and yyyy-MM-dd_HH-mm-ss_z
+
+    If I need milliseconds I tend to just work with epochs instead
+*/
+
+export class DateRatchet {
+  public static COMMON_US_DATE_FORMAT = 'MM/dd/yyyy';
+  public static DEFAULT_DATE_FORMAT = 'yyyy-MM-dd';
+  public static FULL_DATE_FORMAT = 'yyyy-MM-dd_HH_mm_ss';
+
+  public static PACIFIC_TIME_ZONE = 'America/Los_Angeles';
+  public static UTC_TIME_ZONE = 'etc/UTC';
+
+  public static formatFullDate(input: Date): string {
+    return DateTime.fromJSDate(input).toFormat(DateRatchet.FULL_DATE_FORMAT);
+  }
+
+  public static formatDefaultDateOnly(input: Date): string {
+    return DateTime.fromJSDate(input).toFormat(DateRatchet.DEFAULT_DATE_FORMAT);
+  }
+
+  public static parseDefaultDate(input: string): Date {
+    const rval: Date = DateTime.fromFormat(input, DateRatchet.DEFAULT_DATE_FORMAT).toJSDate();
+    return rval;
+  }
+
+  public static parseCommonUsDate(input: string): Date {
+    let rval: Date = null;
+    if (input) {
+      let templ: string = DateRatchet.COMMON_US_DATE_FORMAT;
+      if (input.indexOf('-') === 2) {
+        templ = templ.split('/').join('-');
+      }
+      rval = DateTime.fromFormat(input, templ).toJSDate();
+    }
+    return rval;
+  }
+}

package/src/lang/duration-ratchet.spec.ts

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

package/src/lang/duration-ratchet.ts

@@ -0,0 +1,77 @@
+import { DateTime, Duration, DurationLike } from 'luxon';
+import { NumberRatchet } from './number-ratchet.js';
+
+/*
+    Functions for working with durations (times between times)
+*/
+
+export class DurationRatchet {
+  public static thinFormatMsDuration(ms: number, includeMS = false): string {
+    const rem_ms = Math.floor(ms % 1000);
+    const seconds = Math.floor(ms / 1000) % 60;
+    const minutes = Math.floor(ms / (1000 * 60)) % 60;
+    const hours = Math.floor(ms / (1000 * 60 * 60)) % 24;
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+
+    const f = NumberRatchet.leadingZeros;
+    let rval: string = hours > 0 ? f(hours, 2) + 'h' : '';
+    rval += minutes > 0 ? f(minutes, 2) + 'm' : '';
+    rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) + 's' : f(seconds, 2) + 's';
+    if (days > 0) {
+      rval = days + 'd' + rval;
+    }
+    return rval;
+  }
+
+  public static formatMsDuration(ms: number, includeMS = false): string {
+    const rem_ms = Math.floor(ms % 1000);
+    const seconds = Math.floor(ms / 1000) % 60;
+    const minutes = Math.floor(ms / (1000 * 60)) % 60;
+    const hours = Math.floor(ms / (1000 * 60 * 60)) % 24;
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+
+    const f = NumberRatchet.leadingZeros;
+    let rval = f(hours, 2) + 'h' + f(minutes, 2) + 'm';
+    rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) + 's' : f(seconds, 2) + 's';
+    if (days > 0) {
+      rval = days + 'd' + rval;
+    }
+    return rval;
+  }
+
+  public static colonFormatMsDuration(ms: number, includeMS = false): string {
+    const rem_ms = ms % 1000;
+    const seconds = Math.floor(ms / 1000) % 60;
+    const minutes = Math.floor(ms / (1000 * 60)) % 60;
+    const hours = Math.floor(ms / (1000 * 60 * 60));
+
+    const f = NumberRatchet.leadingZeros;
+    let rval = f(hours, 2) + ':' + f(minutes, 2) + ':';
+    rval += includeMS ? f(seconds, 2) + '.' + f(rem_ms, 3) : f(seconds, 2);
+    return rval;
+  }
+
+  public static daysBetween(d1: Date, d2: Date): number {
+    const dur: Duration = DateTime.fromJSDate(d1).diff(DateTime.fromJSDate(d2));
+    return dur.days;
+  }
+
+  public static createSteps(
+    startEpochMS: number,
+    endEpochMS: number,
+    timezone: string,
+    outputFormat: string,
+    stepUnit: DurationLike,
+  ): string[] {
+    let curDate: DateTime = DateTime.fromMillis(startEpochMS).setZone(timezone);
+    const endDate: DateTime = DateTime.fromMillis(endEpochMS);
+
+    const rval: string[] = [];
+    while (curDate < endDate) {
+      rval.push(curDate.toFormat(outputFormat));
+      curDate = curDate.plus(stepUnit);
+    }
+
+    return rval;
+  }
+}