@onivoro/isomorphic-common 22.0.5 → 24.0.0

package/src/lib/functions/map-enum-to-lookup-array.function.ts

@@ -0,0 +1,6 @@
+import { ILookup } from "../types/lookup.interface";
+
+export function mapEnumToLookupArray<TEnum extends object>(enumeration: TEnum): ILookup<string, string>[] {
+    return Object.entries(enumeration)
+        .map(([key, value]) => ({ value, display: key.replace(/_/g, ' ') }) satisfies ILookup<string, string>);
+}

package/src/lib/functions/map-enum-to-options.function copy.ts

@@ -0,0 +1,7 @@
+export function mapEnumToOptions<TEntity extends object>(enumeration: TEntity, includeBlank = true) {
+    const enumArray = Object.entries(enumeration).map(([key, value]) => ({ value, display: key.replace(/_/g, ' ') }))
+
+    return includeBlank
+        ? [{ display: '', value: '' }, ...enumArray]
+        : enumArray;
+}

package/src/lib/functions/map-enum-to-options.function.ts

@@ -0,0 +1,7 @@
+export function mapEnumToOptions<TEntity extends object>(enumeration: TEntity, includeBlank = true) {
+    const enumArray = Object.entries(enumeration).map(([key, value]) => ({ value, display: key.replace(/_/g, ' ') }))
+
+    return includeBlank
+        ? [{ display: '', value: '' }, ...enumArray]
+        : enumArray;
+}

package/src/lib/functions/mock-calls.function.ts

@@ -0,0 +1,4 @@
+export function mockCalls(jestFn: any, label = 'mock-calls') {
+    const calls = jestFn?.mock?.calls || [];
+    return { [`${label} -->> ${calls.length} invocation(s)`]: calls };
+}

package/src/lib/functions/money.function.spec.ts

@@ -0,0 +1,10 @@
+import { money } from './money.function';
+
+describe('money', () => {
+    it('worx', () => {
+        expect(money('1234.567')).toMatchSnapshot();
+        expect(money(987.65)).toMatchSnapshot();
+        expect(money('$337.65')).toMatchSnapshot();
+        expect(money('$1,234.56')).toMatchSnapshot();
+    })
+});

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

@@ -0,0 +1,22 @@
+import { removeAlphaChars } from "./remove-alpha-chars.function";
+
+export function money(rawValue: number | string) {
+    if(!rawValue) {
+        return;
+    }
+
+    const scrubbed = removeAlphaChars(rawValue);
+
+    const amount = Number(scrubbed);
+
+    if(!amount && amount !== 0) {
+        return;
+    }
+
+    const formatter = new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency: 'USD'
+    });
+
+    return formatter.format(Number(amount));
+}

package/src/lib/functions/parse-bool.function.ts

@@ -0,0 +1,3 @@
+export function parseBool(asc: string | boolean | null | undefined) {
+  return asc ? asc === true || asc === 'true' : false;
+}

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

@@ -0,0 +1,21 @@
+// credit https://stackoverflow.com/questions/15690706/recursively-looping-through-an-object-to-build-a-property-list/53620876#53620876
+
+export function propertiesToArray(obj: Record<string, any>) {
+    const isObject = (val: any) =>
+        val && typeof val === 'object' && !Array.isArray(val);
+
+    const addDelimiter = (a: any, b: any) =>
+        a ? `${a}.${b}` : b;
+
+    const paths: any = (obj = {}, head = '') => {
+        return Object.entries(obj)
+            .reduce((product, [key, value]) => {
+                let fullPath = addDelimiter(head, key)
+                return isObject(value) ?
+                    product.concat(paths(value, fullPath))
+                    : product.concat(fullPath)
+            }, []);
+    }
+
+    return paths(obj);
+}

package/src/lib/functions/remove-alpha-chars.function.spec.ts

@@ -0,0 +1,11 @@
+import { removeAlphaChars } from './remove-alpha-chars.function';
+
+describe('removeAlphaChars', () => {
+    it('worx', () => {
+        expect(removeAlphaChars('1234.567')).toMatchSnapshot();
+        expect(removeAlphaChars(987.65)).toMatchSnapshot();
+        expect(removeAlphaChars('$337.65')).toMatchSnapshot();
+        expect(removeAlphaChars('$1,234.56')).toMatchSnapshot();
+        expect(removeAlphaChars('dollarzzz$1,234.5six')).toMatchSnapshot();
+    })
+});

package/src/lib/functions/remove-alpha-chars.function.ts

@@ -0,0 +1,9 @@
+import { decimalRegex } from "../constants/regexes.constant";
+
+export function removeAlphaChars(input?: string | number) {
+    if (!input) {
+        return;
+    }
+
+    return input.toString().match(decimalRegex)?.join?.('');
+}

package/src/lib/functions/remove-element-at-index.function copy.ts

