@voiceflow/common 8.2.8 → 8.3.1

package/build/esm/utils/object/common.test.js

@@ -1,173 +0,0 @@
-import { hasProperty, isObject, mapEntry, mapValue, omit, omitBy, pick, pickBy, selectField, selectID, selectKey, selectValue, shallowPartialEquals, } from './common.js';
-describe('Utils | object | common', () => {
-    describe('selectField()', () => {
-        it('creates function', () => {
-            expect(typeof selectField('field')).toBe('function');
-        });
-        it('works', () => {
-            expect(selectField('field')({ field: 1 })).toBe(1);
-            expect(selectField('field2')({ field1: 1, field2: 2 })).toBe(2);
-        });
-    });
-    describe('selectID()', () => {
-        it('works', () => {
-            expect(selectID({ id: '1' })).toBe('1');
-            expect(selectID({ id: 0 })).toBe(0);
-        });
-    });
-    describe('selectKey()', () => {
-        it('works', () => {
-            expect(selectKey({ key: '1' })).toBe('1');
-            expect(selectKey({ key: 0 })).toBe(0);
-        });
-    });
-    describe('selectValue()', () => {
-        it('works', () => {
-            expect(selectValue({ value: '1' })).toBe('1');
-            expect(selectValue({ value: 0 })).toBe(0);
-        });
-    });
-    describe('isObject()', () => {
-        it('works positive', () => {
-            expect(isObject({})).toBe(true);
-            expect(isObject({})).toBe(true);
-            expect(isObject([])).toBe(true);
-            // eslint-disable-next-line no-new-wrappers
-            expect(isObject(new Number(1))).toBe(true);
-        });
-        it('works negative', () => {
-            expect(isObject(null)).toBe(false);
-            expect(isObject(undefined)).toBe(false);
-            expect(isObject('')).toBe(false);
-            expect(isObject('lorem')).toBe(false);
-            expect(isObject(0)).toBe(false);
-            expect(isObject(Symbol('s'))).toBe(false);
-        });
-    });
-    describe('hasProperty()', () => {
-        it('works', () => {
-            expect(hasProperty({ value: '1' }, 'value')).toBe(true);
-            expect(hasProperty({}, 'key')).toBe(false);
-        });
-    });
-    describe('omit()', () => {
-        it('works with 0-3 keys', () => {
-            expect(omit({ value1: '1' }, [])).toEqual({ value1: '1' });
-            expect(omit({ value1: '1' }, ['value1'])).toEqual({});
-            expect(omit({ value1: '1', value2: '2', value3: 3 }, ['value1', 'value2'])).toEqual({ value3: 3 });
-            expect(omit({ value1: '1', value2: '2', value3: 3, value4: 4 }, ['value1', 'value2', 'value3'])).toEqual({ value4: 4 });
-        });
-        it('works with 3+ keys', () => {
-            expect(omit({ value1: '1', value2: '2', value3: 3 }, ['value1', 'value2', 'value3'])).toEqual({});
-            expect(omit({ value1: '1', value2: '2', value3: 3, value4: undefined, value5: null }, ['value1', 'value2', 'value3', 'value5'])).toEqual({
-                value4: undefined,
-            });
-        });
-    });
-    describe('pick()', () => {
-        it('works with 0-3 keys', () => {
-            expect(pick({ value1: '1' }, [])).toEqual({});
-            expect(pick({ value1: '1' }, ['value1'])).toEqual({ value1: '1' });
-            expect(pick({ value1: '1', value2: '2', value3: 3 }, ['value1', 'value2'])).toEqual({ value1: '1', value2: '2' });
-            expect(pick({ value1: '1', value2: '2', value3: 3, value4: 4 }, ['value1', 'value2', 'value3'])).toEqual({
-                value1: '1',
-                value2: '2',
-                value3: 3,
-            });
-        });
-        it('works with 3+ keys', () => {
-            expect(pick({ value1: '1', value2: '2', value3: 3 }, ['value1', 'value2', 'value3'])).toEqual({ value1: '1', value2: '2', value3: 3 });
-            expect(pick({ value1: '1', value2: '2', value3: 3, value4: undefined, value5: null }, ['value1', 'value2', 'value3', 'value5'])).toEqual({
-                value1: '1',
-                value2: '2',
-                value3: 3,
-                value5: null,
-            });
-        });
-        it('works with undefined keys', () => {
-            expect(pick({ value1: '1', value2: '2' }, ['value1', 'value2', 'value3'])).toEqual({ value1: '1', value2: '2' });
-        });
-    });
-    describe('omitBy()', () => {
-        it('works', () => {
-            const keys = new Set(['value1', 'value2', 'value5']);
-            expect(omitBy({ value1: '1' }, () => false)).toEqual({ value1: '1' });
-            expect(omitBy({ value1: '1' }, (key) => keys.has(key))).toEqual({});
-            expect(omitBy({ value1: '1', value2: '2', value3: 3 }, (key) => keys.has(key))).toEqual({ value3: 3 });
-            expect(omitBy({ value1: '1', value2: '2', value3: 3 }, (key) => key === 'value3' || keys.has(key))).toEqual({});
-            expect(omitBy({ value1: '1', value2: '2', value3: 3, value4: undefined, value5: null }, (key) => keys.has(key))).toEqual({
-                value3: 3,
-                value4: undefined,
-            });
-        });
-    });
-    describe('pickBy()', () => {
-        it('works', () => {
-            const keys = new Set(['value1', 'value2', 'value5']);
-            expect(pickBy({ value1: '1' }, () => false)).toEqual({});
-            expect(pickBy({ value1: '1' }, (key) => keys.has(key))).toEqual({ value1: '1' });
-            expect(pickBy({ value1: '1', value2: '2', value3: 3 }, (key) => keys.has(key))).toEqual({
-                value1: '1',
-                value2: '2',
-            });
-            expect(pickBy({ value1: '1', value2: '2', value3: 3 }, (key) => key === 'value3' || keys.has(key))).toEqual({
-                value1: '1',
-                value2: '2',
-                value3: 3,
-            });
-            expect(pickBy({ value1: '1', value2: '2', value3: 3, value4: undefined, value5: null }, (key) => keys.has(key))).toEqual({
-                value1: '1',
-                value2: '2',
-                value5: null,
-            });
-        });
-    });
-    describe('mapValue()', () => {
-        it('works', () => {
-            const objects = {
-                a: { id: 1 },
-                b: { id: 2 },
-                c: { id: 3 },
-            };
-            expect(mapValue(objects, ({ id }) => id)).toEqual({ a: 1, b: 2, c: 3 });
-        });
-    });
-    describe('mapEntry()', () => {
-        it('works', () => {
-            const objects = {
-                a: { id: 1 },
-                b: { id: 2 },
-                c: { id: 3 },
-            };
-            expect(mapEntry(objects, ([key, { id }]) => [`new_${key}`, id])).toEqual({ new_a: 1, new_b: 2, new_c: 3 });
-        });
-    });
-    describe('shallowPartialEquals()', () => {
-        it('works', () => {
-            const obj1 = {
-                a: 1,
-                b: 2,
-            };
-            const obj1Update = {
-                a: 1,
-                c: undefined,
-            };
-            expect(shallowPartialEquals(obj1, obj1Update)).toBe(false);
-            const obj2 = {
-                a: 1,
-                b: 2,
-            };
-            const obj2Update = {
-                a: 1,
-            };
-            expect(shallowPartialEquals(obj2, obj2Update)).toBe(true);
-            const obj3 = {
-                a: 1,
-            };
-            const obj3Update = {
-                b: 1,
-            };
-            expect(shallowPartialEquals(obj3, obj3Update)).toBe(false);
-        });
-    });
-});

