@onivoro/isomorphic-common 22.0.7 → 24.0.1

package/{dist/cjs/lib/functions/to-string.function.js → src/lib/functions/to-string.function.ts}

@@ -1,11 +1,11 @@
-"use strict";
 // https://github.com/lodash/lodash/blob/main/src/toString.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toString = toString;
-const is_symbol_function_1 = require("./is-symbol.function");
+
+import { isSymbol } from './is-symbol.function';
+
 /** Used as references for various `Number` constants. */
 const INFINITY = 1 / 0;
-function toString(value) {
+
+export function toString(value: any): string {
     if (value == null) {
         return '';
     }
@@ -17,7 +17,7 @@ function toString(value) {
         // Recursively convert values (susceptible to call stack limits).
         return `${value.map((other) => (other == null ? other : toString(other)))}`;
     }
-    if ((0, is_symbol_function_1.isSymbol)(value)) {
+    if (isSymbol(value)) {
         return value.toString();
     }
     const result = `${value}`;

package/src/lib/functions/to-unique-array.function.spec.ts

@@ -0,0 +1,45 @@
+import { toUniqueArray } from './to-unique-array.function';
+
+describe('toUniqueArray', () => {
+  it.each([
+    [
+      [1, 2, 3],
+      [1, 2, 3],
+    ],
+    [[1, 1, 1], [1]],
+  ])(
+    'GIVEN array of numbers: %j, returns a unique array without duplicate elements',
+    (array, expected) => {
+      expect(toUniqueArray(array)).toEqual(expected);
+    }
+  );
+
+  it.each([
+    [
+      ['one', 'two', 'three'],
+      ['one', 'two', 'three'],
+    ],
+    [['one', 'one', 'one'], ['one']],
+  ])(
+    'GIVEN array of strings: %j, returns a unique array without duplicate elements',
+    (array, expected) => {
+      expect(toUniqueArray(array)).toEqual(expected);
+    }
+  );
+
+  it.each([
+    [
+      ['one', 'two', 'three', undefined, undefined],
+      ['one', 'two', 'three', undefined],
+    ],
+    [
+      ['one', 'one', 'one', null, null],
+      ['one', null],
+    ],
+  ])(
+    'GIVEN array with falsey values: %j, returns a unique array without duplicate elements including falsey values',
+    (array, expected) => {
+      expect(toUniqueArray(array)).toEqual(expected);
+    }
+  );
+});

package/src/lib/functions/to-unique-array.function.ts

@@ -0,0 +1,3 @@
+export function toUniqueArray<TElement>(elements: TElement[]): TElement[] {
+  return Array.from(new Set(elements));
+}

package/src/lib/functions/to-words.function.spec.ts

@@ -0,0 +1,7 @@
+import { toWords } from "./to-words.function";
+
+describe('toWords', () => {
+    it('worx', () => {
+        expect(toWords(337)).toMatchSnapshot();
+    });
+});

package/{dist/cjs/lib/functions/to-words.function.js → src/lib/functions/to-words.function.ts}

@@ -1,8 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toWords = toWords;
-const remove_alpha_chars_function_1 = require("./remove-alpha-chars.function");
+import { removeAlphaChars } from "./remove-alpha-chars.function";
+
 const MAX_SAFE_INTEGER = 9007199254740991;
+
 const TEN = 10;
 const ONE_HUNDRED = 100;
 const ONE_THOUSAND = 1000;
@@ -18,74 +17,92 @@ const LESS_THAN_TWENTY = [
 const TENTHS_LESS_THAN_HUNDRED = [
     'zero', 'ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
 ];
-function toWords(input) {
-    let words;
-    const number = (0, remove_alpha_chars_function_1.removeAlphaChars)(input) || '0';
+
+export function toWords(input: number | string): string {
+    let words: string;
+    const number = removeAlphaChars(input) || '0';
     const num = parseInt(number, 10);
+
     if (!isFinite(num)) {
-        throw new TypeError('Not a finite number: ' + number + ' (' + typeof number + ')');
+        throw new TypeError(
+            'Not a finite number: ' + number + ' (' + typeof number + ')'
+        );
     }
+
     if (!isSafeNumber(num)) {
-        throw new RangeError('Input is not a safe number, it\'s either too large or too small.');
+        throw new RangeError(
+            'Input is not a safe number, it\'s either too large or too small.'
+        );
     }
+
     words = generateWords(num);
+
     return words;
 }
-function generateWords(number, words) {
+
+function generateWords(number: any, words?: any[]): string {
     let remainder, word;
+
     if (number === 0) {
         return !words ? 'zero' : words.join(' ').replace(/,$/, '');
     }
+
     if (!words) {
         words = [];
     }
+
     if (number < 0) {
         words.push('minus');
         number = Math.abs(number);
     }
+
     if (number < 20) {
         remainder = 0;
         word = LESS_THAN_TWENTY[number];
-    }
-    else if (number < ONE_HUNDRED) {
+
+    } else if (number < ONE_HUNDRED) {
         remainder = number % TEN;
         word = TENTHS_LESS_THAN_HUNDRED[Math.floor(number / TEN)];
+
         if (remainder) {
             word += '-' + LESS_THAN_TWENTY[remainder];
             remainder = 0;
         }
-    }
-    else if (number < ONE_THOUSAND) {
+
+    } else if (number < ONE_THOUSAND) {
         remainder = number % ONE_HUNDRED;
         word = generateWords(Math.floor(number / ONE_HUNDRED)) + ' hundred';
-    }
-    else if (number < ONE_MILLION) {
+
+    } else if (number < ONE_MILLION) {
         remainder = number % ONE_THOUSAND;
         word = generateWords(Math.floor(number / ONE_THOUSAND)) + ' thousand,';
-    }
-    else if (number < ONE_BILLION) {
+
+    } else if (number < ONE_BILLION) {
         remainder = number % ONE_MILLION;
         word = generateWords(Math.floor(number / ONE_MILLION)) + ' million,';
-    }
-    else if (number < ONE_TRILLION) {
+
+    } else if (number < ONE_TRILLION) {
         remainder = number % ONE_BILLION;
         word = generateWords(Math.floor(number / ONE_BILLION)) + ' billion,';
-    }
-    else if (number < ONE_QUADRILLION) {
+
+    } else if (number < ONE_QUADRILLION) {
         remainder = number % ONE_TRILLION;
         word = generateWords(Math.floor(number / ONE_TRILLION)) + ' trillion,';
-    }
-    else if (number <= MAX) {
+
+    } else if (number <= MAX) {
         remainder = number % ONE_QUADRILLION;
         word = generateWords(Math.floor(number / ONE_QUADRILLION)) +
             ' quadrillion,';
     }
+
     words.push(word);
     return generateWords(remainder, words);
 }
-function isFinite(value) {
+
+function isFinite(value: any) {
     return !(typeof value !== 'number' || value !== value || value === Infinity || value === -Infinity);
 }
-function isSafeNumber(value) {
+
+function isSafeNumber(value: any) {
     return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
 }

package/src/lib/functions/try-json-parse.spec.ts

@@ -0,0 +1,37 @@
+import { tryJsonParse } from './try-json-parse';
+
+describe('tryJsonParse', () => {
+  describe('GIVEN input is parseable', () => {
+    describe.each([
+      [0, 0],
+      ['0', 0],
+      [337, expect.any(Number)],
+      [`${337}`, expect.any(Number)],
+      [false, false],
+      ['false', false],
+      [true, true],
+      ['true', true],
+      [`{ "test":  ${337}  }`, expect.objectContaining({ test: expect.any(Number) })],
+      [`{ "test": "${337}" }`, expect.objectContaining({ test: expect.stringMatching(/\d/) })],
+    ])('WHEN input is: %j', (input, expectedOutput) => {
+      it(`returns ${expectedOutput}`, () => {
+        expect(tryJsonParse(input as any)).toEqual(expectedOutput);
+      });
+    });
+  });
+
+  describe('GIVEN input is not parseable', () => {
+    describe.each([
+      ['', null],
+      [null, null],
+      [undefined, null],
+      [NaN, null],
+      ['randomness', null],
+      ['totally random', null],
+    ])('WHEN input is: %j', (input, expectedOutput) => {
+      it(`returns ${expectedOutput}`, () => {
+        expect(tryJsonParse(input as any)).toEqual(expectedOutput);
+      });
+    });
+  });
+});

package/src/lib/functions/try-json-parse.ts

@@ -0,0 +1,11 @@
+export function tryJsonParse<T>(parseable: string | null | undefined): T | null {
+  if (typeof parseable === 'undefined') {
+    return null;
+  }
+
+  try {
+    return JSON.parse(parseable as any) as T;
+  } catch (_e) {
+    return null;
+  }
+}

package/src/lib/functions/try-json-stringify.spec.ts

@@ -0,0 +1,44 @@
+import { tryJsonStringify } from './try-json-stringify';
+
+const arbitraryNumber: number = 337;
+
+describe('tryJsonStringify', () => {
+  describe('GIVEN input is stringifiable', () => {
+    describe.each([
+      [0, '0'],
+      ['0', '"0"'],
+      [arbitraryNumber, expect.stringMatching(/\d/)],
+      [arbitraryNumber.toString(), expect.stringMatching(/\d/)],
+      [false, 'false'],
+      ['false', '"false"'],
+      [true, 'true'],
+      ['true', '"true"'],
+      ['', '""'],
+      [{ test: arbitraryNumber }, expect.stringMatching(new RegExp(`"test".*${arbitraryNumber}`))],
+      [{ test: arbitraryNumber.toString() }, expect.stringMatching(new RegExp(`"test".*"${arbitraryNumber}"`))],
+      ['randommmm', expect.any(String)],
+      ['so random', expect.any(String)],
+    ])('WHEN input is: %j', (input, expectedOutput) => {
+      it(`returns ${expectedOutput}`, () => {
+        expect(tryJsonStringify(input as any)).toEqual(expectedOutput);
+      });
+    });
+  });
+
+  describe('GIVEN input is not stringifiable', () => {
+    let circularObject: any;
+
+    beforeEach(() => {
+      circularObject = { children: [] };
+      const circularObjectChild = { parent: circularObject };
+      circularObject.children.push(circularObjectChild);
+    });
+
+    describe('WHEN input is circular', () => {
+      it(`returns null`, () => {
+        expect(tryJsonStringify(circularObject)).toMatchSnapshot();
+        // expect(tryJsonStringify(circularObject)).toEqual(null);
+      });
+    });
+  });
+});

package/src/lib/functions/try-json-stringify.ts

@@ -0,0 +1,11 @@
+export function tryJsonStringify<T>(object: T | null | undefined, fmtr?: any, spaces?: number): string | null {
+  if (typeof object === 'undefined') {
+    return null;
+  }
+
+  try {
+    return JSON.stringify(object, fmtr, spaces);
+  } catch (_e) {
+    return null;
+  }
+}

package/src/lib/functions/try-parse-date.function.spec.ts

@@ -0,0 +1,12 @@
+import { tryParseDate } from './try-parse-date.function';
+
+describe('tryParseDate', () => {
+    describe('GIVEN input is partial or full ISO8601', () => {
+        it.each([
+            '2023-12-23',
+            '2023-12-23T00:00:00.000',
+        ])('%j', (input) => {
+            expect(tryParseDate(input)).toMatchSnapshot();
+        });
+    });
+});

package/src/lib/functions/try-parse-date.function.ts

@@ -0,0 +1,17 @@
+export function tryParseDate(input: string | Date | undefined | null): Date | undefined {
+    if (!input) {
+        return;
+    }
+
+    if(input instanceof Date) {
+        return input;
+    }
+
+    const date = new Date(input);
+
+    if ((date as any) == 'Invalid Date') {
+        return;
+    }
+
+    return date;
+}

package/src/lib/functions/unicode-words.const.ts

@@ -0,0 +1,70 @@
+// source https://github.com/lodash/lodash/blob/master/.internal/unicodeWords.js
+
+/** Used to compose unicode character classes. */
+const rsAstralRange = '\\ud800-\\udfff'
+const rsComboMarksRange = '\\u0300-\\u036f'
+const reComboHalfMarksRange = '\\ufe20-\\ufe2f'
+const rsComboSymbolsRange = '\\u20d0-\\u20ff'
+const rsComboMarksExtendedRange = '\\u1ab0-\\u1aff'
+const rsComboMarksSupplementRange = '\\u1dc0-\\u1dff'
+const rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange + rsComboMarksExtendedRange + rsComboMarksSupplementRange
+const rsDingbatRange = '\\u2700-\\u27bf'
+const rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff'
+const rsMathOpRange = '\\xac\\xb1\\xd7\\xf7'
+const rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf'
+const rsPunctuationRange = '\\u2000-\\u206f'
+const rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000'
+const rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde'
+const rsVarRange = '\\ufe0e\\ufe0f'
+const rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange
+
+/** Used to compose unicode capture groups. */
+const rsApos = "['\u2019]"
+const rsBreak = `[${rsBreakRange}]`
+const rsCombo = `[${rsComboRange}]`
+const rsDigit = '\\d'
+const rsDingbat = `[${rsDingbatRange}]`
+const rsLower = `[${rsLowerRange}]`
+const rsMisc = `[^${rsAstralRange}${rsBreakRange + rsDigit + rsDingbatRange + rsLowerRange + rsUpperRange}]`
+const rsFitz = '\\ud83c[\\udffb-\\udfff]'
+const rsModifier = `(?:${rsCombo}|${rsFitz})`
+const rsNonAstral = `[^${rsAstralRange}]`
+const rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}'
+const rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]'
+const rsUpper = `[${rsUpperRange}]`
+const rsZWJ = '\\u200d'
+
+/** Used to compose unicode regexes. */
+const rsMiscLower = `(?:${rsLower}|${rsMisc})`
+const rsMiscUpper = `(?:${rsUpper}|${rsMisc})`
+const rsOptContrLower = `(?:${rsApos}(?:d|ll|m|re|s|t|ve))?`
+const rsOptContrUpper = `(?:${rsApos}(?:D|LL|M|RE|S|T|VE))?`
+const reOptMod = `${rsModifier}?`
+const rsOptVar = `[${rsVarRange}]?`
+const rsOptJoin = `(?:${rsZWJ}(?:${[rsNonAstral, rsRegional, rsSurrPair].join('|')})${rsOptVar + reOptMod})*`
+const rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])'
+const rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])'
+const rsSeq = rsOptVar + reOptMod + rsOptJoin
+const rsEmoji = `(?:${[rsDingbat, rsRegional, rsSurrPair].join('|')})${rsSeq}`
+
+const reUnicodeWords = RegExp([
+  `${rsUpper}?${rsLower}+${rsOptContrLower}(?=${[rsBreak, rsUpper, '$'].join('|')})`,
+  `${rsMiscUpper}+${rsOptContrUpper}(?=${[rsBreak, rsUpper + rsMiscLower, '$'].join('|')})`,
+  `${rsUpper}?${rsMiscLower}+${rsOptContrLower}`,
+  `${rsUpper}+${rsOptContrUpper}`,
+  rsOrdUpper,
+  rsOrdLower,
+  `${rsDigit}+`,
+  rsEmoji
+].join('|'), 'g')
+
+/**
+ * Splits a Unicode `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+export function unicodeWords(string: string) {
+  return string.match(reUnicodeWords)
+}

package/src/lib/functions/upper-first.function.spec.ts

@@ -0,0 +1,16 @@
+import { upperFirst } from './upper-first.function';
+
+describe('upperFirst', () => {
+  it.each([
+    'asdf',
+    'XCVB'
+  ])('GIVEN %j, does what u expect', (input) => {
+    expect(upperFirst(input)).toMatchSnapshot();
+  });
+
+  it.each([
+    null, undefined, 0, false
+  ])('GIVEN falsey input %j, does what u expect', (input) => {
+    expect(upperFirst(input)).toMatchSnapshot();
+  });
+});

package/src/lib/functions/upper-first.function.ts

@@ -0,0 +1,10 @@
+export function upperFirst(string: string) {
+  if (!string) {
+    return string;
+  }
+
+  return string
+    .split('')
+    .map((curr: string, i: number) => curr[!i ? 'toUpperCase' : 'toLowerCase']())
+    .join('');
+}

package/src/lib/functions/use-date.function.ts

@@ -0,0 +1,21 @@
+/* eslint no-global-assign:0 */
+export async function useDate(date: string, fn: () => Promise<void>) {
+    const mockedDate = new Date(date);
+
+    const OriginalDate = Date;
+
+    Date = class extends OriginalDate {
+        constructor(...args: any[]) {
+            super(
+                (args.length === 0) ? mockedDate : new (OriginalDate as any)(...args)
+            );
+        }
+        static override now() {
+            return mockedDate.getTime();
+        }
+    } as any;
+
+    await fn();
+
+    Date = OriginalDate;
+}

package/src/lib/functions/words.function.ts

@@ -0,0 +1,38 @@
+// source https://github.com/lodash/lodash/blob/master/words.js
+
+import { unicodeWords } from './unicode-words.const';
+
+const hasUnicodeWord = RegExp.prototype.test.bind(
+  /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/
+)
+
+/** Used to match words composed of alphanumeric characters. */
+const reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g
+
+function asciiWords(string: string) {
+  return string.match(reAsciiWord)
+}
+
+/**
+ * Splits `string` into an array of its words.
+ *
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to inspect.
+ * @param {RegExp|string} [pattern] The pattern to match words.
+ * @returns {Array} Returns the words of `string`.
+ * @example
+ *
+ * words('fred, barney, & pebbles')
+ * // => ['fred', 'barney', 'pebbles']
+ *
+ * words('fred, barney, & pebbles', /[^, ]+/g)
+ * // => ['fred', 'barney', '&', 'pebbles']
+ */
+export function words(string: string, pattern?: RegExp) {
+  if (pattern === undefined) {
+    const result = hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string)
+    return result || []
+  }
+  return string.match(pattern) || []
+}

package/src/lib/types/access-token.interface.ts

@@ -0,0 +1,8 @@
+export type IAccessToken = {
+    id: string,
+    brokerId?: string,
+    companyId?: string,
+    roleId: string,
+    type: 'user' | 'machine',
+    exp?: number
+};

package/{dist/esm/lib/interfaces/axios-wrapped-nest-exception.interface.d.ts → src/lib/types/axios-wrapped-nest-exception.interface.ts}

@@ -1,5 +1,5 @@
 export interface IAxiosWrappedNestException {
     statusCode: number;
     error: string;
-    message: string;
+    message: string
 }

package/src/lib/types/company.type.ts

@@ -0,0 +1,18 @@
+export type TCompany = {
+    id: string;
+    statusId: string;
+    renewalDate: string;
+    name: string;
+    ein: string;
+    duns: string;
+    address1: string;
+    address2: string;
+    city: string;
+    state: string;
+    zip: string;
+    phone: string;
+    externalId: string;
+    bmiThresholdWithComorbidities: number;
+    bmiThresholdWithoutComorbidities: number;
+    membershipType: string;
+};

package/src/lib/types/createable.type.ts

@@ -0,0 +1 @@
+export type TCreateable = { createdAt: Date | string };

package/{dist/cjs/lib/interfaces/entity-provider.interface.d.ts → src/lib/types/entity-provider.interface.ts}

@@ -6,4 +6,4 @@ export interface IEntityProvider<TEntity, TFindOneOptions, TFindManyOptions, TFi
     delete: (options: TFindOptionsWhere) => Promise<void>;
     put: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
     patch: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
-}
+}

package/src/lib/types/keys-of.type copy.ts

@@ -0,0 +1 @@
+export type TKeysOf<TKeySource, TValue> = { [key in keyof TKeySource]: TValue };

package/src/lib/types/keys-of.type.ts

@@ -0,0 +1 @@
+export type TKeysOf<TKeySource, TValue> = { [key in keyof TKeySource]: TValue };

package/{dist/types/lib/interfaces/lookup.interface.d.ts → src/lib/types/lookup.interface copy.ts }

@@ -1,4 +1,4 @@
 export interface ILookup<TDisplay, TValue> {
-    display: TDisplay;
-    value: TValue;
+  display: TDisplay;
+  value: TValue;
 }

package/{dist/cjs/lib/interfaces/lookup.interface.d.ts → src/lib/types/lookup.interface.ts}

@@ -1,4 +1,4 @@
 export interface ILookup<TDisplay, TValue> {
-    display: TDisplay;
-    value: TValue;
+  display: TDisplay;
+  value: TValue;
 }

package/src/lib/types/nameable.type.ts

@@ -0,0 +1,4 @@
+export type TNameable = {
+    firstName: string;
+    lastName: string;
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.isomorphic.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../../dist/out-tsc"
+  },
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}