@bitblit/ratchet-common 6.0.145-alpha → 6.0.147-alpha

package/src/lang/sort-ratchet.ts

@@ -0,0 +1,50 @@
+/*
+    Helper functions for working with sorting.
+
+    Note that the functions in here do NOT claim to be able to correctly
+    sort undefined in all cases, since certain browsers will auto
+    sort undefined in arrays to certain places and never even
+    call this function. To be safe, filter and convert yourself
+    before sorting if undefined is a possibility
+
+    See : https://stackoverflow.com/questions/4783242/javascript-array-sort-with-undefined-values
+*/
+
+import { RequireRatchet } from './require-ratchet.js';
+import { NumberRatchet } from './number-ratchet.js';
+
+export class SortRatchet {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static sortNullToTop<T>(a: T, b: T, bothNonNullSort: (c: T, d: T) => number): number {
+    return SortRatchet.nullSafeSort(a, b, true, bothNonNullSort);
+  }
+
+  public static sortNullToBottom<T>(a: T, b: T, bothNonNullSort: (c: T, d: T) => number): number {
+    return SortRatchet.nullSafeSort(a, b, false, bothNonNullSort);
+  }
+
+  public static nullSafeSort<T>(a: T, b: T, nullsOnTop: boolean, bothNonNullSort: (c: T, d: T) => number): number {
+    let rval: number;
+
+    if (RequireRatchet.isNullOrUndefined(a) && RequireRatchet.isNullOrUndefined(b)) {
+      rval = 0;
+    } else if (RequireRatchet.isNullOrUndefined(a)) {
+      rval = nullsOnTop ? -Infinity : Infinity;
+    } else if (RequireRatchet.isNullOrUndefined(b)) {
+      rval = nullsOnTop ? Infinity : -Infinity;
+    } else {
+      rval = bothNonNullSort(a, b);
+    }
+
+    return rval;
+  }
+
+  public static sortNumericStringsAsNumbers(a: string | number, b: string | number, sortNonNumbersToTop?: boolean): number {
+    const an: number = NumberRatchet.safeNumber(a);
+    const bn: number = NumberRatchet.safeNumber(b);
+    return SortRatchet.nullSafeSort<number>(an, bn, sortNonNumbersToTop, (ax: number, bx: number) => ax - bx);
+  }
+}

package/src/lang/stop-watch.spec.ts

@@ -0,0 +1,53 @@
+import { StopWatch } from './stop-watch.js';
+import { PromiseRatchet } from './promise-ratchet.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#elapsedMS', function () {
+  test('should calculate elapsed MS correctly', async () => {
+    const sw: StopWatch = new StopWatch();
+    sw.moveCreateTime(-501);
+    //await PromiseRatchet.wait(500);
+    const elapsed: number = sw.elapsedMS();
+    expect(elapsed).toBeGreaterThan(500);
+    expect(elapsed).toBeLessThan(600);
+  });
+
+  test('should dump all', async () => {
+    const sw: StopWatch = new StopWatch();
+    sw.start('a1');
+    await PromiseRatchet.wait(50);
+    sw.stop('a1');
+    sw.start('b1');
+    await PromiseRatchet.wait(60);
+    sw.stop('b1');
+    sw.start('c1');
+    await PromiseRatchet.wait(70);
+    sw.stop('c1');
+    const names: string[] = sw.timerNames();
+    expect(names).toContain('a1');
+    expect(names).toContain('b1');
+    expect(names).toContain('c1');
+
+    const out: string = sw.dumpAll();
+    expect(out).toContain('a1');
+    expect(out).toContain('b1');
+    expect(out).toContain('c1');
+    expect(out).toContain('Overall');
+  });
+
+  test('should calc expected', async () => {
+    const sw: StopWatch = new StopWatch();
+
+    for (let i = 0; i < 10; i++) {
+      const elapsedTenths: number = Math.floor(sw.elapsedMS() / 100);
+      const expectedTenths: number = Math.floor(sw.expectedRemainingMS(i / 10) / 100);
+      if (i > 0) {
+        expect(elapsedTenths).toEqual(i);
+        expect(expectedTenths).toEqual(10 - i);
+      }
+      sw.moveCreateTime(-100);
+      //Logger.info('%d elapsed %d expected -- %s', elapsedTenths, expectedTenths);
+      //await PromiseRatchet.wait(100);
+    }
+  });
+});