package/build/esm/utils/object/deepMap.test.d.ts

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

package/build/esm/utils/object/deepMap.test.d.ts.map

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

package/build/esm/utils/object/deepMap.test.js

@@ -1,109 +0,0 @@
-import ObjectID from 'bson-objectid';
-import { deepMap, deepMapKeys } from './deepMap.js';
-describe('Utils | object | deepMap', () => {
-    describe('deepMap()', () => {
-        const transform = (n) => (typeof n === 'number' ? n ** 2 : Number(n) ** 2);
-        it('transforms simple object', () => {
-            expect(deepMap({ two: 2, three: '3' }, transform)).toEqual({ two: 4, three: 9 });
-        });
-        it('transforms simple array', () => {
-            expect(deepMap(['2', 3], transform)).toEqual([4, 9]);
-        });
-        it("don't change non plain objects", () => {
-            const transform = (n) => (typeof n === 'string' ? Number(n) ** 2 : n);
-            const date = new Date();
-            expect(deepMap(['2', date], transform)).toEqual([4, date]);
-        });
-        it('transform objectID', () => {
-            const originalID = new ObjectID();
-            const transformedID = new ObjectID();
-            const transform = (n) => (n === originalID ? transformedID : n);
-            const date = new Date();
-            expect(deepMap(['2', date, originalID], transform)).toEqual(['2', date, transformedID]);
-        });
-        it('transforms object with nested objects/arrays', () => {
-            expect(deepMap({ two: '2', obj: { three: '3', four: 4 }, arr: [5, '6'] }, transform)).toEqual({
-                two: 4,
-                obj: { three: 9, four: 16 },
-                arr: [25, 36],
-            });
-        });
-        it('transforms array with nested objects/arrays', () => {
-            expect(deepMap([2, { three: 3, four: 4 }, [5, 6]], transform)).toEqual([4, { three: 9, four: 16 }, [25, 36]]);
-        });
-        it('transforms an object with circular references', () => {
-            const obj = { two: 2, arr: [3, 4], self: null, arr2: null };
-            obj.self = obj;
-            obj.arr2 = obj.arr;
-            const exp = { two: 4, arr: [9, 16], self: null, arr2: null };
-            exp.self = exp;
-            exp.arr2 = exp.arr;
-            expect(deepMap(obj, transform)).toEqual(exp);
-        });
-        it('transforms object in place', () => {
-            const arr = [3];
-            const obj = { two: 2, arr };
-            const result = deepMap(obj, transform, { inPlace: true });
-            expect(result).toEqual({ two: 4, arr: [9] });
-            expect(result).toEqual(obj);
-        });
-        it('transforms sub-objects/sub-arrays in place', () => {
-            const arr = [3];
-            const obj = { two: 2, arr };
-            expect(deepMap(obj, transform, { inPlace: true }).arr).toEqual(arr);
-        });
-        it('defaults to false', () => {
-            const arr = [3];
-            const obj = { two: 2, arr };
-            expect(deepMap(obj, transform)).not.toEqual(obj);
-        });
-        it('mapFunction is called once per primitive value', () => {
-            const square = jest.fn(transform);
-            deepMap({ two: 2, obj: { three: 3 }, arr: [4] }, square);
-            expect(square).toHaveBeenCalledTimes(3);
-        });
-        it('mapFunction is called with value and key', () => {
-            const square = jest.fn(transform);
-            deepMap({ two: 2, arr: [3, 6] }, square);
-            expect(square).toHaveBeenNthCalledWith(1, 2, 'two');
-            expect(square).toHaveBeenNthCalledWith(2, 3, 0);
-            expect(square).toHaveBeenNthCalledWith(3, 6, 1);
-        });
-    });
-    describe('deepMapKeys()', () => {
-        const transform = (key) => key.toUpperCase();
-        it('transforms keys of simple object', () => {
-            expect(deepMapKeys({ one: 1, two: 2 }, transform)).toEqual({ ONE: 1, TWO: 2 });
-        });
-        it('transforms keys of object with nested objects/arrays', () => {
-            expect(deepMapKeys({ one: 1, obj: { two: 2, three: 3 }, arr: [4, 5] }, transform)).toEqual({
-                ONE: 1,
-                OBJ: { TWO: 2, THREE: 3 },
-                ARR: [4, 5],
-            });
-        });
-        it('transforms keys of array with nested object/array', () => {
-            expect(deepMapKeys([1, { two: 2, three: 3, arr: [4, { five: 5 }] }], transform)).toEqual([1, { TWO: 2, THREE: 3, ARR: [4, { FIVE: 5 }] }]);
-        });
-        it('transforms an object with circular references', () => {
-            const obj = { one: 1, arr: [2, 3], self: null, arr2: [] };
-            obj.self = obj;
-            obj.arr2 = obj.arr;
-            const exp = { ONE: 1, ARR: [2, 3], SELF: null, ARR2: [] };
-            exp.SELF = exp;
-            exp.ARR2 = exp.ARR;
-            expect(deepMapKeys(obj, transform)).toEqual(exp);
-        });
-        it('mapFunction is called once per object property', () => {
-            const caps = jest.fn(transform);
-            deepMapKeys({ one: 1, obj: { two: 2, three: 3 }, arr: [4, 5] }, caps);
-            expect(caps).toHaveBeenCalledTimes(5);
-        });
-        it('mapFunction is called with key and value', () => {
-            const caps = jest.fn(transform);
-            deepMapKeys({ one: 1, arr: [2, 3] }, caps);
-            expect(caps).toHaveBeenNthCalledWith(1, 'one', 1);
-            expect(caps).toHaveBeenNthCalledWith(2, 'arr', [2, 3]);
-        });
-    });
-});

