@onivoro/isomorphic-common 0.1.1 → 0.2.1

package/esm/src/lib/functions/to-words.function.js

@@ -0,0 +1,86 @@
+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) {
+    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, words) {
+    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) {
+    return !(typeof value !== 'number' || value !== value || value === Infinity || value === -Infinity);
+}
+function isSafeNumber(value) {
+    return typeof value === 'number' && Math.abs(value) <= MAX_SAFE_INTEGER;
+}

package/esm/src/lib/functions/to-words.function.spec.js

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

package/esm/src/lib/functions/try-parse-date.function.js

@@ -0,0 +1,13 @@
+export function tryParseDate(input) {
+    if (!input) {
+        return;
+    }
+    if (input instanceof Date) {
+        return input;
+    }
+    const date = new Date(input);
+    if (date == 'Invalid Date') {
+        return;
+    }
+    return date;
+}

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

@@ -0,0 +1,11 @@
+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/esm/src/lib/functions/unicode-words.const.js

@@ -0,0 +1,65 @@
+// 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/esm/src/lib/functions/upper-first.function.js

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

package/esm/src/lib/functions/upper-first.function.spec.js

@@ -0,0 +1,14 @@
+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/esm/src/lib/functions/words.function.js

@@ -0,0 +1,31 @@
+// 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, pattern) {
+    if (pattern === undefined) {
+        const result = hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+        return result || [];
+    }
+    return string.match(pattern) || [];
+}

package/esm/src/lib/interfaces/axios-wrapped-nest-exception.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/src/lib/interfaces/entity-provider.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/src/lib/interfaces/keys-of.type.js

@@ -0,0 +1 @@
+export {};

package/jest.config.ts

@@ -0,0 +1,17 @@
+/* eslint-disable */
+export default {
+  displayName: 'isomorphic-common',
+  preset: '../../jest.preset.js',
+  globals: {},
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]sx?$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+      },
+    ],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/libs/isomorphic-common',
+};

package/package.json

@@ -1,12 +1,22 @@
 {
   "name": "@onivoro/isomorphic-common",
-  "version": "0.1.1",
-  "main": "index.cjs.js",
-  "module": "index.cjs.js",
+  "version": "0.2.1",
+  "module": "esm/index.js",
+  "type": "module",
+  "main": "cjs/index.js",
+  "scripts": {
+    "esb": "npx esbuild src/index.ts --bundle --platform=node --target=node16.20.2 > dist/index.cjs.js",
+    "ts": "npx tsc --module es2022 --outDir esm/ && echo '{\"type\": \"module\"}' > esm/package.json",
+    "push": "npm run ts && cp package.json dist && npm publish --access public"
+  },
   "exports": {
     ".": {
-      "import": "./index.cjs.js",
-      "require": "./index.cjs.js"
+      "require": "./cjs/index.js",
+      "import": "./esm/index.js"
     }
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "typescript": "^5.3.3"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+export * from './lib/constants/millis-per-day.constant';
+export * from './lib/constants/millis-per-hour.constant';
+export * from './lib/constants/millis-per-minute.constant';
+
+export * from './lib/functions/add-offset.function';
+export * from './lib/functions/camel-case.function';
+export * from './lib/functions/convert-object-to-literal.function';
+export * from './lib/functions/from-boolean-string.function';
+export * from './lib/functions/from-calendar-date.function';
+export * from './lib/functions/from-csv-string.function';
+export * from './lib/functions/kebab-case.function';
+export * from './lib/functions/parse-bool.function';
+export * from './lib/functions/properties-to-array.function';
+export * from './lib/functions/sanitize-filename.function';
+export * from './lib/functions/snake-case.function';
+export * from './lib/functions/subtract-offset.function';
+export * from './lib/functions/to-boolean-string.function';
+export * from './lib/functions/to-calendar-date.function';
+export * from './lib/functions/to-csv-string.function';
+export * from './lib/functions/to-decimal-base.function';
+export * from './lib/functions/to-dollars-and-cents.function';
+export * from './lib/functions/to-unique-array.function';
+export * from './lib/functions/to-words.function';
+export * from './lib/functions/try-parse-date.function';
+export * from './lib/functions/unicode-words.const';
+export * from './lib/functions/upper-first.function';
+export * from './lib/functions/words.function';
+
+export * from './lib/interfaces/axios-wrapped-nest-exception.interface';
+export * from './lib/interfaces/entity-provider.interface';
+export * from './lib/interfaces/keys-of.type';

package/src/lib/constants/millis-per-day.constant.ts

@@ -0,0 +1,3 @@
+import { MILLIS_PER_HOUR } from "./millis-per-hour.constant";
+
+export const MILLIS_PER_DAY = MILLIS_PER_HOUR * 24;

package/src/lib/constants/millis-per-hour.constant.ts

@@ -0,0 +1,3 @@
+import { MILLIS_PER_MINUTE } from "./millis-per-minute.constant";
+
+export const MILLIS_PER_HOUR = MILLIS_PER_MINUTE * 60;

package/src/lib/constants/millis-per-minute.constant.ts

@@ -0,0 +1 @@
+export const MILLIS_PER_MINUTE = 1000 * 60;

package/src/lib/functions/__snapshots__/add-offset.function.spec.ts.snap

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`addOffset GIVEN input is partial or full ISO8601 "2023-12-23" 1`] = `2023-12-23T06:00:00.000Z`;
+
+exports[`addOffset GIVEN input is partial or full ISO8601 "2023-12-23T00:00:00.000" 1`] = `2023-12-23T12:00:00.000Z`;

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

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`/Users/lee/github.com/onivoro/onivoro/libs/isomorphic-common/src/lib/functions/convert-object-to-literal.function.spec.ts converts an object to a string 1`] = `"qty=337 AND price=100 AND product=flux-capacitor"`;

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

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`fromCalendarDate GIVEN input is partial or full ISO8601 "2023-12-23" 1`] = `2023-12-22T12:00:00.000Z`;

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

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`subtractOffset GIVEN input is partial or full ISO8601 "2023-12-23" 1`] = `2023-12-22T18:00:00.000Z`;
+
+exports[`subtractOffset GIVEN input is partial or full ISO8601 "2023-12-23T00:00:00.000" 1`] = `2023-12-23T00:00:00.000Z`;

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

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`toDollarsAndCents worx 1`] = `"three hundred thirty-seven dollars and thirty-three cents"`;

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

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`toWords worx 1`] = `"three hundred thirty-seven"`;

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

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`tryParseDate GIVEN input is partial or full ISO8601 "2023-12-23" 1`] = `2023-12-23T00:00:00.000Z`;
+
+exports[`tryParseDate GIVEN input is partial or full ISO8601 "2023-12-23T00:00:00.000" 1`] = `2023-12-23T06:00:00.000Z`;

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

