@bitblit/ratchet-common 6.1.196-alpha → 6.1.198-alpha

package/src/lang/boolean-ratchet.ts

@@ -6,7 +6,7 @@ import { NumberRatchet } from './number-ratchet.js';
 
 export class BooleanRatchet {
   public static allTrue(vals: boolean[], emptyArraysReturn = false): boolean {
-    let rval: boolean = null;
+    let rval: boolean;
     if (vals) {
       if (vals.length > 0) {
         rval = vals.reduce((a, i) => a && i, true);
@@ -21,7 +21,7 @@ export class BooleanRatchet {
   }
 
   public static anyTrue(vals: boolean[], emptyArraysReturn = false): boolean {
-    let rval: boolean = null;
+    let rval: boolean;
     if (vals) {
       if (vals.length > 0) {
         rval = vals.reduce((a, i) => a || i, false);

package/src/lang/global-ratchet.ts

@@ -36,7 +36,7 @@ export class GlobalRatchet {
         rval = process; // Final failover, not really a great option
       }
     } catch (err) {
-      throw new Error('Should not happen - error thrown trying to find global : '+ err);
+      throw new Error('Should not happen - error thrown trying to find global : ' + err, { cause: err });
     }
     if (!rval) {
       if (returnNullOnNone) {

package/src/lang/map-ratchet.ts

@@ -5,7 +5,7 @@
 import { KeyValue } from './key-value.js';
 import { Logger } from '../logger/logger.js';
 import { ErrorRatchet } from './error-ratchet.js';
-import { StringRatchet } from "./string-ratchet.ts";
+import { StringRatchet } from './string-ratchet.ts';
 
 export class MapRatchet {
   // Takes any map with keys that are nested and expands them
@@ -205,9 +205,9 @@ export class MapRatchet {
     return rval;
   }
 
-  public static snakeCaseKeysToCamelCase(obj:any):any {
+  public static snakeCaseKeysToCamelCase(obj: any): any {
     if (Array.isArray(obj)) {
-      return obj.map(v => StringRatchet.snakeCaseToCamelCase(v));
+      return obj.map((v) => StringRatchet.snakeCaseToCamelCase(v));
     } else if (obj !== null && obj.constructor === Object) {
       return Object.entries(obj).reduce((acc, [key, value]) => {
         const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());

package/src/lang/number-ratchet.ts

@@ -67,7 +67,7 @@ export class NumberRatchet {
   }
 
   public static safeNumberOpt(input: any, optionPart?: Partial<SafeNumberOptions>): number {
-    let rval: number = undefined;
+    let rval: number;
     const opts: SafeNumberOptions = Object.assign({}, NumberRatchet.DEFAULT_SAFE_NUMBER_OPTIONS, optionPart || {});
     if (input === null) {
       rval = opts.returnValueForNull;

package/src/lang/promise-ratchet.ts

@@ -107,7 +107,7 @@ export class PromiseRatchet {
       return false;
     }
 
-    let curVal: any = null;
+    let curVal: any;
     try {
       curVal = testFunction(count);
     } catch (err) {

package/src/lang/simple-encryption-ratchet.ts

@@ -1,18 +1,23 @@
-import { RequireRatchet } from "./require-ratchet.ts";
-import { NumberRatchet } from "./number-ratchet.ts";
-import { Base64Ratchet } from "./base64-ratchet.ts";
+import { RequireRatchet } from './require-ratchet.ts';
+import { NumberRatchet } from './number-ratchet.ts';
+import { Base64Ratchet } from './base64-ratchet.ts';
 
 /**
  * A VERY simple wrapper for doing basic AES-GCM encryption on arbitrary text -
  * useful for slugs, etc., since the same code should work both in Node.js and
  * most modern browsers
  */
-export class SimpleEncryptionRatchet{
+export class SimpleEncryptionRatchet {
   private sharedKey: Promise<CryptoKey>;
 
-  constructor(sharedRawKey: string | Promise<string>, private urlSafe:boolean = false, private ivLength: number = 12) { // Recommended for AES-GCM
+  constructor(
+    sharedRawKey: string | Promise<string>,
+    private urlSafe: boolean = false,
+    private ivLength: number = 12,
+  ) {
+    // Recommended for AES-GCM
     RequireRatchet.notNullOrUndefined(sharedRawKey);
-    RequireRatchet.true(ivLength>=12, 'ivLength must be at least 12');
+    RequireRatchet.true(ivLength >= 12, 'ivLength must be at least 12');
     this.sharedKey = this.createSharedKey(sharedRawKey);
   }
 
@@ -28,25 +33,24 @@ export class SimpleEncryptionRatchet{
 
   // Converts base64 to ArrayBuffer
   private base64ToBuf(base64: string): Uint8Array<ArrayBuffer> {
-    return new Uint8Array(atob(base64).split('').map(c => c.charCodeAt(0)));
+    return new Uint8Array(
+      atob(base64)
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    );
   }
 
-
   // Encrypt a string with a shared key
   public async encrypt(data: string): Promise<string> {
-    const iv:Uint8Array<ArrayBuffer> = crypto.getRandomValues(new Uint8Array(this.ivLength));
-    const encoded:Uint8Array<ArrayBuffer> = this.strToBuf(data);
+    const iv: Uint8Array<ArrayBuffer> = crypto.getRandomValues(new Uint8Array(this.ivLength));
+    const encoded: Uint8Array<ArrayBuffer> = this.strToBuf(data);
     const key: CryptoKey = await this.sharedKey;
-    const ciphertext = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv },
-      key,
-      encoded
-    );
+    const ciphertext = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, encoded);
     const ivMsg: string = this.bufToBase64(iv.buffer);
     const dataMsg: string = this.bufToBase64(ciphertext);
 
     // Format it up in a way that can be unrolled later
-    let rval: string = ivMsg.length+'K'+ivMsg+dataMsg;
+    let rval: string = ivMsg.length + 'K' + ivMsg + dataMsg;
     if (this.urlSafe) {
       rval = Base64Ratchet.encodeStringToBase64UrlString(rval);
     }
@@ -56,20 +60,16 @@ export class SimpleEncryptionRatchet{
   // Decrypt a string with the shared key
   public async decrypt(encryptedValueIn: string): Promise<string> {
     const encryptedValue: string = this.urlSafe ? Base64Ratchet.decodeBase64UrlStringToString(encryptedValueIn) : encryptedValueIn;
-    const split: number = encryptedValue?.indexOf('K')
-    if (!split || split<1) {
-      throw new Error('Invalid split : '+split);
+    const split: number = encryptedValue?.indexOf('K');
+    if (!split || split < 1) {
+      throw new Error('Invalid split : ' + split);
     }
     const ivLen: number = NumberRatchet.safeNumber(encryptedValue.substring(0, split));
-    const iv: string = encryptedValue.substring(split+1, split+1+ivLen);
-    const data: string = encryptedValue.substring(split+1+ivLen);
+    const iv: string = encryptedValue.substring(split + 1, split + 1 + ivLen);
+    const data: string = encryptedValue.substring(split + 1 + ivLen);
 
     const key: CryptoKey = await this.sharedKey;
-    const decrypted = await crypto.subtle.decrypt(
-      { name: "AES-GCM", iv: this.base64ToBuf(iv) },
-      key,
-      this.base64ToBuf(data)
-    );
+    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: this.base64ToBuf(iv) }, key, this.base64ToBuf(data));
     return new TextDecoder().decode(decrypted);
   }
 
@@ -77,12 +77,6 @@ export class SimpleEncryptionRatchet{
   private async createSharedKey(rawKeyIn: string | Promise<string>): Promise<CryptoKey> {
     const rawKey: string = typeof rawKeyIn === 'string' ? rawKeyIn : await rawKeyIn;
     const keyMaterial = this.strToBuf(rawKey.padEnd(32, '0').slice(0, 32)); // 256-bit key
-    return crypto.subtle.importKey(
-      "raw",
-      keyMaterial,
-      "AES-GCM",
-      false,
-      ["encrypt", "decrypt"]
-    );
+    return crypto.subtle.importKey('raw', keyMaterial, 'AES-GCM', false, ['encrypt', 'decrypt']);
   }
-}
+}

package/src/lang/stop-watch.ts

@@ -24,7 +24,7 @@ export class StopWatch {
   // 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;
+    this._createTime += offset;
     return this._createTime;
   }
 

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

@@ -84,7 +84,6 @@ describe('#randomGeneration', function () {
     expect(result).toBeTruthy();
     expect(result.length).toEqual(12);
   });
-
 });
 
 describe('#leadingZeros', function () {
@@ -226,7 +225,7 @@ describe('substring finder', () => {
 
 describe('alphabet checker', () => {
   test('should detect bad chars', () => {
-    expect(StringRatchet.stringContainsOnly())
+    expect(StringRatchet.stringContainsOnly());
     expect(StringRatchet.longestNonOverlappingRepeatingSubstring('abc123abc')).toEqual('abc');
     expect(StringRatchet.longestNonOverlappingRepeatingSubstring('abc123456')).toEqual(null);
   });

package/src/lang/string-ratchet.ts

@@ -187,7 +187,7 @@ export class StringRatchet {
    * @param len - Desired length of the random string.
    * @returns The generated random string.
    */
-  public static createRandomStringFromAlphabet(alphabet: string, len:number = 10): string {
+  public static createRandomStringFromAlphabet(alphabet: string, len: number = 10): string {
     RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(alphabet, 'Alphabet may not be empty');
     let rval: string = '';
 
@@ -195,7 +195,6 @@ export class StringRatchet {
       rval += alphabet.charAt(Math.floor(Math.random() * alphabet.length));
     }
     return rval;
-
   }
 
   /**
@@ -527,7 +526,7 @@ export class StringRatchet {
    * @returns A JSON string representation of the input, or an error message if circular references are found.
    */
   public static circSafeJsonStringify(input: any): string {
-    let rval: string = null;
+    let rval: string;
     try {
       rval = JSON.stringify(input);
     } catch (err) {
@@ -667,5 +666,4 @@ export class StringRatchet {
   public static snakeCaseToCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
   }
-
 }

package/src/logger/logger-instance.ts

@@ -31,19 +31,17 @@ export class LoggerInstance {
     this.options = inOptions; // MUST use the setter here
   }
 
-
   public findMessagesMatchingInBuffer(regex: RegExp): LogMessage[] {
     if (!this._ringBuffer) {
-      throw new Error('Called findMessagesMatchingInBuffer with no ring buffer configured')
+      throw new Error('Called findMessagesMatchingInBuffer with no ring buffer configured');
     }
     return this._ringBuffer.findMessagesMatchingInBuffer(regex);
   }
 
   public hasMessageMatchingInBuffer(regex: RegExp): boolean {
-    return this.findMessagesMatchingInBuffer(regex).length>0;
+    return this.findMessagesMatchingInBuffer(regex).length > 0;
   }
 
-
   public levelIsEnabled(level: LoggerLevelName): boolean {
     return LoggerUtil.levelIsEnabled(level, this._level);
   }
@@ -195,7 +193,7 @@ export class LoggerInstance {
         fn(rval);
       }
       // If it was logged out, or it wasn't but the formatter says to still put it in the ringbuffer...
-      if (this._ringBuffer && (rval || this.options.formatType===LogMessageFormatType.RingBufferOnly)) {
+      if (this._ringBuffer && (rval || this.options.formatType === LogMessageFormatType.RingBufferOnly)) {
         this._ringBuffer.addToRingBuffer(msg);
       }
     } else {

package/src/logger/logger-ring-buffer.ts

@@ -18,12 +18,12 @@ export class LoggerRingBuffer {
   }
 
   public findMessagesMatchingInBuffer(regex: RegExp): LogMessage[] {
-    const rval: LogMessage[] = this._buffer.filter(s=>s.messageSource.match(regex));
+    const rval: LogMessage[] = this._buffer.filter((s) => s.messageSource.match(regex));
     return rval;
   }
 
   public hasMessageMatchingInBuffer(regex: RegExp): boolean {
-    return this.findMessagesMatchingInBuffer(regex).length>0;
+    return this.findMessagesMatchingInBuffer(regex).length > 0;
   }
 
   public get currentIndex(): number {
@@ -43,7 +43,7 @@ export class LoggerRingBuffer {
   }
 
   public getMessages(inStartFrom: number = null, clear = false, reverseSort = false): LogMessage[] {
-    let rval: LogMessage[] = null;
+    let rval: LogMessage[];
     if (this._bufferIdx < this._bufferSize) {
       const start: number = inStartFrom == null ? 0 : inStartFrom;
       rval = this._buffer.slice(start, this._bufferIdx); // Use slice to get a copy (should use below too)

package/src/logger/logger.ts

@@ -32,7 +32,6 @@ export class Logger {
     preProcessors: [],
   };
 
-
   public static findMessagesMatchingInBuffer(regex: RegExp): LogMessage[] {
     return Logger.getLogger().findMessagesMatchingInBuffer(regex);
   }
@@ -41,7 +40,6 @@ export class Logger {
     return Logger.getLogger().hasMessageMatchingInBuffer(regex);
   }
 
-
   public static applyDefaultsToOptions(input?: Partial<LoggerOptions>): LoggerOptions {
     const rval: LoggerOptions = input || {};
     rval.initialLevel = rval.initialLevel ?? Logger.DEFAULT_OPTIONS.initialLevel;

package/src/mail/mailer.ts

@@ -152,7 +152,7 @@ export class Mailer<T, R> implements MailerLike<T, R> {
   public async sendEmail(inRts: ReadyToSendEmail): Promise<SendEmailResult<T, R>> {
     RequireRatchet.notNullOrUndefined(inRts, 'RTS must be defined');
     RequireRatchet.notNullOrUndefined(inRts.destinationAddresses, 'Destination addresses must be defined');
-    let rval: SendEmailResult<T, R> = null;
+    let rval: SendEmailResult<T, R>;
 
     const resolved: ResolvedReadyToSendEmail = await this.resolveReadyToSendEmail(inRts);
     try {

package/src/network/restful-api-http-error.ts

@@ -80,7 +80,7 @@ export class RestfulApiHttpError<T = void> extends Error {
   }
 
   public static wrapError<T = void>(err: Error): RestfulApiHttpError<T> {
-    let rval: RestfulApiHttpError<T> = null;
+    let rval: RestfulApiHttpError<T>;
     if (RestfulApiHttpError.objectIsRestfulApiHttpError(err)) {
       rval = err as RestfulApiHttpError<T>;
     } else {

package/src/transform/transform-ratchet.ts

@@ -19,7 +19,7 @@ export class TransformRatchet {
   }
 
   private static transformGeneric(toTransform: any, rules: TransformRule[] = [], isKey: boolean, context: any): any {
-    let rval: any = null;
+    let rval: any;
     const type: string = typeof toTransform;
     switch (type) {
       case 'undefined':

package/src/typing/exact-and-require-all.ts

@@ -1,9 +1,9 @@
-import { RequireAll } from "./require-all.ts";
-import { Exact } from "./exact.ts";
+import { RequireAll } from './require-all.ts';
+import { Exact } from './exact.ts';
 
 /**
  * This is used in a "satisfy" clause to make sure that an object
  * contains all the fields in T and does not contain any fields
  * not in T
  */
-export type ExactAndRequireAll<T> = Exact<RequireAll<T>>;
+export type ExactAndRequireAll<T> = Exact<RequireAll<T>>;

package/src/typing/exact.ts

@@ -2,5 +2,4 @@
  * This is used in a "satisfy" clause to make sure that an object
  * DOES NOT contain any fields that the referred type doesn't have
  */
-export type Exact<T extends object> =
-  T & Partial<Record<Exclude<string, keyof T>, never>>;
+export type Exact<T extends object> = T & Partial<Record<Exclude<string, keyof T>, never>>;

package/src/typing/require-all.ts

@@ -4,4 +4,4 @@
  */
 export type RequireAll<T> = {
   [K in keyof T]-?: NonNullable<T[K]>;
-};
+};