@onivoro/isomorphic-common 22.0.7 → 24.0.1

package/src/lib/functions/camel-case.function.ts

@@ -0,0 +1,30 @@
+// https://github.com/lodash/lodash/blob/main/src/camelCase.ts
+
+import { toString } from './to-string.function';
+import { upperFirst } from './upper-first.function';
+import { words } from './words.function';
+
+/**
+ * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
+ *
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the camel cased string.
+ * @see lowerCase, kebabCase, snakeCase, startCase, upperCase, upperFirst
+ * @example
+ *
+ * camelCase('Foo Bar')
+ * // => 'fooBar'
+ *
+ * camelCase('--foo-bar--')
+ * // => 'fooBar'
+ *
+ * camelCase('__FOO_BAR__')
+ * // => 'fooBar'
+ */
+export const camelCase = (string: string): string =>
+    (words(toString(string).replace(/['\u2019]/g, '')) as string[]).reduce((result: string, word: string, index: number) => {
+        word = word.toLowerCase();
+        return result + (index ? upperFirst(word) : word);
+    }, '');

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

@@ -0,0 +1,20 @@
+import { chunk } from './chunk.function';
+import { arrangeActAssert } from '../functions/arrange-act-assert.function';
+
+const array = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'];
+
+describe('chunk', () => {
+    it.each([
+        [1],
+        [2],
+        [3],
+        [4],
+        [5],
+    ])('given %j, returns an array of arrays', async (_) => await arrangeActAssert({
+        arrange: () => ({ subject: chunk }),
+        act: ({ subject }) => subject(array, _),
+        assert: ({ result }) => {
+            expect(result).toMatchSnapshot();
+        }
+    }));
+});

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

@@ -0,0 +1,25 @@
+export function chunk<T>(array: T[], numDivisions: number): T[][] {
+    if (numDivisions <= 0) {
+        throw new Error('Number of divisions must be greater than or equal to 0');
+    }
+
+    if (array.length === 0) {
+        return [];
+    }
+
+    const result: T[][] = [];
+    const chunkSize = Math.ceil(array.length / numDivisions);
+
+    for (let i = 0; i < array.length; i += chunkSize) {
+        result.push(array.slice(i, i + chunkSize));
+    }
+
+    while (result.length > numDivisions) {
+        const lastChunk = result.pop();
+        if (lastChunk) {
+            result[result.length - 1].push(...lastChunk);
+        }
+    }
+
+    return result;
+}

package/src/lib/functions/convert-object-to-literal.function.spec.ts

@@ -0,0 +1,16 @@
+import { convertObjectToLiteral } from './convert-object-to-literal.function';
+
+const qty = 337;
+const price = 100;
+const product = 'flux-capacitor';
+
+describe('convertObjectToLiteral', () => {
+  it.each([[(k, v) => `${k}=${v}`, ' AND ', { qty, price, product }]])(
+    'converts an object to a string',
+    (literalFn, delimiter, obj) => {
+      expect(
+        convertObjectToLiteral(literalFn, delimiter, obj)
+      ).toMatchSnapshot();
+    }
+  );
+});

package/src/lib/functions/convert-object-to-literal.function.ts

@@ -0,0 +1,10 @@
+export function convertObjectToLiteral(
+  literalFn: (k: string, v: any) => string,
+  delimiter: string,
+  keyValuePairs: Record<string, any>
+) {
+  return Object.entries(keyValuePairs)
+    .filter(([, v]) => !!v || v === 0 || v === false)
+    .map(([k, v]) => literalFn(k, v?.toString?.()))
+    .join(delimiter);
+}

package/src/lib/functions/format-usd.function.ts

@@ -0,0 +1,4 @@
+export function formatUsd(rawAmount?: number | string) {
+    const amount = Number(rawAmount) || 0;
+    return new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(amount);
+  }

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

@@ -0,0 +1,3 @@
+export function fromBooleanString(value?: string) {
+  return value === 'true';
+}

package/src/lib/functions/from-calendar-date.function.spec.ts

@@ -0,0 +1,11 @@
+import { fromCalendarDate } from './from-calendar-date.function';
+
+describe('fromCalendarDate', () => {
+    describe('GIVEN input is partial or full ISO8601', () => {
+        it.each([
+            '2023-12-23',
+        ])('%j', (input) => {
+            expect(fromCalendarDate(input)).toMatchSnapshot();
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+import { addOffset } from "./add-offset.function";
+
+export function fromCalendarDate(input: string | Date | undefined | null): Date | null {
+    return addOffset(input) || null;
+}

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

@@ -0,0 +1,3 @@
+export function fromCsvString(value?: string) {
+  return value ? value.split(',').map((v) => v.trim()) : [];
+}

package/src/lib/functions/get-date-last-month.function.ts

@@ -0,0 +1,6 @@
+import { MILLIS_PER_DAY } from "../constants/millis-per-day.constant";
+
+export function getDateLastMonth() {
+    const days = new Date().getUTCDate() + 1;
+    return new Date(Date.now() - (MILLIS_PER_DAY * days));
+}

package/src/lib/functions/get-date-range-for-month.function copy.ts

@@ -0,0 +1,8 @@
+import { MILLIS_PER_DAY } from "../constants/millis-per-day.constant";
+
+export function getDateRangeForMonth(year: number, month: number) {
+    const startDate = new Date(+Date.UTC(year, month + -1, 0) + MILLIS_PER_DAY);
+    const endDate = new Date(+Date.UTC(year, month + 0, 0) + MILLIS_PER_DAY);
+
+    return { startDate, endDate };
+}

package/src/lib/functions/get-date-range-for-month.function.ts

@@ -0,0 +1,8 @@
+import { MILLIS_PER_DAY } from "../constants/millis-per-day.constant";
+
+export function getDateRangeForMonth(year: number, month: number) {
+    const startDate = new Date(+Date.UTC(year, month + -1, 0) + MILLIS_PER_DAY);
+    const endDate = new Date(+Date.UTC(year, month + 0, 0) + MILLIS_PER_DAY);
+
+    return { startDate, endDate };
+}

package/src/lib/functions/get-tag.function.ts

@@ -0,0 +1,10 @@
+// https://github.com/lodash/lodash/blob/main/src/.internal/getTag.ts
+
+const toString = Object.prototype.toString
+
+export function getTag(value: any): string {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]'
+    }
+    return toString.call(value)
+}

package/src/lib/functions/get-user-full-name.function.ts

@@ -0,0 +1,5 @@
+import { TNameable } from "../types/nameable.type";
+
+export function getUserFullName(user: TNameable | undefined): string {
+    return `${user?.firstName} ${user?.lastName}`;
+}

package/src/lib/functions/is-symbol.function.ts

@@ -0,0 +1,11 @@
+// https://github.com/lodash/lodash/blob/main/src/isSymbol.ts
+
+import { getTag } from './get-tag.function';
+
+export function isSymbol(value: any): boolean {
+    const type = typeof value;
+    return (
+        type === 'symbol' ||
+        (type === 'object' && value != null && getTag(value) === '[object Symbol]')
+    );
+}

package/src/lib/functions/is-valid-date.function.ts

@@ -0,0 +1,5 @@
+export function isValidDate(dateString: string | Date) {
+    const date = new Date(dateString);
+
+    return (date instanceof Date && !isNaN(date.getTime())) ? date : undefined;
+}

package/src/lib/functions/kebab-case.function.ts

@@ -0,0 +1,5 @@
+import { snakeCase } from "./snake-case.function";
+
+export function kebabCase(string: string) {
+  return snakeCase(string).replace(/_/g, '-');
+}

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

@@ -0,0 +1,11 @@
+export function mapEntitiesToOptions<TEntity extends { name?: string, id: string }>(
+    entities: Record<string, TEntity>,
+    ids: string[],
+    includeBlank = true,
+) {
+    const entityArray = ids?.length ? (ids?.map((value => ({ value, display: entities[value].name || entities[value].id })))) : [];
+
+    return includeBlank
+        ? [{ display: '', value: '' }, ...entityArray]
+        : entityArray;
+}

package/src/lib/functions/map-enum-to-array-of-values.function copy.ts

@@ -0,0 +1,3 @@
+export function mapEnumToArrayOfValues(enumeration: any): any {
+    return Object.entries(enumeration).map(([key, value]) => value) as string[];
+}

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

@@ -0,0 +1,3 @@
+export function mapEnumToArrayOfValues(enumeration: any): any {
+    return Object.entries(enumeration).map(([key, value]) => value) as string[];
+}

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