@@ -0,0 +1,13 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`upperFirst GIVEN "XCVB", does what u expect 1`] = `"Xcvb"`;
+
+exports[`upperFirst GIVEN "asdf", does what u expect 1`] = `"Asdf"`;
+
+exports[`upperFirst GIVEN falsey input 0, does what u expect 1`] = `0`;
+
+exports[`upperFirst GIVEN falsey input false, does what u expect 1`] = `false`;
+
+exports[`upperFirst GIVEN falsey input null, does what u expect 1`] = `null`;
+
+exports[`upperFirst GIVEN falsey input undefined, does what u expect 1`] = `undefined`;

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

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

package/src/lib/functions/add-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 addOffset(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/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, '')).reduce((result: string, word: string, index: number) => {
+        word = word.toLowerCase();
+        return result + (index ? upperFirst(word) : word);
+    }, '');

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(__filename, () => {
+  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/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-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/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/kebab-case.function.ts

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

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) {
+    const isObject = val =>
+        val && typeof val === 'object' && !Array.isArray(val);
+
+    const addDelimiter = (a, b) =>
+        a ? `${a}.${b}` : b;
+
+    const paths = (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/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/snake-case.function.ts

@@ -0,0 +1,34 @@
+// source https://github.com/lodash/lodash/blob/master/snakeCase.js
+
+import { words } from "./words.function";
+
+/**
+ * Converts `string` to
+ * [snake case](https://en.wikipedia.org/wiki/Snake_case).
+ *
+ * @since 3.0.0
+ * @category String
+ * @param {string} [string=''] The string to convert.
+ * @returns {string} Returns the snake cased string.
+ * @see camelCase, lowerCase, kebabCase, startCase, upperCase, upperFirst
+ * @example
+ *
+ * snakeCase('Foo Bar')
+ * // => 'foo_bar'
+ *
+ * snakeCase('fooBar')
+ * // => 'foo_bar'
+ *
+ * snakeCase('--FOO-BAR--')
+ * // => 'foo_bar'
+ *
+ * snakeCase('foo2bar')
+ * // => 'foo_2_bar'
+ */
+export function snakeCase(string) {
+  return (
+    words(string.replace(/['\u2019]/g, '')).reduce((result, word, index) => (
+      result + (index ? '_' : '') + word.toLowerCase()
+    ), '')
+  );
+}

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