@voiceflow/common 8.2.8 → 8.3.0

package/package.json

@@ -1,66 +1,64 @@
 {
   "name": "@voiceflow/common",
+  "version": "8.3.0",
   "description": "Junk drawer of utility functions",
-  "version": "8.2.8",
-  "author": "Voiceflow",
-  "bugs": {
-    "url": "https://github.com/voiceflow/libs/issues"
-  },
-  "dependencies": {
-    "@types/crypto-js": "^4.0.2",
-    "@types/shallowequal": "^1.1.1",
-    "bson-objectid": "^2.0.1",
-    "crypto-js": "^4.2.0",
-    "cuid": "^2.1.8",
-    "dayjs": "1.10.7",
-    "lodash": "^4.17.21",
-    "murmurhash-wasm": "^1.3.0",
-    "number-to-words": "^1.2.4",
-    "shallowequal": "^1.1.0",
-    "typescript-fsa": "3.0.0"
-  },
-  "devDependencies": {
-    "@types/lodash": "^4.14.176",
-    "@types/number-to-words": "1.2.0",
-    "@voiceflow-meta/jest-config": "1.0.2",
-    "@voiceflow-meta/typescript-config": "1.0.2"
-  },
-  "files": [
-    "build"
-  ],
-  "homepage": "https://github.com/voiceflow/libs#readme",
   "keywords": [
     "voiceflow"
   ],
-  "license": "ISC",
-  "main": "build/cjs/index.js",
-  "module": "build/esm/index.js",
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/voiceflow/libs#readme",
+  "bugs": {
+    "url": "https://github.com/voiceflow/libs/issues"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voiceflow/libs.git"
   },
+  "license": "ISC",
+  "author": "Voiceflow",
+  "main": "build/cjs/index.js",
+  "module": "build/esm/index.js",
+  "types": "build/cjs/index.d.ts",
+  "files": [
+    "build"
+  ],
   "scripts": {
-    "build": "yarn clean && yarn build:cjs && yarn build:esm",
-    "build:cjs": "yarn g:tsc -p tsconfig.build.cjs.json && yarn g:tsc-alias -p tsconfig.build.cjs.json && yarn postbuild:cjs",
-    "build:esm": "yarn g:tsc -p tsconfig.build.esm.json && yarn g:tsc-alias -p tsconfig.build.esm.json && yarn postbuild:esm",
+    "build": "yarn g:turbo run build:cmd --filter=@voiceflow/common...",
+    "build:cjs": "yarn g:build:pkg cjs",
+    "build:cmd": "yarn g:run-p build:cjs build:esm",
+    "build:esm": "yarn g:build:pkg esm",
     "clean": "yarn g:rimraf build",
-    "commit": "cz",
-    "lint": "yarn g:eslint '**/*.{js,ts}'",
-    "lint:fix": "yarn lint --fix",
-    "lint:quiet": "yarn lint --quiet",
-    "lint:report": "yarn g:eslint-output --quiet '**/*.{js,ts}'",
-    "postbuild:cjs": "touch build/cjs/package.json && echo '{ \"type\": \"commonjs\" }' > build/cjs/package.json",
-    "postbuild:esm": "touch build/esm/package.json && echo '{ \"type\": \"module\" }' > build/esm/package.json",
-    "tdd": "yarn test:unit --watch",
-    "test:dependencies": "yarn g:depcheck",
-    "test:unit": "yarn g:jest"
+    "lint": "yarn g:run-p -c lint:eslint lint:prettier",
+    "lint:eslint": "yarn g:eslint",
+    "lint:fix": "yarn g:run-p -c \"lint:eslint --fix\" \"lint:prettier --write\"",
+    "lint:prettier": "yarn g:prettier --check",
+    "tdd": "yarn g:vitest",
+    "test": "yarn g:run-p -c test:dependencies test:types test:unit",
+    "test:dependencies": "yarn g:depcruise",
+    "test:types": "yarn g:tsc --noEmit",
+    "test:unit": "yarn g:vitest run --coverage"
+  },
+  "dependencies": {
+    "@types/crypto-js": "4.1.0",
+    "@types/shallowequal": "1.1.1",
+    "bson-objectid": "2.0.2",
+    "crypto-js": "4.2.0",
+    "cuid": "2.1.8",
+    "dayjs": "1.10.7",
+    "lodash": "4.17.21",
+    "murmurhash-wasm": "1.3.0",
+    "number-to-words": "1.2.4",
+    "shallowequal": "1.1.0",
+    "typescript-fsa": "3.0.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.14.178",
+    "@types/number-to-words": "1.2.0"
   },
-  "types": "build/cjs/index.d.ts",
   "volta": {
     "extends": "../../package.json"
   },
-  "gitHead": "14334e394022769620436e607881f0e364ebd81f"
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "82c3c81b9012f5e64c4bec3cd031af220ad26572"
 }

