@voiceflow/common 8.2.4 → 8.2.6

package/build/esm/utils/normalized.js

@@ -1,16 +1,5 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { stringify } from './functional';
-import { hasProperty } from './object';
+import { stringify } from './functional.js';
+import { hasProperty } from './object/index.js';
 const createEmptyNormalized = () => ({ byKey: {}, allKeys: [] });
 export const EMPTY = createEmptyNormalized();
 export const defaultGetKey = (obj) => stringify(obj.id);
@@ -29,7 +18,7 @@ export const buildLookup = (allKeys, getValue) => allKeys.reduce((acc, key, inde
  * @deprecated prefer `normal-store`
  */
 export const normalize = (items, getKey) => {
-    const allKeys = items.map(getKey !== null && getKey !== void 0 ? getKey : defaultGetKey);
+    const allKeys = items.map(getKey ?? defaultGetKey);
     return {
         byKey: buildLookup(allKeys, getByIndex(items)),
         allKeys,
@@ -54,26 +43,35 @@ export const getAllNormalizedByKeys = ({ byKey }, keys) => keys.map((key) => byK
 /**
  * @deprecated prefer `normal-store`
  */
-export const updateNormalizedByKey = (_a, key, obj) => {
-    var { byKey } = _a, rest = __rest(_a, ["byKey"]);
-    return (Object.assign(Object.assign({}, rest), { byKey: Object.assign(Object.assign({}, byKey), { [key]: obj }) }));
-};
+export const updateNormalizedByKey = ({ byKey, ...rest }, key, obj) => ({
+    ...rest,
+    byKey: { ...byKey, [key]: obj },
+});
 /**
  * @deprecated prefer `normal-store`
  */
-export const addNormalizedByKey = (normalized, key, obj) => (Object.assign(Object.assign({}, updateNormalizedByKey(normalized, key, obj)), { allKeys: safeAdd(normalized.allKeys, key) }));
+export const addNormalizedByKey = (normalized, key, obj) => ({
+    ...updateNormalizedByKey(normalized, key, obj),
+    allKeys: safeAdd(normalized.allKeys, key),
+});
 /**
  * @deprecated prefer `normal-store`
  */
-export const addToStartNormalizedByKey = (normalized, key, obj) => (Object.assign(Object.assign({}, updateNormalizedByKey(normalized, key, obj)), { allKeys: safeAddToStart(normalized.allKeys, key) }));
+export const addToStartNormalizedByKey = (normalized, key, obj) => ({
+    ...updateNormalizedByKey(normalized, key, obj),
+    allKeys: safeAddToStart(normalized.allKeys, key),
+});
 /**
  * @deprecated prefer `normal-store`
  */
 export const addAllNormalizedByKeys = (normalized, objs, getKey) => {
-    const keyGetter = getKey !== null && getKey !== void 0 ? getKey : defaultGetKey;
+    const keyGetter = getKey ?? defaultGetKey;
     const keys = objs.map(keyGetter);
     return {
-        byKey: Object.assign(Object.assign({}, normalized.byKey), objs.reduce((acc, obj) => Object.assign(acc, { [keyGetter(obj)]: obj }), {})),
+        byKey: {
+            ...normalized.byKey,
+            ...objs.reduce((acc, obj) => Object.assign(acc, { [keyGetter(obj)]: obj }), {}),
+        },
         allKeys: keys.reduce(safeAdd, normalized.allKeys),
     };
 };
@@ -84,4 +82,3 @@ export const reorderKeys = (newKeyArray, byKey) => ({
     allKeys: newKeyArray,
     byKey,
 });
-//# sourceMappingURL=normalized.js.map

package/build/esm/utils/number.d.ts

@@ -2,3 +2,4 @@ export declare const NON_ALPHANUMERIC_REGEXP: RegExp;
 export declare const convertToWord: (value: number) => string;
 export declare const isInRange: (target: number, min: number, max: number) => boolean;
 export declare const clamp: (value: number, min: number, max: number) => number;
+//# sourceMappingURL=number.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src/utils/number.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAE7C,eAAO,MAAM,aAAa,UAAW,MAAM,KAAG,MAA4E,CAAC;AAE3H,eAAO,MAAM,SAAS,WAAY,MAAM,OAAO,MAAM,OAAO,MAAM,KAAG,OAAyC,CAAC;AAE/G,eAAO,MAAM,KAAK,UAAW,MAAM,OAAO,MAAM,OAAO,MAAM,KAAG,MAA6C,CAAC"}

package/build/esm/utils/number.js

@@ -3,4 +3,3 @@ export const NON_ALPHANUMERIC_REGEXP = /\W/g;
 export const convertToWord = (value) => numberToWords.toWords(value).replace(NON_ALPHANUMERIC_REGEXP, ' ');
 export const isInRange = (target, min, max) => target >= min && target <= max;
 export const clamp = (value, min, max) => Math.max(Math.min(value, max), min);
-//# sourceMappingURL=number.js.map

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

@@ -1,4 +1,4 @@
-import { AnyRecord, Struct } from "../../types";
+import { AnyRecord, Struct } from '../../types.js';
 export { default as shallowEquals } from 'shallowequal';
 export declare const selectField: <K extends string | number>(field: K) => <T extends { [key in K]: any; }>(obj: T) => T[K];
 export declare const selectID: <T extends {
@@ -32,3 +32,4 @@ export declare const mapValue: <T, R>(obj: Record<string | number | symbol, T>,
     [k: string]: R;
 };
 export declare const shallowPartialEquals: <T extends object>(obj: T, partial: Partial<T>) => boolean;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/utils/object/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGlD,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAExD,eAAO,MAAM,WAAW,2FAGV,CAAC;AAEf,eAAO,MAAM,QAAQ;;qBAAoB,CAAC;AAE1C,eAAO,MAAM,SAAS;;sBAAqB,CAAC;AAE5C,eAAO,MAAM,WAAW;;wBAAuB,CAAC;AAEhD,eAAO,MAAM,QAAQ,QAAS,OAAO,kBAA2D,CAAC;AAEjG,eAAO,MAAM,aAAa,QAAS,OAAO,kBAAuC,CAAC;AAElF,eAAO,MAAM,WAAW,kFACwB,CAAC;AAEjD,eAAO,MAAM,IAAI,yDAsBhB,CAAC;AAEF,eAAO,MAAM,IAAI,yDAgChB,CAAC;AAEF,UAAU,UAAU;IAClB,CAAC,CAAC,SAAS,SAAS,EAAE,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACnG,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,EAAE,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC;CAChH;AAED,eAAO,MAAM,MAAM,EAAE,UAOb,CAAC;AAET,eAAO,MAAM,MAAM,EAAE,UAUlB,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,aAAa,YAAS,CAAC;AAEpC,eAAO,MAAM,QAAQ;;CACkC,CAAC;AAExD,eAAO,MAAM,QAAQ;;CACkE,CAAC;AAExF,eAAO,MAAM,oBAAoB,4DAC2E,CAAC"}

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

@@ -8,7 +8,7 @@ export const isObject = (obj) => obj !== null && typeof obj === 'object';
 export const isPlainObject = (obj) => _isPlainObject(obj);
 export const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
 export const omit = (obj, keys) => {
-    const newObj = Object.assign({}, obj);
+    const newObj = { ...obj };
     if (keys.length > 3) {
         return keys.reduce((acc, key) => {
             delete acc[key];
@@ -62,7 +62,7 @@ export const omitBy = (obj, predicate) => Object.entries(obj).reduce((acc, [key,
         delete acc[key];
     }
     return acc;
-}, Object.assign({}, obj));
+}, { ...obj });
 /**
  * @deprecated use pickBy instead
  */
@@ -70,4 +70,3 @@ export const filterEntries = pickBy;
 export const mapEntry = (obj, callback) => Object.fromEntries(Object.entries(obj).map(callback));
 export const mapValue = (obj, callback) => Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, callback(value)]));
 export const shallowPartialEquals = (obj, partial) => Object.entries(partial).every(([key, partialValue]) => hasProperty(obj, key) && partialValue === obj[key]);
-//# sourceMappingURL=common.js.map

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

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

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

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

@@ -0,0 +1,173 @@
+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.d.ts

@@ -1,5 +1,6 @@
-import { Struct } from "../../types";
+import { Struct } from '../../types.js';
 export declare const deepMap: <T = Struct>(object: unknown, mapFunction: (value: unknown, key: string | number) => unknown, options?: {
     inPlace?: boolean;
 }) => T;
 export declare const deepMapKeys: <T = Struct>(object: unknown, mapFunction: (key: string, value: unknown) => string) => T;
+//# sourceMappingURL=deepMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deepMap.d.ts","sourceRoot":"","sources":["../../../../src/utils/object/deepMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvC,eAAO,MAAM,OAAO,uBACV,OAAO,uBACM,OAAO,OAAO,MAAM,GAAG,MAAM,KAAK,OAAO,YACrD;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,MA8C/B,CAAC;AAEF,eAAO,MAAM,WAAW,uBAAwB,OAAO,qBAAqB,MAAM,SAAS,OAAO,KAAK,MAAM,MA6C5G,CAAC"}

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

@@ -1,4 +1,4 @@
-import { isPlainObject } from './common';
+import { isPlainObject } from './common.js';
 export const deepMap = (object, mapFunction, options = {}) => {
     const cache = new WeakMap();
     const mapArray = (arr) => {
@@ -69,4 +69,3 @@ export const deepMapKeys = (object, mapFunction) => {
     };
     return map(object);
 };
-//# sourceMappingURL=deepMap.js.map

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

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

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

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

@@ -0,0 +1,109 @@
+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.d.ts

@@ -1,2 +1,3 @@
-import { AnyRecord } from "../../types";
+import { AnyRecord } from '../../types.js';
 export declare const getTopLevelDiff: <S extends AnyRecord>(object: S, base: S, compare?: <T>(left: T, right: T) => boolean) => Partial<S>;
+//# sourceMappingURL=diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../src/utils/object/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAK1C,eAAO,MAAM,eAAe,gFAFmB,OAAO,eAYrD,CAAC"}

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

@@ -9,4 +9,3 @@ export const getTopLevelDiff = (object, base, compare = defaultCompare) => {
     });
     return changes(object, base);
 };
-//# sourceMappingURL=diff.js.map

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

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

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

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

@@ -0,0 +1,17 @@
+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/index.d.ts

@@ -1,4 +1,5 @@
-export * from './common';
-export * from './deepMap';
-export * from './diff';
-export * from './keys';
+export * from './common.js';
+export * from './deepMap.js';
+export * from './diff.js';
+export * from './keys.js';
+//# sourceMappingURL=index.d.ts.map

package/build/esm/utils/object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC"}

package/build/esm/utils/object/index.js

@@ -1,5 +1,4 @@
-export * from './common';
-export * from './deepMap';
-export * from './diff';
-export * from './keys';
-//# sourceMappingURL=index.js.map
+export * from './common.js';
+export * from './deepMap.js';
+export * from './diff.js';
+export * from './keys.js';

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

@@ -1 +1,2 @@
 export declare const getKeys: <T>(obj: T) => (keyof T)[];
+//# sourceMappingURL=keys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../../../src/utils/object/keys.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,4BAA8D,CAAC"}

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

@@ -1,2 +1 @@
 export const getKeys = (obj) => Object.keys(obj);
-//# sourceMappingURL=keys.js.map

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

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

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

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

@@ -0,0 +1,13 @@
+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.d.ts

@@ -1,2 +1,3 @@
 export declare const delay: <T = boolean>(timeout: number, value?: T) => Promise<T>;
 export declare const rejectIn: (timeout: number) => Promise<never>;
+//# sourceMappingURL=promise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promise.d.ts","sourceRoot":"","sources":["../../../src/utils/promise.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,yBAA0B,MAAM,0BAG9C,CAAC;AAEL,eAAO,MAAM,QAAQ,YAAa,MAAM,KAAG,QAAQ,KAAK,CAKpD,CAAC"}

package/build/esm/utils/promise.js

@@ -6,4 +6,3 @@ export const rejectIn = (timeout) => new Promise((_resolve, reject) => {
         reject(new Error('Rejected by timeout!'));
     }, timeout);
 });
-//# sourceMappingURL=promise.js.map

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

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

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

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

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

@@ -0,0 +1,23 @@
+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.d.ts

@@ -15,3 +15,4 @@ export declare class Channel<K extends string> {
 }
 export declare type ChannelParams<T extends Channel<string>> = T extends Channel<infer R> ? Record<R, string> : never;
 export declare const createChannel: <K extends string>(variables: K[], build: (params: Record<K, string>) => string) => Channel<K>;
+//# sourceMappingURL=protocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../../src/utils/protocol.ts"],"names":[],"mappings":"AAAA,OAA6B,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEjF,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,CAAC,CAAC;CACV;AAED,eAAO,MAAM,YAAY,+CAAyB,CAAC;AAEnD,eAAO,MAAM,iBAAiB,iEAA2D,MAAM,eAAe,IAAI,iCAC5E,CAAC;AAEvC,eAAO,MAAM,WAAW,aACX,MAAM,EAAE,YACZ,MAAM,KAAG,MACY,CAAC;AAE/B,qBAAa,OAAO,CAAC,CAAC,SAAS,MAAM;IAChB,SAAS,EAAE,CAAC,EAAE;IAAS,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM;gBAAnE,SAAS,EAAE,CAAC,EAAE,EAAS,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM;IAEtF,YAAY;IAIZ,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM;CAGtF;AAED,oBAAY,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;AAE9G,eAAO,MAAM,aAAa,2EAA4E,MAAM,eAAkC,CAAC"}

package/build/esm/utils/protocol.js

@@ -15,4 +15,3 @@ export class Channel {
     }
 }
 export const createChannel = (variables, build) => new Channel(variables, build);
-//# sourceMappingURL=protocol.js.map

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

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

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

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