package/src/lang/stop-watch.ts

@@ -0,0 +1,202 @@
+import { DurationRatchet } from './duration-ratchet.js';
+import { StringRatchet } from './string-ratchet.js';
+import { RequireRatchet } from './require-ratchet.js';
+import { LoggerLevelName } from '../logger/logger-level-name.js';
+import { Logger } from '../logger/logger.js';
+
+/*
+    Class to simplify timing
+*/
+
+export class StopWatch {
+  get createTime(): number {
+    return this._createTime;
+  }
+
+  private starts: Map<string, number> = new Map<string, number>();
+  private ends: Map<string, number> = new Map<string, number>();
+
+  private _createTime: number = Date.now();
+  private _label: string = StringRatchet.createRandomHexString(4);
+  private _labelIncludedInOutput = false;
+
+  // This is mainly used for testing - allows me to programmitically
+  // move the create-time into the past for testing things.  Might have
+  // some other uses, not really sure
+  public moveCreateTime(offset: number): number {
+    this._createTime+=offset;
+    return this._createTime;
+  }
+
+  public withLabel(val: string): StopWatch {
+    this._label = StringRatchet.trimToNull(val);
+    return this;
+  }
+
+  public withLabelIncludedInOutput(val: boolean): StopWatch {
+    this._labelIncludedInOutput = val;
+    return this;
+  }
+
+  get label(): string {
+    return this._label;
+  }
+
+  set label(value: string) {
+    this._label = value;
+  }
+
+  get labelIncludedInOutput(): boolean {
+    return this._labelIncludedInOutput;
+  }
+
+  set labelIncludedInOutput(value: boolean) {
+    this._labelIncludedInOutput = value;
+  }
+
+  public start(name: string): number {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+    const now: number = Date.now();
+    this.starts.set(StringRatchet.trimToNull(name), now);
+    return now;
+  }
+
+  public stop(name: string): number {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+    const now: number = Date.now();
+    this.ends.set(StringRatchet.trimToNull(name), now);
+    return now;
+  }
+
+  public reset(name: string): void {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+    this.starts.delete(StringRatchet.trimToNull(name));
+    this.ends.delete(StringRatchet.trimToNull(name));
+  }
+
+  public hasTimer(name: string): boolean {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
+    return this.starts.has(name);
+  }
+
+  public log(name?: string, shortForm?: boolean, logLevel: LoggerLevelName = LoggerLevelName.info): void {
+    Logger.logByLevel(logLevel, this.dump(name, shortForm));
+  }
+
+  public logExpected(pctComplete: number, name?: string, shortForm?: boolean, logLevel: LoggerLevelName = LoggerLevelName.info): void {
+    Logger.logByLevel(logLevel, this.dumpExpected(pctComplete, name, shortForm));
+  }
+
+  public timerNames(): string[] {
+    return Array.from(this.starts.keys());
+  }
+
+  public dumpAll(separator = ', ', shortForm?: boolean): string {
+    const outs: string[] = this.timerNames().map((s) => this.dump(s, shortForm));
+    let rval: string = 'Overall: ' + this.dump(null, shortForm);
+    if (outs.length > 0) {
+      rval += separator;
+      rval += outs.join(separator);
+    }
+    return rval;
+  }
+
+  public dump(name?: string, shortForm?: boolean): string {
+    let rval: string = this._labelIncludedInOutput ? this._label + ' ' : '';
+    const cleanName: string = StringRatchet.trimToNull(name);
+    if (cleanName && !this.hasTimer(cleanName)) {
+      rval += 'No such timer : ' + cleanName;
+    } else {
+      const start: number = name ? this.starts.get(cleanName) : this._createTime;
+      const end: number = name ? this.ends.get(cleanName) : Date.now();
+      rval += (cleanName || 'Default') + ' ';
+      if (!!start && !!end) {
+        rval += 'completed in ' + DurationRatchet.formatMsDuration(end - start, !shortForm);
+      } else if (start) {
+        rval += 'running for ' + DurationRatchet.formatMsDuration(Date.now() - start, !shortForm);
+      }
+    }
+    return rval;
+  }
+
+  public dumpExpectedByIdx(idx: number, total: number, name?: string, shortForm?: boolean): string {
+    RequireRatchet.true(idx > 0 && idx < total, 'IDX must be >=0 and less than total');
+    return this.dumpExpected(idx / total, name, shortForm);
+  }
+
+  public dumpExpected(pctComplete: number, name?: string, shortForm?: boolean): string {
+    let rval: string = this._labelIncludedInOutput ? this._label + ' ' : '';
+    const cleanName: string = StringRatchet.trimToNull(name);
+    if (cleanName && !this.hasTimer(cleanName)) {
+      rval += 'No such timer : ' + cleanName;
+    } else {
+      if (!pctComplete || pctComplete <= 0) {
+        rval += 'Cannot generate output for 0 percent complete';
+      } else if (pctComplete > 1) {
+        rval += 'Cannot generate output for percent > 1';
+      } else {
+        rval += (cleanName || 'Default') + ' ';
+        const remainMS: number = this.expectedRemainingMS(pctComplete, cleanName);
+        const elapsedMS: number = this.elapsedMS(cleanName);
+        //const expectedTotalMS: number = elapsedMS + remainMS;
+        if (remainMS === 0) {
+          rval += 'completed in ' + DurationRatchet.formatMsDuration(elapsedMS, !shortForm);
+        } else if (remainMS > 0) {
+          rval +=
+            'running for ' +
+            DurationRatchet.formatMsDuration(elapsedMS, !shortForm) +
+            ' approx ' +
+            DurationRatchet.formatMsDuration(remainMS, !shortForm) +
+            ' remaining';
+        } else {
+          throw new Error('Cannot happen - had negative remaining time : ' + remainMS);
+        }
+      }
+    }
+    return rval;
+  }
+
+  public expectedRemainingMSByIdx(idx: number, total: number, name?: string): number {
+    RequireRatchet.true(idx > 0 && idx < total, 'IDX must be >=0 and less than total');
+    return this.expectedRemainingMS(idx / total, name);
+  }
+
+  public expectedRemainingMS(pctComplete: number, name?: string): number {
+    let rval: number = null;
+    if (!pctComplete || pctComplete <= 0) {
+      // return null, no such thing
+    } else if (pctComplete > 1) {
+      // return null, no such thing for percent larger than one
+    } else {
+      const cleanName: string = StringRatchet.trimToNull(name);
+      const start: number = name ? this.starts.get(cleanName) : this._createTime;
+      const end: number = name ? this.ends.get(cleanName) : null;
+      if (!!start && !!end) {
+        rval = end - start; // already completed
+      } else if (start) {
+        const now: number = Date.now();
+        const elapsedMS: number = now - start;
+        const expectedTotalMS: number = Math.ceil(elapsedMS / pctComplete);
+        rval = expectedTotalMS - elapsedMS;
+      }
+    }
+    return rval;
+  }
+
+  public elapsedMS(name?: string): number {
+    let rval: number = null;
+    const cleanName: string = StringRatchet.trimToNull(name);
+    if (cleanName && !this.hasTimer(cleanName)) {
+      rval = null;
+    } else {
+      const start: number = name ? this.starts.get(cleanName) : this._createTime;
+      const end: number = name ? this.ends.get(cleanName) : Date.now();
+      if (!!start && !!end) {
+        rval = end - start;
+      } else if (start) {
+        rval = Date.now() - start;
+      }
+    }
+    return rval;
+  }
+}

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