package/build/cjs/crypto/hex2abc.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=hex2abc.test.d.ts.map

package/build/cjs/crypto/hex2abc.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hex2abc.test.d.ts","sourceRoot":"","sources":["../../../src/crypto/hex2abc.test.ts"],"names":[],"mappings":""}

package/build/cjs/crypto/hex2abc.test.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hex2abc_1 = require("./hex2abc");
-describe('hex2abc()', () => {
-    it('works', () => {
-        expect((0, hex2abc_1.hex2abc)('abcdef')).toBe('abcdef');
-        expect((0, hex2abc_1.hex2abc)('0123456789')).toBe('ghijklmnop');
-    });
-    it('works with 0x prefixes', () => {
-        expect((0, hex2abc_1.hex2abc)('0xabc123')).toBe('gxabchij');
-    });
-});

package/build/cjs/crypto/murmurhash.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=murmurhash.test.d.ts.map

package/build/cjs/crypto/murmurhash.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"murmurhash.test.d.ts","sourceRoot":"","sources":["../../../src/crypto/murmurhash.test.ts"],"names":[],"mappings":""}

package/build/cjs/crypto/murmurhash.test.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const murmurhash_1 = require("./murmurhash");
-// for second test check (4 byte chunk)
-// const buf_left = Buffer.of(0xff, 0xff, 0xff, 0xff);
-// const buf_right = Buffer.of(0x76, 0x29, 0x3b, 0x50);
-// for third test check (correct endian order)
-// const buf_left_two = Buffer.of(0x21, 0x43, 0x65, 0x87);
-// const buf_right_two = Buffer.of(0xf5, 0x5b, 0x51, 0x6b);
-describe('hash()', () => {
-    it('return a 32-bit hash resulting from the murmurhash3 algorithm', () => {
-        expect(murmurhash_1.MurmurHash.hash('hello', 0)).toBe('lokkdakm');
-        expect(murmurhash_1.MurmurHash.hash('hello world', 0)).toBe('kkehkpgl');
-        expect(murmurhash_1.MurmurHash.hash('helloworld', 0)).toBe('holkilfm');
-        expect(murmurhash_1.MurmurHash.hash('HELLOWORLD', 0)).toBe('dohkopda');
-        expect(murmurhash_1.MurmurHash.hash('', 0)).toBe('g'); // not sure why '0000 0000' fails as a test
-        expect(murmurhash_1.MurmurHash.hash('abc', 0)).toBe('bjddpjfa');
-        expect(murmurhash_1.MurmurHash.hash('ABC', 0)).toBe('kjchcljl');
-        // from https://github.com/jonahsnider/murmurhash-wasm/blob/main/test/murmur-hash3/hash-32.test.ts
-        // expect(MurmurHash.hash(buf_left.toString('hex'), 0)).to.eql(buf_right.toString('hex'));
-        // expect(MurmurHash.hash(buf_left_two.toString('hex'), 0)).to.eql(buf_right_two.toString('hex'));
-    });
-});

package/build/cjs/utils/__fixtures__/name.json