package/build/esm/utils/object/diff.test.d.ts

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

package/build/esm/utils/object/diff.test.d.ts.map

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

package/build/esm/utils/object/diff.test.js

@@ -1,17 +0,0 @@
-import { getTopLevelDiff } from './diff.js';
-describe('Utils | object | diff', () => {
-    describe('getTopLevelDiff()', () => {
-        it('gets diff of arrays', () => {
-            expect(getTopLevelDiff(['foo', 'bar', 'fuzz'], ['fizz', 'buzz', 'fuzz'])).toEqual(['foo', 'bar']);
-        });
-        it('gets diff of objects', () => {
-            expect(getTopLevelDiff({ foo: 1, bar: 2, fuzz: 3 }, { fizz: 4, buzz: 5, fuzz: 3 })).toEqual({ foo: 1, bar: 2 });
-        });
-        it('gets diff of objects with custom compare', () => {
-            expect(getTopLevelDiff({ foo: 1, bar: 2, fuzz: 6 }, { fizz: 4, buzz: 5, fuzz: 9 }, (lhs, rhs) => typeof lhs === typeof rhs)).toEqual({
-                foo: 1,
-                bar: 2,
-            });
-        });
-    });
-});

package/build/esm/utils/object/keys.test.d.ts

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

package/build/esm/utils/object/keys.test.d.ts.map

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