@@ -0,0 +1,9 @@
+export function removeElementAtIndex<T>(array: T[], indexToRemove: number): T[] {
+    const newArray: T[] = [];
+    (array || []).forEach((element, index) => {
+        if(index !== indexToRemove) {
+            newArray.push(element);
+        }
+    });
+    return newArray;
+}

package/src/lib/functions/remove-element-at-index.function.ts

@@ -0,0 +1,9 @@
+export function removeElementAtIndex<T>(array: T[], indexToRemove: number): T[] {
+    const newArray: T[] = [];
+    (array || []).forEach((element, index) => {
+        if(index !== indexToRemove) {
+            newArray.push(element);
+        }
+    });
+    return newArray;
+}

package/src/lib/functions/round.function copy.ts

@@ -0,0 +1,4 @@
+export function round(numberToRound: number, scalingFactor: number) {
+    const scaledServingDose = numberToRound * scalingFactor;
+    return Math.round(scaledServingDose) / scalingFactor;
+}

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

@@ -0,0 +1,4 @@
+export function round(numberToRound: number, scalingFactor: number) {
+    const scaledServingDose = numberToRound * scalingFactor;
+    return Math.round(scaledServingDose) / scalingFactor;
+}

package/src/lib/functions/sanitize-filename.function.ts