@@ -1,64 +0,0 @@
-{
-    "slots": [
-        {
-            "key": "4i3h3mmi",
-            "name": "slotmans",
-            "type": {
-                "value": "custom"
-            },
-            "color": "#4F9ED1",
-            "inputs": ["tyler", "john", "scott", "michael", "william", "andy", "peter", "frank", "igor", "steven", "jessica"]
-        }
-    ],
-    "intents": [
-        {
-            "key": "3sb53sup",
-            "name": "name_intent",
-            "slots": [
-                {
-                    "id": "4i3h3mmi",
-                    "dialog": {
-                        "prompt": [
-                            {
-                                "text": "",
-                                "slots": []
-                            }
-                        ],
-                        "confirm": [
-                            {
-                                "text": "",
-                                "slots": []
-                            }
-                        ],
-                        "utterances": [
-                            {
-                                "text": "{{[name].4i3h3mmi}} ",
-                                "slots": ["4i3h3mmi"]
-                            }
-                        ],
-                        "confirmEnabled": false
-                    },
-                    "required": false
-                }
-            ],
-            "inputs": [
-                {
-                    "text": "It's {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "I'm {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "{{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                },
-                {
-                    "text": "my name is {{[slotmans].4i3h3mmi}}",
-                    "slots": ["4i3h3mmi"]
-                }
-            ]
-        }
-    ]
-}

package/build/cjs/utils/array.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=array.test.d.ts.map

package/build/cjs/utils/array.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.test.d.ts","sourceRoot":"","sources":["../../../src/utils/array.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/array.test.js

@@ -1,237 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const array_1 = require("./array");
-describe('Utils | array', () => {
-    describe('unique()', () => {
-        it('return an array containing one instance of each value from the array passed to it', () => {
-            expect((0, array_1.unique)([1, 1, 2, 0, 1, 4, 3, 1, 9, 9, 2])).toEqual([1, 2, 0, 4, 3, 9]);
-        });
-    });
-    describe('without()', () => {
-        it('return an array containing every value from the array passed to it except for the value at the provided index', () => {
-            expect((0, array_1.without)([], -1)).toEqual([]);
-            expect((0, array_1.without)([], 0)).toEqual([]);
-            expect((0, array_1.without)(['a', 'b', 'c', 'd'], -1)).toEqual(['a', 'b', 'c', 'd']);
-            expect((0, array_1.without)(['a', 'b', 'c', 'd'], 0)).toEqual(['b', 'c', 'd']);
-            expect((0, array_1.without)(['a', 'b', 'c', 'd'], 2)).toEqual(['a', 'b', 'd']);
-            expect((0, array_1.without)(['a', 'b', 'c', 'd'], 4)).toEqual(['a', 'b', 'c', 'd']);
-        });
-    });
-    describe('withoutValue()', () => {
-        it('return an array containing every value from the array passed to it except for first value that is directly equal to the provided value', () => {
-            expect((0, array_1.withoutValue)([], 'd')).toEqual([]);
-            expect((0, array_1.withoutValue)(['a', 'b', 'c', 'd'], 'g')).toEqual(['a', 'b', 'c', 'd']);
-            expect((0, array_1.withoutValue)(['a', 'b', 'c', 'd'], 'b')).toEqual(['a', 'c', 'd']);
-        });
-    });
-    describe('withoutValues()', () => {
-        it('return an array containing every value from the array passed to it except for values from a second provided array', () => {
-            expect((0, array_1.withoutValues)(['a', 'b', 'c', 'd'], [])).toEqual(['a', 'b', 'c', 'd']);
-            expect((0, array_1.withoutValues)([], ['g', 'c', 'b', 'e'])).toEqual([]);
-            expect((0, array_1.withoutValues)(['a', 'b', 'c', 'd'], ['g', 'c', 'b', 5])).toEqual(['a', 'd']);
-            expect((0, array_1.withoutValues)(['a', 'b', 'c', 'd'], ['g', 'e'])).toEqual(['a', 'b', 'c', 'd']);
-        });
-    });
-    describe('replace()', () => {
-        it('return an array where the value at the provided index has been replaced with the new value', () => {
-            expect((0, array_1.insert)([], 8, 'f')).toEqual(['f']);
-            expect((0, array_1.replace)(['a', 'b', 'c', 'd'], -1, 'f')).toEqual(['a', 'b', 'c', 'd']);
-            expect((0, array_1.replace)(['a', 'b', 'c', 'd'], 8, 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-            expect((0, array_1.replace)(['a', 'b', 'c', 'd'], 2, 'f')).toEqual(['a', 'b', 'f', 'd']);
-        });
-    });
-    describe('insert()', () => {
-        it('return an array where the provided value has been inserted at the provided index', () => {
-            expect((0, array_1.insert)([], 8, 'f')).toEqual(['f']);
-            expect((0, array_1.insert)(['a', 'b', 'c', 'd'], -1, 'f')).toEqual(['f', 'a', 'b', 'c', 'd']);
-            expect((0, array_1.insert)(['a', 'b', 'c', 'd'], 2, 'f')).toEqual(['a', 'b', 'f', 'c', 'd']);
-            expect((0, array_1.insert)(['a', 'b', 'c', 'd'], 8, 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-        });
-    });
-    describe('insertAll()', () => {
-        it('return an array where the provided array of values has been inserted at the provided index', () => {
-            expect((0, array_1.insertAll)([], 8, ['f', 'g', 'h'])).toEqual(['f', 'g', 'h']);
-            expect((0, array_1.insertAll)(['a', 'b', 'c', 'd'], -1, ['f', 'g', 'h'])).toEqual(['f', 'g', 'h', 'a', 'b', 'c', 'd']);
-            expect((0, array_1.insertAll)(['a', 'b', 'c', 'd'], 2, ['f', 'g', 'h'])).toEqual(['a', 'b', 'f', 'g', 'h', 'c', 'd']);
-            expect((0, array_1.insertAll)(['a', 'b', 'c', 'd'], 8, ['f', 'g', 'h'])).toEqual(['a', 'b', 'c', 'd', 'f', 'g', 'h']);
-        });
-    });
-    describe('append()', () => {
-        it('return an array with the provided value appended, does not add if already exists', () => {
-            expect((0, array_1.append)([], 'f')).toEqual(['f']);
-            expect((0, array_1.append)(['a', 'b', 'c', 'd'], 'f')).toEqual(['a', 'b', 'c', 'd', 'f']);
-            expect((0, array_1.append)(['a', 'b', 'c'], 'c')).toEqual(['a', 'b', 'c']);
-        });
-    });
-    describe('toggleMembership()', () => {
-        it('return an array with the provided value included or excluded, the opposite of the current state', () => {
-            expect((0, array_1.toggleMembership)(['a', 'b', 'c'], 'f')).toEqual(['a', 'b', 'c', 'f']);
-            expect((0, array_1.toggleMembership)(['a', 'b', 'c', 'f'], 'f')).toEqual(['a', 'b', 'c']);
-        });
-    });
-    describe('head()', () => {
-        it('return the item at the head of the array and an array containing the remaining elements as a tuple pair', () => {
-            expect((0, array_1.head)(['a', 'b', 'c', 'd'])).toEqual(['a', ['b', 'c', 'd']]);
-            expect((0, array_1.head)(['a'])).toEqual(['a', []]);
-            expect((0, array_1.head)([])).toEqual([undefined, []]);
-        });
-    });
-    describe('tail()', () => {
-        it('return the item at the end of the array and an array containing the remaining elements as a tuple pair', () => {
-            expect((0, array_1.tail)(['a', 'b', 'c', 'd'])).toEqual([['a', 'b', 'c'], 'd']);
-            expect((0, array_1.tail)(['a'])).toEqual([[], 'a']);
-            expect((0, array_1.tail)([])).toEqual([[], undefined]);
-        });
-    });
-    describe('filterOutNullish()', () => {
-        it('filters nullish values', () => {
-            expect((0, array_1.filterOutNullish)([undefined, 1, null])).toEqual([1]);
-            expect((0, array_1.filterOutNullish)([undefined, null])).toEqual([]);
-            expect((0, array_1.filterOutNullish)([1])).toEqual([1]);
-        });
-    });
-    describe('isNullish()', () => {
-        it('works', () => {
-            expect((0, array_1.isNullish)(null)).toBe(true);
-            expect((0, array_1.isNullish)(undefined)).toBe(true);
-            expect((0, array_1.isNullish)(0)).toBe(false);
-        });
-    });
-    describe('isNotNullish()', () => {
-        it('works', () => {
-            expect((0, array_1.isNotNullish)(null)).toBe(false);
-            expect((0, array_1.isNotNullish)(undefined)).toBe(false);
-            expect((0, array_1.isNotNullish)(0)).toBe(true);
-        });
-    });
-    describe('toArray()', () => {
-        it('works with arrays', () => {
-            const value = [1];
-            expect((0, array_1.toArray)(value)).toEqual([1]);
-        });
-        it('works with non-arrays', () => {
-            const value = 1;
-            expect((0, array_1.toArray)(value)).toEqual([1]);
-        });
-    });
-    describe('reorder()', () => {
-        it('should do nothing if from index goes outside array', () => {
-            const array = [1, 2, 3];
-            expect((0, array_1.reorder)(array, -1, 1)).toEqual(array);
-            expect((0, array_1.reorder)(array, 3, 1)).toEqual(array);
-        });
-        it('should set as first item if toIndex is zero or lower than 0', () => {
-            const array = [1, 2, 3];
-            expect((0, array_1.reorder)(array, 2, -1)).toEqual([3, 1, 2]);
-            expect((0, array_1.reorder)(array, 2, 0)).toEqual([3, 1, 2]);
-        });
-        it('should set as last item if toIndex is the last or greater than last', () => {
-            const array = [1, 2, 3];
-            expect((0, array_1.reorder)(array, 0, 2)).toEqual([2, 3, 1]);
-            expect((0, array_1.reorder)(array, 0, 3)).toEqual([2, 3, 1]);
-        });
-        it('should reorder moving forward or backward', () => {
-            const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-            expect((0, array_1.reorder)(array, 1, 2)).toEqual([1, 3, 2, 4, 5, 6, 7, 8, 9, 10]);
-            expect((0, array_1.reorder)(array, 2, 3)).toEqual([1, 2, 4, 3, 5, 6, 7, 8, 9, 10]);
-            expect((0, array_1.reorder)(array, 2, 8)).toEqual([1, 2, 4, 5, 6, 7, 8, 9, 3, 10]);
-            expect((0, array_1.reorder)(array, 8, 1)).toEqual([1, 9, 2, 3, 4, 5, 6, 7, 8, 10]);
-            expect((0, array_1.reorder)(array, 7, 2)).toEqual([1, 2, 8, 3, 4, 5, 6, 7, 9, 10]);
-        });
-    });
-    describe('separate()', () => {
-        it('separates items that pass and fail a predicate', () => {
-            const [passes, fails] = (0, array_1.separate)([20, 1, -3, 15, 8, 23, 40, 3], (x) => x > 10);
-            expect(passes).toEqual([20, 15, 23, 40]);
-            expect(fails).toEqual([1, -3, 8, 3]);
-        });
-    });
-    describe('createEntries()', () => {
-        it('creates entries by extracting a key for each item in an array', () => {
-            const entries = (0, array_1.createEntries)([{ index: 1 }, { index: 3 }, { index: 5 }], ({ index }) => String(index));
-            expect(entries).toEqual([
-                ['1', { index: 1 }],
-                ['3', { index: 3 }],
-                ['5', { index: 5 }],
-            ]);
-        });
-    });
-    describe('createMap()', () => {
-        it('creates object by extracting a key for each item in an array', () => {
-            const obj = (0, array_1.createMap)([{ index: 1 }, { index: 3 }, { index: 5 }], ({ index }) => String(index));
-            expect(obj).toEqual({
-                1: { index: 1 },
-                3: { index: 3 },
-                5: { index: 5 },
-            });
-        });
-    });
-    describe('findUnion()', () => {
-        it('finds the overlap between two lists', () => {
-            const { lhsOnly, rhsOnly, union } = (0, array_1.findUnion)([20, 1, -3, 15], [1, 8, 23, -3, 40, 3]);
-            expect(lhsOnly).toEqual([20, 15]);
-            expect(rhsOnly).toEqual([8, 23, 40, 3]);
-            expect(union).toEqual([1, -3]);
-        });
-    });
-    describe('diff()', () => {
-        it('finds items that only occur in one of two lists', () => {
-            expect((0, array_1.diff)([20, 1, -3, 15], [1, 8, 23, -3, 40, 3])).toEqual([20, 15, 8, 23, 40, 3]);
-        });
-    });
-    describe('hasIdenticalMembers()', () => {
-        it('returns false if lists have different lengths', () => {
-            expect((0, array_1.hasIdenticalMembers)([1, 2, 3], [3, 3, 2, 2, 1])).toBe(false);
-        });
-        it('returns false if either list has a unique member', () => {
-            expect((0, array_1.hasIdenticalMembers)([1, 2, 3], [2, 3])).toBe(false);
-        });
-        it('returns true if both lists contain the same members', () => {
-            expect((0, array_1.hasIdenticalMembers)([1, 2, 3], [3, 1, 2])).toBe(true);
-        });
-        it('returns true if both lists are empty', () => {
-            expect((0, array_1.hasIdenticalMembers)([], [])).toBe(true);
-        });
-    });
-    describe('filterAndGetLastRemovedValue()', () => {
-        it('returns the last item which did not pass the filter predicate', () => {
-            expect((0, array_1.filterAndGetLastRemovedValue)([1, 2, 3], () => true)).toEqual([[1, 2, 3], null]);
-            expect((0, array_1.filterAndGetLastRemovedValue)([], () => false)).toEqual([[], null]);
-            expect((0, array_1.filterAndGetLastRemovedValue)([1, 2, 3], (x) => x !== 2)).toEqual([[1, 3], 2]);
-        });
-    });
-    describe('mergeByIdentifier()', () => {
-        it('test', () => {
-            const array1 = [
-                {
-                    key: 1,
-                    value: [1, 2],
-                },
-            ];
-            const array2 = [
-                {
-                    key: 1,
-                    value: [3],
-                },
-                {
-                    key: 2,
-                    value: [4, 5],
-                },
-            ];
-            const result = (0, array_1.mergeByIdentifier)(array1, array2, (x) => x.key.toString(), (a, b) => ({
-                ...a,
-                value: [...a.value, ...b.value],
-            }));
-            expect(result).toEqual([
-                {
-                    key: 1,
-                    value: [1, 2, 3],
-                },
-                {
-                    key: 2,
-                    value: [4, 5],
-                },
-            ]);
-        });
-    });
-});

package/build/cjs/utils/email.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=email.test.d.ts.map

package/build/cjs/utils/email.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"email.test.d.ts","sourceRoot":"","sources":["../../../src/utils/email.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/email.test.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const emails_1 = require("./emails");
-describe('Utils | email', () => {
-    describe('isValid()', () => {
-        it('should be valid', () => {
-            const validEmails = ['joe.doe@test.com', 'john.-last@sub.domain.com', 'test+@voiceflow.com', 't-est+34@voice-flow.com'];
-            validEmails.forEach((email) => expect((0, emails_1.isValidEmail)(email)).toBe(true));
-        });
-        it('should be invalid', () => {
-            const invalidEmails = ['joe@.com', 'joe@', '@voiceflow.com', '', 'voiceflow.com'];
-            invalidEmails.forEach((email) => expect((0, emails_1.isValidEmail)(email)).toBe(false));
-        });
-    });
-    describe('getEmailDomain()', () => {
-        it('works', () => {
-            expect((0, emails_1.getEmailDomain)('test@voiceflow.com')).toBe('voiceflow.com');
-            expect((0, emails_1.getEmailDomain)('')).toBe('');
-            expect((0, emails_1.getEmailDomain)('totally@invalid@voiceflow.com')).toBe('voiceflow.com');
-        });
-    });
-});

package/build/cjs/utils/functional.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=functional.test.d.ts.map

package/build/cjs/utils/functional.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"functional.test.d.ts","sourceRoot":"","sources":["../../../src/utils/functional.test.ts"],"names":[],"mappings":""}

package/build/cjs/utils/functional.test.js

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const functional_1 = require("./functional");
-const promise_1 = require("./promise");
-describe('Utils | functional', () => {
-    describe('isFunction()', () => {
-        it('checks if the provided argument is a function', () => {
-            expect((0, functional_1.isFunction)(null)).toBe(false);
-            expect((0, functional_1.isFunction)({})).toBe(false);
-            expect((0, functional_1.isFunction)(() => null)).toBe(true);
-        });
-    });
-    describe('compose()', () => {
-        it('composes from right-to-left', () => {
-            const add = (x) => x + 1;
-            const div = (x) => x / 3;
-            const mult = (x) => x * 2;
-            expect((0, functional_1.compose)(mult, div, add)(5)).toBe(4);
-            expect((0, functional_1.compose)(add, mult, div)(9)).toBe(7);
-            expect((0, functional_1.compose)(mult, add)(6)).toBe(14);
-            expect((0, functional_1.compose)(mult)(6)).toBe(12);
-        });
-    });
-    describe('noop()', () => {
-        it('does nothing', () => {
-            expect((0, functional_1.noop)()).toBeUndefined();
-        });
-    });
-    describe('identity()', () => {
-        it('returns the input', () => {
-            const input = () => null;
-            expect((0, functional_1.identity)(input)).toEqual(input);
-        });
-    });
-    describe('stringify()', () => {
-        it('returns the input as a string', () => {
-            expect((0, functional_1.stringify)('foo')).toBe('foo');
-            expect((0, functional_1.stringify)(123)).toBe('123');
-        });
-    });
-    describe('chain()', () => {
-        it('chains multiple function calls from left to right', () => {
-            let result = 5;
-            const outerArgs = ['a', false, -3];
-            const add = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result += 1;
-            };
-            const div = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result /= 3;
-            };
-            const mult = (...args) => {
-                expect(args).toEqual(outerArgs);
-                result *= 2;
-            };
-            (0, functional_1.chain)(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            (0, functional_1.chain)(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            (0, functional_1.chain)(add)(...outerArgs);
-            expect(result).toBe(6);
-        });
-    });
-    describe('chainVoid()', () => {
-        it('chains multiple function calls from left to right', () => {
-            let result = 5;
-            const add = () => {
-                result += 1;
-            };
-            const div = () => {
-                result /= 3;
-            };
-            const mult = () => {
-                result *= 2;
-            };
-            (0, functional_1.chainVoid)(add, div, mult)();
-            expect(result).toBe(4);
-        });
-    });
-    describe('chainAsync()', () => {
-        it('chains multiple async function calls in sequence from left to right', async () => {
-            let result = 5;
-            const outerArgs = ['a', false, -3];
-            const add = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await (0, promise_1.delay)(1);
-                result += 1;
-            };
-            const div = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await (0, promise_1.delay)(1);
-                result /= 3;
-            };
-            const mult = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await (0, promise_1.delay)(1);
-                result *= 2;
-            };
-            await (0, functional_1.chainAsync)(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            await (0, functional_1.chainAsync)(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            await (0, functional_1.chainAsync)(add)(...outerArgs);
-            expect(result).toBe(6);
-        });
-    });
-    describe('chainVoidAsync()', () => {
-        it('chains multiple async function calls in sequence from left to right', async () => {
-            let result = 5;
-            const add = async () => {
-                await (0, promise_1.delay)(1);
-                result += 1;
-            };
-            const div = async () => {
-                await (0, promise_1.delay)(1);
-                result /= 3;
-            };
-            const mult = async () => {
-                await (0, promise_1.delay)(1);
-                result *= 2;
-            };
-            await (0, functional_1.chainVoidAsync)(add, div, mult)();
-            expect(result).toBe(4);
-        });
-    });
-    describe('withEffect()', () => {
-        it('apply effect to a value and return the value', () => {
-            const input = 4;
-            const spy = jest.fn();
-            (0, functional_1.withEffect)(spy)(input);
-            expect(spy).toHaveBeenCalledWith(4);
-        });
-    });
-});