package/build/esm/utils/object/keys.test.js

@@ -1,13 +0,0 @@
-import { getKeys } from './keys.js';
-describe('Utils | object | keys', () => {
-    describe('getKeys()', () => {
-        it('gets keys with a strict type', () => {
-            const foo = Symbol('foo');
-            const bar = Symbol('bar');
-            const fizz = Symbol('fizz');
-            const keys = getKeys({ [foo]: 1, [bar]: 2, [fizz]: 3 });
-            // this would throw a compiler error if `keys[0]` was a `string`
-            keys[0] === foo;
-        });
-    });
-});

package/build/esm/utils/promise.test.d.ts

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

package/build/esm/utils/promise.test.d.ts.map

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

package/build/esm/utils/promise.test.js

@@ -1,23 +0,0 @@
-import { delay, rejectIn } from './promise.js';
-describe('Utils | promise', () => {
-    describe('delay()', () => {
-        it('delay for the provided time before resolving', async () => {
-            const timeout = 10;
-            const start = Date.now();
-            await delay(timeout);
-            expect(Date.now() - start).toBeGreaterThanOrEqual(timeout);
-        });
-    });
-    describe('rejectIn()', () => {
-        it('delay for the provided time before rejecting', async () => {
-            const timeout = 10;
-            const start = Date.now();
-            try {
-                await rejectIn(timeout);
-            }
-            catch (err) {
-                expect(Date.now() - start).toBeGreaterThanOrEqual(timeout);
-            }
-        });
-    });
-});

package/build/esm/utils/protocol.test.d.ts

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

package/build/esm/utils/protocol.test.d.ts.map

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

package/build/esm/utils/protocol.test.js

