@onivoro/isomorphic-common 0.2.3 → 0.3.0

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

@@ -1,45 +0,0 @@
-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

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

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

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

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

@@ -1,105 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,70 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,38 +0,0 @@
-// 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/keys-of.type.ts

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

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "$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
-  }
-}