@voiceflow/common 8.2.7 → 8.3.0

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

@@ -1,137 +0,0 @@
-import { chain, chainAsync, chainVoid, chainVoidAsync, compose, identity, isFunction, noop, stringify, withEffect } from './functional.js';
-import { delay } from './promise.js';
-describe('Utils | functional', () => {
-    describe('isFunction()', () => {
-        it('checks if the provided argument is a function', () => {
-            expect(isFunction(null)).toBe(false);
-            expect(isFunction({})).toBe(false);
-            expect(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(compose(mult, div, add)(5)).toBe(4);
-            expect(compose(add, mult, div)(9)).toBe(7);
-            expect(compose(mult, add)(6)).toBe(14);
-            expect(compose(mult)(6)).toBe(12);
-        });
-    });
-    describe('noop()', () => {
-        it('does nothing', () => {
-            expect(noop()).toBeUndefined();
-        });
-    });
-    describe('identity()', () => {
-        it('returns the input', () => {
-            const input = () => null;
-            expect(identity(input)).toEqual(input);
-        });
-    });
-    describe('stringify()', () => {
-        it('returns the input as a string', () => {
-            expect(stringify('foo')).toBe('foo');
-            expect(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;
-            };
-            chain(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            chain(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            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;
-            };
-            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 delay(1);
-                result += 1;
-            };
-            const div = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await delay(1);
-                result /= 3;
-            };
-            const mult = async (...args) => {
-                expect(args).toEqual(outerArgs);
-                await delay(1);
-                result *= 2;
-            };
-            await chainAsync(add, div, mult)(...outerArgs);
-            expect(result).toBe(4);
-            result = 5;
-            await chainAsync(add, mult)(...outerArgs);
-            expect(result).toBe(12);
-            result = 5;
-            await 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 delay(1);
-                result += 1;
-            };
-            const div = async () => {
-                await delay(1);
-                result /= 3;
-            };
-            const mult = async () => {
-                await delay(1);
-                result *= 2;
-            };
-            await 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();
-            withEffect(spy)(input);
-            expect(spy).toHaveBeenCalledWith(4);
-        });
-    });
-});

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

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

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

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

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

@@ -1,64 +0,0 @@
-import { remapObjectIDs } from './id.js';
-// sample ObjectIds
-const Sample = {
-    A: 'aaaaaaaaaaaaaaaaaaaaaaaa',
-    B: 'bbbbbbbbbbbbbbbbbbbbbbbb',
-    C: 'cccccccccccccccccccccccc',
-    REAL: '61dcebb839fc80002d048dbd',
-};
-describe('Utils | id', () => {
-    describe('remapObjectIDs()', () => {
-        it('shallow nested', () => {
-            const map = { [Sample.A]: Sample.B };
-            expect(remapObjectIDs({ cool: Sample.A }, map)).toEqual({ cool: Sample.B });
-        });
-        it('converts string', () => {
-            const map = { [Sample.A]: Sample.B };
-            expect(remapObjectIDs(Sample.A, map)).toBe(Sample.B);
-        });
-        it('converts multiple', () => {
-            const map = { [Sample.A]: Sample.B, [Sample.REAL]: Sample.C };
-            expect(remapObjectIDs({ 1: Sample.A, 2: Sample.REAL }, map)).toEqual({ 1: Sample.B, 2: Sample.C });
-            expect(remapObjectIDs({ 1: { 2: { 3: Sample.A, 4: [Sample.REAL] } } }, map)).toEqual({ 1: { 2: { 3: Sample.B, 4: [Sample.C] } } });
-        });
-        it('converts multiple maps', () => {
-            const map = new Map([
-                [Sample.A, Sample.B],
-                [Sample.REAL, Sample.C],
-            ]);
-            expect(remapObjectIDs({ 1: Sample.A, 2: Sample.REAL }, map)).toEqual({ 1: Sample.B, 2: Sample.C });
-            expect(remapObjectIDs({ 1: { 2: { 3: Sample.A, 4: [Sample.REAL] } } }, map)).toEqual({ 1: { 2: { 3: Sample.B, 4: [Sample.C] } } });
-        });
-        it('converts very nested', () => {
-            const object = {
-                a: { b: { c: { d: { e: 'id1' } } } },
-                id1: {
-                    id2: {
-                        id3: {
-                            id4: ['id5'],
-                        },
-                    },
-                    b: 'id2',
-                },
-            };
-            const map = {
-                id1: 'new1',
-                id2: 'new2',
-                id3: 'new3',
-                id4: 'new4',
-                id5: 'new5',
-            };
-            expect(remapObjectIDs(object, map)).toEqual({
-                a: { b: { c: { d: { e: 'new1' } } } },
-                new1: {
-                    new2: {
-                        new3: {
-                            new4: ['new5'],
-                        },
-                    },
-                    b: 'new2',
-                },
-            });
-        });
-    });
-});

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

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

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

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

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