@@ -1,38 +0,0 @@
-import { Channel, createChannel, typeFactory } from './protocol.js';
-describe('Utils | protocol', () => {
-    describe('typeFactory()', () => {
-        it('should generate a prefixed type', () => {
-            expect(typeFactory('red', 'blue')('green')).toBe('red.blue.green');
-        });
-    });
-    describe('Channel', () => {
-        describe('build()', () => {
-            it('store original build function directly', () => {
-                const channel = new Channel(['foo', 'bar'], ({ foo, bar }) => `${foo}/fizz/buzz/${bar}`);
-                expect(channel.build({ foo: '123', bar: '456' })).toBe('123/fizz/buzz/456');
-            });
-        });
-        describe('buildMatcher()', () => {
-            it('store build a matcher using the provided argument names', () => {
-                const channel = new Channel(['foo', 'bar'], ({ foo, bar }) => `${foo}/fizz/buzz/${bar}`);
-                expect(channel.buildMatcher()).toBe(':foo/fizz/buzz/:bar');
-            });
-        });
-        describe('extend()', () => {
-            it('create a channel built to be suffixed to the output of an existing channel', () => {
-                const fooChannel = new Channel(['foo'], ({ foo }) => `foo/${foo}`);
-                const barChannel = fooChannel.extend(['bar'], ({ bar }) => `bar/${bar}`);
-                expect(barChannel.buildMatcher()).toBe('foo/:foo/bar/:bar');
-                expect(barChannel.build({ foo: '123', bar: '456' })).toBe('foo/123/bar/456');
-            });
-        });
-        describe('createChannel()', () => {
-            it('constructs a new Channel', () => {
-                const channel = createChannel(['foo'], ({ foo }) => `foo/${foo}`);
-                expect(channel).toBeInstanceOf(Channel);
-                expect(channel.buildMatcher()).toBe('foo/:foo');
-                expect(channel.build({ foo: '123' })).toBe('foo/123');
-            });
-        });
-    });
-});

package/build/esm/utils/slot.test.d.ts

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

package/build/esm/utils/slot.test.d.ts.map

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

package/build/esm/utils/slot.test.js

@@ -1,13 +0,0 @@
-import * as SlotUtils from './slot.js';
-describe('Utils | slot', () => {
-    describe('getValueWithSynonyms', () => {
-        it('extracts synonyms', () => {
-            expect(SlotUtils.getValueWithSynonyms('a, b, c, d')).toEqual(['a', ['b', 'c', 'd']]);
-        });
-    });
-    describe('mapSlotAnnotations', () => {
-        it('renames keys and maps', () => {
-            expect(SlotUtils.mapSlotAnnotations('test {{[name].key}} thing', () => ({ key: 'newKey', name: 'newName' }))).toEqual('test {{[newName].newKey}} thing');
-        });
-    });
-});

package/build/esm/utils/string.test.d.ts

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

package/build/esm/utils/string.test.d.ts.map

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

package/build/esm/utils/string.test.js

@@ -1,51 +0,0 @@
-import { arrayStringReplace, capitalizeAllWords, capitalizeFirstLetter, conditionalReplace, removeTrailingUnderscores, stripHTMLTags, } from './string.js';
-describe('Utils | string', () => {
-    describe('capitalizeFirstLetter()', () => {
-        it('capitalizes the first letter', () => {
-            expect(capitalizeFirstLetter('')).toBe('');
-            expect(capitalizeFirstLetter('123')).toBe('123');
-            expect(capitalizeFirstLetter('abc')).toBe('Abc');
-        });
-    });
-    describe('capitalizeAllWords()', () => {
-        it('capitalizes all the space-delimited words', () => {
-            expect(capitalizeAllWords('')).toBe('');
-            expect(capitalizeAllWords('abc')).toBe('Abc');
-            expect(capitalizeAllWords('abc def')).toBe('Abc Def');
-        });
-    });
-    describe('arrayStringReplace()', () => {
-        it('replace a pattern for each item in an array', () => {
-            expect(arrayStringReplace('x', 'y', [])).toEqual([]);
-            expect(arrayStringReplace('x', 'y', ['foo'])).toEqual(['foo']);
-            expect(arrayStringReplace('x', 'y', ['xyz', 'foo', 'fox', 'bar'])).toEqual(['yyz', 'foo', 'foy', 'bar']);
-        });
-    });
-    describe('stripHTMLTags()', () => {
-        it('remove HTML tags from a string', () => {
-            expect(stripHTMLTags('')).toBe('');
-            expect(stripHTMLTags('<')).toBe('<');
-            expect(stripHTMLTags('<>')).toBe('<>');
-            expect(stripHTMLTags('<foo>')).toBe('');
-            expect(stripHTMLTags('a b c d')).toBe('a b c d');
-            expect(stripHTMLTags('a <foo> b <bar> c <fizz> d')).toBe('a  b  c  d');
-        });
-    });
-    describe('removeTrailingUnderscores()', () => {
-        it('remove leading and trailing underscore characters', () => {
-            expect(removeTrailingUnderscores('')).toBe('');
-            expect(removeTrailingUnderscores('foo')).toBe('foo');
-            expect(removeTrailingUnderscores('__foo')).toBe('foo');
-            expect(removeTrailingUnderscores('foo__')).toBe('foo');
-            expect(removeTrailingUnderscores('__foo__')).toBe('foo');
-        });
-    });
-    describe('conditionalReplace()', () => {
-        it('do nothing with falsey value', () => {
-            expect(conditionalReplace('fizz', /i/)).toBe('fizz');
-        });
-        it('use truthy value as replacement value', () => {
-            expect(conditionalReplace('fizz', /i/, 'u')).toBe('fuzz');
-        });
-    });
-});