@@ -0,0 +1,226 @@
+import { StringRatchet } from './string-ratchet.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#formatBytes', function () {
+  test('should format 0 bytes correctly', function () {
+    const result = StringRatchet.formatBytes(0);
+    expect(result).toEqual('0 Bytes');
+  });
+
+  test('should format less than a Kb correctly', function () {
+    const result = StringRatchet.formatBytes(123);
+    expect(result).toEqual('123 Bytes');
+  });
+
+  test('should format less than a Mb correctly', function () {
+    const result = StringRatchet.formatBytes(1024);
+    expect(result).toEqual('1 KB');
+  });
+
+  test('should format less than a Mb correctly with 3 decimals', function () {
+    const result = StringRatchet.formatBytes(1234, 3);
+    expect(result).toEqual('1.205 KB');
+  });
+});
+
+describe('#safeToString', function () {
+  test('should return "asdf"', function () {
+    const result = StringRatchet.safeString('asdf');
+    expect(result).toEqual('asdf');
+  });
+
+  test('should return "55"', function () {
+    const result = StringRatchet.safeString(55);
+    expect(result).toEqual('55');
+  });
+});
+
+describe('#obscure', function () {
+  test('should return "pa****rd"', function () {
+    const result = StringRatchet.obscure('password', 2, 2);
+    expect(result).toEqual('pa****rd');
+  });
+
+  test('should return null', function () {
+    const result = StringRatchet.obscure(null, 2, 2);
+    expect(result).toBeNull();
+  });
+
+  test('should return "p**s"', function () {
+    const result = StringRatchet.obscure('pass', 2, 2);
+    expect(result).toEqual('p**s');
+  });
+
+  test('should return "****"', function () {
+    const result = StringRatchet.obscure('pass', 0, 0);
+    expect(result).toEqual('****');
+  });
+
+  test('should return "p***"', function () {
+    const result = StringRatchet.obscure('pass', 1, 0);
+    expect(result).toEqual('p***');
+  });
+
+  test('should return "***s"', function () {
+    const result = StringRatchet.obscure('pass', 0, 1);
+    expect(result).toEqual('***s');
+  });
+});
+
+describe('#randomGeneration', function () {
+  test('should generate a guid"', function () {
+    const result = StringRatchet.createType4Guid();
+    expect(result).toBeTruthy();
+  });
+
+  test('should generate a random hex string"', function () {
+    const result = StringRatchet.createRandomHexString(12);
+    expect(result).toBeTruthy();
+    expect(result.length).toEqual(12);
+  });
+
+  test('should generate a random string from an alphabet"', function () {
+    const result = StringRatchet.createRandomStringFromAlphabet(StringRatchet.LOWER_CASE_LATIN, 12);
+    expect(result).toBeTruthy();
+    expect(result.length).toEqual(12);
+  });
+
+});
+
+describe('#leadingZeros', function () {
+  test('should generate string with leading zeros"', function () {
+    const result = StringRatchet.leadingZeros(25, 4);
+    expect(result).toEqual('0025');
+  });
+
+  test('should generate string with leading zeros and a negative sign"', function () {
+    const result = StringRatchet.leadingZeros(-8, 2);
+    expect(result).toEqual('-08');
+  });
+});
+
+describe('#stripNonNumeric', function () {
+  test('should return a string containing only numbers"', function () {
+    const result: string = StringRatchet.stripNonNumeric('702-555-1212');
+    expect(result).toEqual('7025551212');
+  });
+});
+
+describe('#stringContainsOnly', function () {
+  test('should check string contains only valid chars"', function () {
+    expect(StringRatchet.stringContainsOnly('test', 'tes')).toBeTruthy();
+    expect(StringRatchet.stringContainsOnly('test', 'teg')).toBeFalsy();
+
+    expect(StringRatchet.stringContainsOnlyAlphanumeric('test')).toBeTruthy();
+    expect(StringRatchet.stringContainsOnlyAlphanumeric('tes-')).toBeFalsy();
+
+    expect(StringRatchet.stringContainsOnlyHex('1a3')).toBeTruthy();
+    expect(StringRatchet.stringContainsOnlyHex('test')).toBeFalsy();
+  });
+});
+
+describe('#stringCsvSafe', function () {
+  test('should make values safe to place in a CSV"', function () {
+    expect(StringRatchet.csvSafe('test')).toEqual('test');
+    expect(StringRatchet.csvSafe('test,and 1')).toEqual('"test,and 1"');
+    expect(StringRatchet.csvSafe(1)).toEqual('1');
+    expect(StringRatchet.csvSafe("test'blah")).toEqual('"test\'blah"');
+  });
+});
+
+describe('#trimToEmpty', function () {
+  test('should return an empty string for null"', function () {
+    const result: string = StringRatchet.trimToEmpty(null);
+    expect(result).toEqual('');
+  });
+
+  test('should return an empty string for undefined"', function () {
+    const result: string = StringRatchet.trimToEmpty(undefined);
+    expect(result).toEqual('');
+  });
+
+  test('should return an empty string"', function () {
+    const result: string = StringRatchet.trimToEmpty('     ');
+    expect(result).toEqual('');
+  });
+
+  test('should return an abc"', function () {
+    const result: string = StringRatchet.trimToEmpty('abc   ');
+    expect(result).toEqual('abc');
+  });
+
+  test('should return string "5"', function () {
+    const result: string = StringRatchet.trimToEmpty(5 as any); // as any to fool TSC for testing
+    expect(result).toEqual('5');
+  });
+});
+
+describe('#trimStringPropertiesInPlace', function () {
+  test('should trim properties to null"', function () {
+    const test: any = {
+      a: 'test   ',
+      b: 1,
+      c: '    test',
+      d: null,
+      e: '     ',
+    };
+    const nullResult: any = StringRatchet.trimAllStringPropertiesToNullInPlace<any>(test);
+
+    expect(nullResult).not.toBeNull();
+    expect(nullResult['a']).toEqual('test');
+    expect(nullResult['b']).toEqual(1);
+    expect(nullResult['c']).toEqual('test');
+    expect(nullResult['d']).toEqual(null);
+    expect(nullResult['e']).toEqual(null);
+  });
+
+  test('should trim properties to empty"', function () {
+    const test: any = {
+      a: 'test   ',
+      b: 1,
+      c: '    test',
+      d: null,
+      e: '     ',
+    };
+    const emptyResult: any = StringRatchet.trimAllStringPropertiesToEmptyInPlace<any>(test);
+
+    expect(emptyResult).not.toBeNull();
+    expect(emptyResult['a']).toEqual('test');
+    expect(emptyResult['b']).toEqual(1);
+    expect(emptyResult['c']).toEqual('test');
+    expect(emptyResult['d']).toEqual(null);
+    expect(emptyResult['e']).toEqual('');
+  });
+});
+
+describe('#createShortUid', function () {
+  test('should return a short uid', function () {
+    for (let i = 0; i < 20; i++) {
+      console.log(StringRatchet.createShortUid());
+    }
+
+    const result: string = StringRatchet.createShortUid();
+    expect(result).toBeTruthy();
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe('#circSafeFormat', function () {
+  test('should format correctly when contents are circular', function () {
+    const testOb: any = {
+      a: 1,
+      b: 2,
+    };
+    testOb['c'] = testOb;
+    const out: string = StringRatchet.format('This is a test : %j', testOb);
+    expect(out).not.toBeNull;
+  });
+});
+
+describe('substring finder', () => {
+  test('should detect substring', () => {
+    expect(StringRatchet.longestNonOverlappingRepeatingSubstring('abc123abc')).toEqual('abc');
+    expect(StringRatchet.longestNonOverlappingRepeatingSubstring('abc123456')).toEqual(null);
+  });
+});
+