@@ -1,75 +0,0 @@
-import * as data from './__fixtures__/name.json';
-import { injectUtteranceSpaces, utteranceEntityPermutations } from './intent.js';
-describe('utteranceEntityPermutations unit tests', () => {
-    it('works correctly', async () => {
-        const utterances = data.intents[0].inputs.map(({ text }) => text);
-        const entitiesByID = Object.fromEntries(data.slots.map((slot) => [slot.key, slot]));
-        const key = '4i3h3mmi';
-        const luisUtterances = utteranceEntityPermutations({ utterances, entitiesByID });
-        expect(luisUtterances.length).toBe(Math.min(entitiesByID[key].inputs.length, 22));
-        // Check that each slot value is within one of the utterances
-        entitiesByID[key].inputs.forEach((input, i) => {
-            if (i < 22) {
-                expect(luisUtterances.filter((utt) => utt.text?.includes(input)).length).toBeGreaterThan(0);
-            }
-        });
-        // Check that a fake name is not within the utterances
-        expect(luisUtterances.filter((utt) => utt.text?.includes('fakeName')).length).toBe(0);
-    });
-    it('with replacer', async () => {
-        const utterances = [
-            '{{[slot].4i3h3mmi}} testing {{[slotmans].4i3h3mmi}} {{[third].third}}',
-            'close {{[slotmans].4i3h3mmi}}{{[third].third}} together',
-        ];
-        const entitiesByID = {
-            '4i3h3mmi': { name: 'slotmans', inputs: ['value1', 'value_super_long', 'v3'] },
-            third: { name: 'third', inputs: ['thirdvalue'] },
-        };
-        // this generates the rasa format
-        const replacer = (sample, entityID) => {
-            return `[${sample}](${entitiesByID[entityID].name})`;
-        };
-        const replacedUtterances = utteranceEntityPermutations({ utterances, entitiesByID, replacer });
-        expect(replacedUtterances.map(({ text }) => text)).toEqual([
-            '[value1](slotmans) testing [value_super_long](slotmans) [thirdvalue](third)',
-            'close [v3](slotmans)[thirdvalue](third) together',
-        ]);
-    });
-});
-describe('injectUtteranceSpaces', () => {
-    const testUtterances = [
-        '',
-        '{{[slot].4i3h3mmi}}',
-        '{{[slot].4i3h3mmi}}{{[slotmans].4i3h3mmi}}',
-        'hello there {{[slotmans].4i3h3mma}}',
-        'hello there {{[slotmans].4i3h3mmb}} words',
-        'hello there{{[slotmans].4i3h3mmc}} words',
-        'hello there {{[slotmans].4i3h3mmd}}words',
-        'hello there{{[slotmans].4i3h3mme}}words',
-        'hello there {{[slotmans].4i3h3mmf}}, words',
-        'hello there:{{[slotmans].4i3h3mmg}},words',
-        '{{[slot].4i3h3mmi}}and{{[third].third}}',
-        '{{[slot].4i3h3mmi}}{{[slotmans].4i3h3mmi}}{{[third].third}}',
-        'multiple{{[slotmans].4i3h3mmi}}slots{{[slotmans].4i3h3mmi}}words{{[slotmans].4i3h3mmi}}',
-    ];
-    const expectedResults = [
-        '',
-        '{{[slot].4i3h3mmi}}',
-        '{{[slot].4i3h3mmi}} {{[slotmans].4i3h3mmi}}',
-        'hello there {{[slotmans].4i3h3mma}}',
-        'hello there {{[slotmans].4i3h3mmb}} words',
-        'hello there {{[slotmans].4i3h3mmc}} words',
-        'hello there {{[slotmans].4i3h3mmd}} words',
-        'hello there {{[slotmans].4i3h3mme}} words',
-        'hello there {{[slotmans].4i3h3mmf}}, words',
-        'hello there:{{[slotmans].4i3h3mmg}},words',
-        '{{[slot].4i3h3mmi}} and {{[third].third}}',
-        '{{[slot].4i3h3mmi}} {{[slotmans].4i3h3mmi}} {{[third].third}}',
-        'multiple {{[slotmans].4i3h3mmi}} slots {{[slotmans].4i3h3mmi}} words {{[slotmans].4i3h3mmi}}',
-    ];
-    it('add spaces around slots if needed', () => {
-        for (let i = 0; i < testUtterances.length; ++i) {
-            expect(injectUtteranceSpaces(testUtterances[i])).toBe(expectedResults[i]);
-        }
-    });
-});

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

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

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

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

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

@@ -1,20 +0,0 @@
-import { getOrDefault } from './map.js';
-describe('Utils | map', () => {
-    describe('getOrDefault', () => {
-        it('returns the value at the given key if it exists in the map', () => {
-            const map = new Map([['key', 'value']]);
-            const value = getOrDefault(map, 'key', 'other');
-            expect(value).toBe('value');
-        });
-        it('inserts and returns the default value if key does not exist in the map', () => {
-            const map = new Map();
-            const value = getOrDefault(map, 'key', 'other');
-            expect(value).toBe('other');
-        });
-        it('inserts and returns the result of the default value function if key does not exist in the map', () => {
-            const map = new Map();
-            const value = getOrDefault(map, 'key', () => 'other');
-            expect(value).toBe('other');
-        });
-    });
-});

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

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

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

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

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":""}