@voiceflow/common 8.2.5 → 8.2.7

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

@@ -3,3 +3,4 @@ export declare const deepMap: <T = Struct>(object: unknown, mapFunction: (value:
     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

@@ -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.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

@@ -2,3 +2,4 @@ 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

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

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,OAAO,EAAwB,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

@@ -1,4 +1,4 @@
-import actionCreatorFactory from 'typescript-fsa';
+import { actionCreatorFactory } from 'typescript-fsa';
 export const createAction = actionCreatorFactory();
 export const createAsyncAction = (type, commonMeta) => createAction.async(type, commonMeta);
 export const typeFactory = (...parts) => (name) => [...parts, name].join('.');
@@ -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":""}

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

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

@@ -24,3 +24,4 @@ export declare const mapSlotAnnotations: (input: string, callbackFn: (slot: {
     key: string;
     name: string;
 }) => string;
+//# sourceMappingURL=slot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slot.d.ts","sourceRoot":"","sources":["../../../src/utils/slot.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;SAAqB,MAAM;YAAU,MAAM,EAAE;oCAAqC,OAAO,MAAM,EAAE,MAAM,EAAE,CAAC,QAStI,CAAC;AAEL,eAAO,MAAM,gBAAgB,UAAW,MAAM,aAAgE,CAAC;AAG/G,eAAO,MAAM,aAAa,YAAY,MAAM,EAAE,aAAyF,CAAC;AAExI;;GAEG;AACH,eAAO,MAAM,oBAAoB,UAAW,MAAM,KAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAGrE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,UAAW,MAAM,qBAAqB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,MAAM,CAAA;CAAE,KAAK;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,MAAM,CAAA;CAAE,WAKnI,CAAC"}

package/build/esm/utils/slot.js

@@ -2,7 +2,10 @@ import _uniqBy from 'lodash/uniqBy';
 import { SLOT_REGEXP } from '../constants/index.js';
 export const addPrebuiltEntities = (entities, prebuiltEntities) => entities.map((entity) => {
     if (prebuiltEntities[entity.key]) {
-        return Object.assign(Object.assign({}, entity), { inputs: [...entity.inputs, ...prebuiltEntities[entity.key]] });
+        return {
+            ...entity,
+            inputs: [...entity.inputs, ...prebuiltEntities[entity.key]],
+        };
     }
     return entity;
 });
@@ -31,4 +34,3 @@ export const mapSlotAnnotations = (input, callbackFn) => {
         return `{{[${name}].${key}}}`;
     });
 };
-//# sourceMappingURL=slot.js.map

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

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

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

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

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

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

@@ -4,3 +4,4 @@ export declare const arrayStringReplace: (targetString: string, newString: strin
 export declare const stripHTMLTags: (str: string) => string;
 export declare const removeTrailingUnderscores: (str: string) => string;
 export declare const conditionalReplace: (base: string, pattern: RegExp, value?: string) => string;
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/utils/string.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,UAAW,MAAM,KAAG,MAAwD,CAAC;AAE/G,eAAO,MAAM,kBAAkB,UAAW,MAAM,KAAG,MAA+D,CAAC;AAEnH,eAAO,MAAM,kBAAkB,iBAAkB,MAAM,aAAa,MAAM,eAAe,MAAM,EAAE,KAAG,MAAM,EAC5B,CAAC;AAE/E,eAAO,MAAM,aAAa,QAAS,MAAM,KAAG,MAAsC,CAAC;AAEnF,eAAO,MAAM,yBAAyB,QAAS,MAAM,KAAG,MAAsD,CAAC;AAE/G,eAAO,MAAM,kBAAkB,SAAU,MAAM,WAAW,MAAM,UAAU,MAAM,WAE/E,CAAC"}

package/build/esm/utils/string.js

@@ -8,4 +8,3 @@ export const removeTrailingUnderscores = (str) => str.replace(TRAILING_UNDERSCOR
 export const conditionalReplace = (base, pattern, value) => {
     return value ? base.replace(pattern, value) : base;
 };
-//# sourceMappingURL=string.js.map

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

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

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

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