@@ -0,0 +1,9 @@
+/* eslint-disable no-control-regex */
+
+const _ = '_';
+const asciiReplacementRegX = /\/|\?|:|\\|{|\^|'|\}|%|`|]|>|\[|~|<|#|\||"|!|\*/g;
+const unicodeReplacementRegX = /[^\u0000-\u007F]/g;
+
+export function sanitizeFilename(filename: string) {
+  return filename.replace(unicodeReplacementRegX, _).replace(asciiReplacementRegX, _).replace(/_+/g, _).trim();
+}

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

@@ -0,0 +1,3 @@
+export async function sleep(milliseconds = 0) {
+    return await new Promise(resolve => setTimeout(resolve, milliseconds));
+}

package/{dist/esm/lib/functions/snake-case.function.js → src/lib/functions/snake-case.function.ts}

@@ -1,8 +1,7 @@
-"use strict";
 // source https://github.com/lodash/lodash/blob/master/snakeCase.js
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.snakeCase = snakeCase;
-const words_function_1 = require("./words.function");
+
+import { words } from "./words.function";
+
 /**
  * Converts `string` to
  * [snake case](https://en.wikipedia.org/wiki/Snake_case).
@@ -26,6 +25,10 @@ const words_function_1 = require("./words.function");
  * snakeCase('foo2bar')
  * // => 'foo_2_bar'
  */
-function snakeCase(string) {
-    return ((0, words_function_1.words)(string.replace(/['\u2019]/g, '')).reduce((result, word, index) => (result + (index ? '_' : '') + word.toLowerCase()), ''));
+export function snakeCase(string: string) {
+  return (
+    (words(string.replace(/['\u2019]/g, '')) as string[]).reduce((result: string, word: string, index: number) => (
+      result + (index ? '_' : '') + word.toLowerCase()
+    ), '')
+  );
 }

package/src/lib/functions/sort-by-created-at.function.ts

@@ -0,0 +1,7 @@
+import { TCreateable } from "../types/createable.type";
+
+export function sortByCreatedAt<TEntity extends TCreateable>(a: TEntity, b: TEntity) {
+    const isLessThan = a.createdAt < b.createdAt;
+
+    return isLessThan ? -1 : 1;
+}

package/src/lib/functions/sort-by-full-name.function.ts

@@ -0,0 +1,6 @@
+import { TNameable } from "../types/nameable.type";
+import { getUserFullName } from "./get-user-full-name.function";
+
+export function sortByFullName<TEntity extends TNameable>(a: TEntity, b: TEntity) {
+    return getUserFullName(a).localeCompare(getUserFullName(b)) || 0;
+}

package/src/lib/functions/sort-by-id.function.ts

@@ -0,0 +1,3 @@
+export function sortById<TEntity extends { id: string }>(a: TEntity, b: TEntity) {
+    return a?.id?.localeCompare(b?.id || '') || 0;
+}

package/src/lib/functions/sort-by-name.function.ts

@@ -0,0 +1,3 @@
+export function sortByName<TEntity extends { name: string }>(a: TEntity, b: TEntity) {
+    return a?.name?.localeCompare(b?.name || '') || 0;
+}

package/src/lib/functions/sort-numbers.function.ts

@@ -0,0 +1,3 @@
+export const sortNumbers = (a: number, b: number) => {
+    return Number(a) < Number(b) ? -1 : 1;
+};

package/src/lib/functions/split-date-range-into-days.function.spec.ts

@@ -0,0 +1,17 @@
+import { splitDateRangeIntoDays } from './split-date-range-into-days.function';
+import { arrangeActAssert } from '../functions/arrange-act-assert.function';
+describe('splitDateRangeIntoDays', () => {
+    it.each([
+        [{ from: '', to: '' }],
+        [{ from: 'asdf', to: '2345' }],
+        [{ from: '2024-01-01', to: '2024-01-01' }],
+        [{ from: '2024-01-01', to: '2024-02-01' }],
+        [{ from: '2025-01-01', to: '' }],
+    ])('given %j, returns an array of days', async (_) => await arrangeActAssert({
+        arrange: () => ({ subject: splitDateRangeIntoDays }),
+        act: ({ subject }) => subject(_),
+        assert: ({ result }) => {
+            expect(result).toMatchSnapshot();
+        }
+    }));
+});

package/src/lib/functions/split-date-range-into-days.function.ts

@@ -0,0 +1,26 @@
+import { MILLIS_PER_DAY } from "../constants/millis-per-day.constant";
+
+const iso8601Regex = /\d{4}-\d{2}-\d{2}/;
+
+export function splitDateRangeIntoDays(_: { from: string, to: string }): string[] {
+    const { from = '', to = '' } = _;
+    const days: Date[] = [];
+
+    if (!from || !to || !iso8601Regex.test(from) || !iso8601Regex.test(to)) {
+        return days as any[];
+    }
+
+    const _from = new Date(from);
+    const _to = new Date(to);
+
+    let current = _from;
+
+    while (current < _to) {
+        days.push(current);
+        current = new Date(+current + MILLIS_PER_DAY);
+    }
+
+    days.push(_to);
+
+    return days.map(day => day.toISOString().split('T')[0]);
+}

package/src/lib/functions/subtract-offset.function.spec.ts

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

package/src/lib/functions/subtract-offset.function.ts

@@ -0,0 +1,14 @@
+import { MILLIS_PER_MINUTE } from '../constants/millis-per-minute.constant';
+import { tryParseDate } from './try-parse-date.function';
+
+export function subtractOffset(input: string | Date | undefined | null): Date | undefined {
+    const parsed = tryParseDate(input);
+
+    if(!parsed) {
+        return;
+    }
+
+    const offset = (parsed).getTimezoneOffset();
+
+    return new Date(parsed.valueOf() - offset * MILLIS_PER_MINUTE);
+}

package/src/lib/functions/to-boolean-string.function.ts

@@ -0,0 +1,3 @@
+export function toBooleanString(val?: boolean) {
+  return (!!(val || false)).toString() as 'true' | 'false';
+}

package/src/lib/functions/to-calendar-date.function.ts

@@ -0,0 +1,11 @@
+import { subtractOffset } from "./subtract-offset.function";
+
+export function toCalendarDate(input: string | Date | undefined | null): string | undefined {
+    const parsed = subtractOffset(input);
+
+    if (!parsed) {
+        return;
+    }
+
+    return parsed?.toISOString().split('T')[0];
+}

package/src/lib/functions/to-csv-string.function.ts

@@ -0,0 +1,3 @@
+export function toCsvString(val?: string[]) {
+  return (val || []).join(',');
+}

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

@@ -1,21 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toDecimalBase = toDecimalBase;
-function toDecimalBase(n, base = 16) {
+export function toDecimalBase(n: string | number, base = 16) {
     const digits = n.toString().split('');
+
     let answer = 0;
+
     digits.reverse().forEach(function (d, i) {
         let actualNumber = Number(d);
+
         if (!actualNumber && actualNumber !== 0) {
             const codeAt = d.charCodeAt(0);
+
             if (codeAt >= 97) {
                 actualNumber = codeAt - 87;
-            }
-            else {
+            } else {
                 actualNumber = codeAt - 55;
             }
         }
+
         answer = answer + actualNumber * Math.pow(base, i);
     });
+
     return answer;
-}
+}

package/src/lib/functions/to-dollars-and-cents.function.spec.ts

@@ -0,0 +1,7 @@
+import { toDollarsAndCents } from './to-dollars-and-cents.function';
+
+describe('toDollarsAndCents', () => {
+    it('worx', () => {
+        expect(toDollarsAndCents(337.33)).toMatchSnapshot();
+    });
+});

package/src/lib/functions/to-dollars-and-cents.function.ts

@@ -0,0 +1,17 @@
+import { removeAlphaChars } from "./remove-alpha-chars.function";
+import { toWords } from "./to-words.function";
+
+export function toDollarsAndCents(input: string | number): string {
+    const number = removeAlphaChars(input);
+    const num = Number(number);
+    const decimal = (Math.round((num % 1) * 100)) / 100;
+    const int = num - decimal;
+
+    const dollars = `${toWords(int)} dollars`;
+
+    if (!decimal) {
+        return dollars;
+    }
+
+    return `${dollars} and ${toWords(decimal * 100)} cents`;
+}

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;
+  }
+}