@onivoro/isomorphic-common 0.1.1 → 0.2.1

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/src/lib/functions/to-decimal-base.function.ts

@@ -0,0 +1,23 @@
+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 {
+                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,15 @@
+import { toWords } from "./to-words.function";
+
+export function toDollarsAndCents(number: any): string {
+    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/src/lib/functions/to-string.function.ts

@@ -0,0 +1,25 @@
+// https://github.com/lodash/lodash/blob/main/src/toString.ts
+
+import { isSymbol } from './is-symbol.function';
+
+/** Used as references for various `Number` constants. */
+const INFINITY = 1 / 0;
+
+export function toString(value: any): string {
+    if (value == null) {
+        return '';
+    }
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // Recursively convert values (susceptible to call stack limits).
+        return `${value.map((other) => (other == null ? other : toString(other)))}`;
+    }
+    if (isSymbol(value)) {
+        return value.toString();
+    }
+    const result = `${value}`;
+    return result === '0' && 1 / value === -INFINITY ? '-0' : result;
+}

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/src/lib/functions/to-words.function.ts

@@ -0,0 +1,105 @@
+const MAX_SAFE_INTEGER = 9007199254740991;
+
+const TEN = 10;
+const ONE_HUNDRED = 100;
+const ONE_THOUSAND = 1000;
+const ONE_MILLION = 1000000;
+const ONE_BILLION = 1000000000;
+const ONE_TRILLION = 1000000000000;
+const ONE_QUADRILLION = 1000000000000000;
+const MAX = MAX_SAFE_INTEGER + 1;
+const LESS_THAN_TWENTY = [
+    'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
+    'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
+];
+const TENTHS_LESS_THAN_HUNDRED = [
+    'zero', 'ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
+];
+
+export function toWords(number: any): string {
+    let words;
+    const num = parseInt(number, 10);
+
+    if (!isFinite(num)) {
+        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.'
+        );
+    }
+
+    words = generateWords(num);
+
+    return 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) {
+        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) {
+        remainder = number % ONE_HUNDRED;
+        word = generateWords(Math.floor(number / ONE_HUNDRED)) + ' hundred';
+
+    } else if (number < ONE_MILLION) {
+        remainder = number % ONE_THOUSAND;
+        word = generateWords(Math.floor(number / ONE_THOUSAND)) + ' thousand,';
+
+    } else if (number < ONE_BILLION) {
+        remainder = number % ONE_MILLION;
+        word = generateWords(Math.floor(number / ONE_MILLION)) + ' million,';
+
+    } else if (number < ONE_TRILLION) {
+        remainder = number % ONE_BILLION;
+        word = generateWords(Math.floor(number / ONE_BILLION)) + ' billion,';
+
+    } else if (number < ONE_QUADRILLION) {
+        remainder = number % ONE_TRILLION;
+        word = generateWords(Math.floor(number / ONE_TRILLION)) + ' trillion,';
+
+    } 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: any) {
+    return !(typeof value !== 'number' || value !== value || value === Infinity || value === -Infinity);
+}
+
+function isSafeNumber(value: any) {
+    return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
+}

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) {
+  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) {
+  if (!string) {
+    return string;
+  }
+
+  return string
+    .split('')
+    .map((curr: string, i: number) => curr[!i ? 'toUpperCase' : 'toLowerCase']())
+    .join('');
+}

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) {
+  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/interfaces/axios-wrapped-nest-exception.interface.ts

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

package/src/lib/interfaces/entity-provider.interface.ts

@@ -0,0 +1,9 @@
+export interface IEntityProvider<TEntity, TFindOneOptions, TFindManyOptions, TFindOptionsWhere, TQueryDeepPartialEntity> {
+    getOne: (options: TFindOneOptions) => Promise<TEntity>;
+    getMany: (options: TFindManyOptions) => Promise<TEntity[]>;
+    postOne: (body: Partial<TEntity>) => Promise<TEntity>;
+    postMany: (body: Partial<TEntity[]>) => Promise<TEntity[]>;
+    delete: (options: TFindOptionsWhere) => Promise<void>;
+    put: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
+    patch: (options: TFindOptionsWhere, body: TQueryDeepPartialEntity) => Promise<void>;
+}

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

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

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "display": "Node 16",
+  "_version": "16.1.0",
+
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "module": "NodeNext",
+    "target": "es2021",
+
+    "strict": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}