package/build/esm/utils/timezones.test.d.ts

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

package/build/esm/utils/timezones.test.d.ts.map

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

package/build/esm/utils/timezones.test.js

@@ -1,10 +0,0 @@
-import { unique } from './array.js';
-import { TIMEZONES } from './timezones.js';
-describe('Utils | timezones', () => {
-    describe('TIMEZONES', () => {
-        it('a list of all timezones', () => {
-            expect(TIMEZONES.length).toBe(490);
-            expect(unique(TIMEZONES)).toEqual(TIMEZONES);
-        });
-    });
-});

package/build/esm/utils/typeguard.test.d.ts

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

package/build/esm/utils/typeguard.test.d.ts.map

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

package/build/esm/utils/typeguard.test.js

@@ -1,53 +0,0 @@
-import { createTypedTypeguardCreator, createTypeguardCreator } from './typeguard.js';
-describe('Utils | typeguard', () => {
-    describe('createTypeguardCreator()', () => {
-        it('casts the guarded argument', () => {
-            const createTypeguard = createTypeguardCreator();
-            const input = 'foo';
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const assertTyped = (_arg) => undefined;
-            const typeguard = createTypeguard('foo');
-            if (typeguard(input)) {
-                assertTyped(input);
-            }
-        });
-        it('typeguard against a single value', () => {
-            const createTypeguard = createTypeguardCreator();
-            const typeguard = createTypeguard('foo');
-            expect(typeguard('foo')).toBe(true);
-            expect(typeguard('bar')).toBe(false);
-        });
-        it('typeguard against an array of values', () => {
-            const createTypeguard = createTypeguardCreator();
-            const typeguard = createTypeguard(['foo', 'bar']);
-            expect(typeguard('foo')).toBe(true);
-            expect(typeguard('bar')).toBe(true);
-            expect(typeguard('fizz')).toBe(false);
-        });
-    });
-    describe('createTypedTypeguardCreator()', () => {
-        it('casts the guarded argument', () => {
-            const createTypeguard = createTypedTypeguardCreator();
-            const input = { type: 'foo', id: 123 };
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const assertTyped = (_arg) => undefined;
-            const typeguard = createTypeguard('foo');
-            if (typeguard(input)) {
-                assertTyped(input);
-            }
-        });
-        it('typeguard against a single value', () => {
-            const createTypeguard = createTypedTypeguardCreator();
-            const typeguard = createTypeguard('foo');
-            expect(typeguard({ type: 'foo', id: 1 })).toBe(true);
-            expect(typeguard({ type: 'bar', id: 2 })).toBe(false);
-        });
-        it('typeguard against an array of values', () => {
-            const createTypeguard = createTypedTypeguardCreator();
-            const typeguard = createTypeguard(['foo', 'bar']);
-            expect(typeguard({ type: 'foo', id: 1 })).toBe(true);
-            expect(typeguard({ type: 'bar', id: 2 })).toBe(true);
-            expect(typeguard({ type: 'fizz', id: 3 })).toBe(false);
-        });
-    });
-});