@wise/dynamic-flow-client 5.13.2-experimental-e750b58 → 5.13.2

package/build/domain/components/searchComponent/SearchComponent.test.js

@@ -0,0 +1,190 @@
+import { vi } from 'vitest';
+import { wait } from '../../../test-utils';
+import { getUpdateFunctionMock } from '../../mappers/schema/tests/test-utils';
+import { createMarkdownComponent } from '../MarkdownComponent';
+import { createSearchComponent } from './SearchComponent';
+const defaultSearchProps = {
+    uid: '0',
+    emptyMessage: '',
+    initialState: { type: 'layout', content: [] },
+    margin: 'md',
+    title: 'title',
+};
+describe('SearchComponent', () => {
+    describe('when onChange is called', () => {
+        it('searching is debounced', () => {
+            const performSearch = vi.fn().mockImplementation(async () => Promise.resolve([]));
+            const onAction = vi.fn();
+            const mockUpdateFunction = getUpdateFunctionMock(() => component);
+            const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+            component.onChange('query');
+            expect(performSearch).toHaveBeenCalledTimes(0);
+            vi.advanceTimersByTime(500);
+            expect(performSearch).toHaveBeenCalledTimes(1);
+        });
+        it('updates the query state immediately', () => {
+            const performSearch = vi
+                .fn()
+                .mockImplementation(async () => Promise.resolve({ type: 'noResults' }));
+            const onAction = vi.fn();
+            const mockUpdateFunction = getUpdateFunctionMock(() => component);
+            const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+            component.onChange('query');
+            expect(performSearch).toHaveBeenCalledTimes(0);
+            expect(component.query).toBe('query');
+        });
+        describe('after debouncing', () => {
+            it('performs a search', async () => {
+                const performSearch = vi.fn().mockImplementation(async () => {
+                    return Promise.resolve({ type: 'noResults' });
+                });
+                const onAction = vi.fn();
+                const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                component.onChange('query');
+                await vi.advanceTimersByTimeAsync(1000); // debounce time
+                expect(performSearch).toHaveBeenCalled();
+            });
+            it('sets isLoading when search begins, and when search ends sets isLoading to false', async () => {
+                const performSearch = vi.fn().mockImplementation(async () => {
+                    await wait(1000);
+                    return Promise.resolve({ type: 'noResults' });
+                });
+                const onAction = vi.fn();
+                const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                component.onChange('query');
+                await vi.advanceTimersByTimeAsync(500);
+                expect(performSearch).toHaveBeenCalled();
+                expect(component.isLoading).toBe(true);
+                await vi.advanceTimersByTimeAsync(1000);
+                expect(component.isLoading).toBe(false);
+            });
+        });
+        describe('when a valid response is received', () => {
+            describe('and the response is the results type', () => {
+                describe('and results is non-empty', () => {
+                    it('updates results', async () => {
+                        const performSearch = vi.fn().mockImplementation(async () => Promise.resolve({
+                            type: 'results',
+                            results: [{ type: 'action', title: '', action: {} }],
+                        }));
+                        const onAction = vi.fn();
+                        const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                        const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                        component.onChange('query');
+                        await vi.advanceTimersByTimeAsync(500);
+                        expect(performSearch).toHaveBeenCalled();
+                        expect(component.isLoading).toBe(false);
+                        expect(component.state).toStrictEqual(expect.objectContaining({
+                            type: 'results',
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            results: expect.arrayContaining([expect.objectContaining({ type: 'action' })]),
+                        }));
+                    });
+                });
+                describe('and results is empty', () => {
+                    it('updates results', async () => {
+                        const performSearch = vi
+                            .fn()
+                            .mockImplementation(async () => Promise.resolve({ type: 'results', results: [] }));
+                        const onAction = vi.fn();
+                        const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                        const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                        component.onChange('query');
+                        await vi.advanceTimersByTimeAsync(500);
+                        expect(performSearch).toHaveBeenCalled();
+                        expect(component.isLoading).toBe(false);
+                        expect(component.state).toStrictEqual(expect.objectContaining({
+                            type: 'results',
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                            results: expect.arrayContaining([]),
+                        }));
+                    });
+                });
+            });
+            describe('and the response is the modern layout type', () => {
+                it('updates the state to contain the new layout', async () => {
+                    const performSearch = vi.fn().mockImplementation(async () => Promise.resolve({
+                        type: 'layout',
+                        content: [
+                            createMarkdownComponent({
+                                uid: 'markdown',
+                                margin: 'md',
+                                align: 'start',
+                                content: 'Here is some markdown',
+                                size: 'md',
+                            }),
+                        ],
+                    }));
+                    const onAction = vi.fn();
+                    const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                    const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                    component.onChange('query');
+                    await vi.advanceTimersByTimeAsync(500);
+                    expect(performSearch).toHaveBeenCalled();
+                    expect(component.isLoading).toBe(false);
+                    expect(component.state).toStrictEqual(expect.objectContaining({
+                        type: 'layout',
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        content: expect.arrayContaining([
+                            expect.objectContaining({ type: 'markdown', content: 'Here is some markdown' }),
+                        ]),
+                    }));
+                });
+            });
+        });
+        describe('when an invalid response is received', () => {
+            it('sets error string', async () => {
+                const performSearch = vi.fn().mockImplementation(async () => {
+                    throw Error('cannot parse response');
+                });
+                const onAction = vi.fn();
+                const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                component.onChange('query');
+                await vi.advanceTimersByTimeAsync(500);
+                expect(performSearch).toHaveBeenCalled();
+                expect(component.isLoading).toBe(false);
+                expect(component.error).toBeDefined();
+            });
+        });
+        describe('when onClick is called', () => {
+            describe('on an `action` result', () => {
+                it('calls onAction with the result', async () => {
+                    const performSearch = vi.fn();
+                    const onBehavior = vi.fn();
+                    const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                    const component = createSearchComponent(defaultSearchProps, performSearch, onBehavior, mockUpdateFunction);
+                    component.onSelect({
+                        type: 'action',
+                        title: 'title',
+                        value: { id: 'selected-action-id' },
+                    });
+                    expect(onBehavior).toHaveBeenCalledWith(expect.objectContaining({ type: 'action', action: { id: 'selected-action-id' } }));
+                });
+            });
+            describe('on a `search` result', () => {
+                it('performs a search with the new config', async () => {
+                    const performSearch = vi.fn().mockImplementation(async () => Promise.resolve([]));
+                    const onAction = vi.fn();
+                    const mockUpdateFunction = getUpdateFunctionMock(() => component);
+                    const component = createSearchComponent(defaultSearchProps, performSearch, onAction, mockUpdateFunction);
+                    component.onSelect({
+                        type: 'search',
+                        title: 'title',
+                        value: { url: '/new-search', param: 'query', method: 'GET', query: 'new' },
+                    });
+                    expect(performSearch).toHaveBeenCalledWith(expect.objectContaining({
+                        query: 'new',
+                        config: expect.objectContaining({
+                            url: '/new-search',
+                            method: 'GET',
+                            param: 'query',
+                        }),
+                    }));
+                });
+            });
+        });
+    });
+});

package/build/domain/components/step/ExternalConfirmationComponent.js

@@ -0,0 +1,24 @@
+import { getInputUpdateFunction } from '../utils/component-utils';
+export const createExternalConfirmation = (uid, url, onLink, onComponentUpdate) => {
+    const update = getInputUpdateFunction(onComponentUpdate);
+    return {
+        type: 'external-confirmation',
+        kind: 'layout',
+        uid,
+        url,
+        status: 'initial',
+        open() {
+            if (this.status === 'initial' || this.status === 'failure') {
+                const success = onLink(this.url);
+                update(this, (draft) => {
+                    draft.status = success ? 'success' : 'failure';
+                });
+            }
+        },
+        onCancel() {
+            update(this, (draft) => {
+                draft.status = 'dismissed';
+            });
+        },
+    };
+};

package/build/domain/components/step/StepDomainComponent.js

@@ -0,0 +1,78 @@
+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 { getLocalValues, getSubmittableData, getSubmittableDataSync, } from '../../../utils/component-utils';
+import { getInputUpdateFunction } from '../utils/component-utils';
+export const createStepComponent = (stepProps) => {
+    const { uid, stepPolling, stepRefreshAfter, stepPrefetch, onComponentUpdate } = stepProps, rest = __rest(stepProps, ["uid", "stepPolling", "stepRefreshAfter", "stepPrefetch", "onComponentUpdate"]);
+    const update = getInputUpdateFunction(onComponentUpdate);
+    const component = Object.assign(Object.assign({ uid }, rest), { type: 'step', kind: 'step', modals: [], requestCache: stepPrefetch.requestCache, dismissModal() {
+            var _a;
+            (_a = this.modals.at(-1)) === null || _a === void 0 ? void 0 : _a.close();
+        },
+        dismissAllModals() {
+            this._update((draft) => {
+                draft.modals = draft.modals.map((m) => (Object.assign(Object.assign({}, m), { open: false })));
+            });
+        },
+        showModal(modal) {
+            this._update((draft) => {
+                draft.modals = [...draft.modals, modal];
+            });
+        },
+        _update(updateFn) {
+            update(this, updateFn);
+        },
+        getChildren() {
+            return this.externalConfirmation
+                ? [...this.layoutComponents, this.externalConfirmation]
+                : this.layoutComponents;
+        },
+        getModals() {
+            return this.modals;
+        },
+        async getSubmittableValue() {
+            return getSubmittableData(this.schemaComponents);
+        },
+        getSubmittableValueSync() {
+            return getSubmittableDataSync(this.schemaComponents);
+        },
+        getLocalValue() {
+            return getLocalValues(this.schemaComponents);
+        },
+        validate() {
+            return this.schemaComponents.every((inputComponent) => {
+                var _a;
+                return this.referencedSchemaIds.includes((_a = inputComponent.schemaId) !== null && _a !== void 0 ? _a : '')
+                    ? inputComponent.validate()
+                    : true;
+            });
+        },
+        setLoadingState(loadingState) {
+            this._update((draft) => {
+                draft.loadingState = loadingState;
+            });
+        },
+        start() {
+            stepPolling === null || stepPolling === void 0 ? void 0 : stepPolling.start();
+            stepRefreshAfter === null || stepRefreshAfter === void 0 ? void 0 : stepRefreshAfter.start();
+            stepPrefetch.start(this.getSubmittableValueSync());
+        },
+        stop() {
+            stepPolling === null || stepPolling === void 0 ? void 0 : stepPolling.stop();
+            stepRefreshAfter === null || stepRefreshAfter === void 0 ? void 0 : stepRefreshAfter.stop();
+            stepPrefetch.stop();
+            this._update((draft) => {
+                draft.modals = [];
+            });
+        } });
+    return component;
+};

package/build/domain/components/step/ToolbarComponent.js

@@ -0,0 +1 @@
+export {};

package/build/domain/components/utils/WithUpdate.js

@@ -0,0 +1 @@
+export {};

package/build/domain/components/utils/component-utils.js

@@ -0,0 +1,12 @@
+/**
+ * Helper function to update a component.
+ *
+ * @param onComponentUpdate the function that will notify the view layer that something has changed in the domain layer
+ * @returns a function that can be used to update components without the linter shouting at us.
+ */
+export const getInputUpdateFunction = (onComponentUpdate) => {
+    return (component, updateFn) => {
+        updateFn(component);
+        onComponentUpdate();
+    };
+};

package/build/domain/components/utils/debounce.js

@@ -0,0 +1,34 @@
+export const debounce = (callback, waitMs) => {
+    let timeoutId = null;
+    let lastArgs = null;
+    const clearTimer = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        lastArgs = null;
+    };
+    const debouncedFn = (...args) => {
+        lastArgs = args;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            callback(...lastArgs);
+            timeoutId = null;
+            lastArgs = null;
+        }, waitMs);
+    };
+    debouncedFn.cancel = () => {
+        if (timeoutId !== null) {
+            clearTimer();
+        }
+    };
+    debouncedFn.flush = () => {
+        if (timeoutId !== null) {
+            callback(...lastArgs);
+            clearTimer();
+        }
+    };
+    return debouncedFn;
+};

package/build/domain/components/utils/debounce.test.js

@@ -0,0 +1,67 @@
+import { vi } from 'vitest';
+import { debounce } from './debounce';
+describe('debounce', () => {
+    it('will delay function execution until the wait period has passed', () => {
+        const fn = vi.fn();
+        const debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        expect(fn).toHaveBeenCalledTimes(0);
+        vi.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('will call function with provided arguments', () => {
+        const fn = vi.fn();
+        const debouncedFn = debounce(fn, 5);
+        debouncedFn('a', 'b', 'c');
+        vi.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will reset the wait period and ignore previous executions if called within the wait period', () => {
+        const fn = vi.fn();
+        const debouncedFn = debounce(fn, 5);
+        debouncedFn(1, 2, 3);
+        vi.advanceTimersByTime(4);
+        debouncedFn('a', 'b', 'c');
+        vi.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+    });
+    it('will call the same function twice if invoked after the wait period', () => {
+        const fn = vi.fn();
+        const debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        vi.advanceTimersByTime(5);
+        debouncedFn();
+        vi.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    describe('flush', () => {
+        it('will call the callback immediately', () => {
+            const fn = vi.fn();
+            const debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('uses the last passed args', () => {
+            const fn = vi.fn();
+            const debouncedFn = debounce(fn, 5);
+            debouncedFn(1, 2, 3);
+            debouncedFn('a', 'b', 'c');
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+            expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+        });
+    });
+    describe('cancel', () => {
+        it('cancels any waiting callback', () => {
+            const fn = vi.fn();
+            const debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.cancel();
+            vi.advanceTimersByTime(5);
+            expect(fn).toHaveBeenCalledTimes(0);
+        });
+    });
+});

package/build/domain/components/utils/file-utils.js

@@ -0,0 +1,21 @@
+export const toBase64 = async (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.addEventListener('load', () => resolve(reader.result));
+    reader.addEventListener('error', reject);
+    reader.readAsDataURL(file);
+});
+export const base64dataUrltoFile = (dataurl, filename) => {
+    if (!isBase64DataUrl(dataurl)) {
+        return null;
+    }
+    const [, base64data] = dataurl.split(',');
+    return new File([base64ToBytes(base64data)], filename, { type: getMimeType(dataurl) });
+};
+const isBase64DataUrl = (dataurl) => dataurl.startsWith('data:') && dataurl.includes('base64') && dataurl.includes(',');
+const getMimeType = (base64dataUrl) => base64dataUrl.substring('data:'.length).split(';')[0];
+const base64ToBytes = (base64) => {
+    const charCodes = atob(base64)
+        .split('')
+        .map((m) => m.charCodeAt(0));
+    return Uint8Array.from(charCodes);
+};

package/build/domain/components/utils/file-utils.test.js

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { base64dataUrltoFile, toBase64 } from './file-utils';
+describe('toBase64', () => {
+    describe('given a valid file', () => {
+        it('should return a base64 string', async () => {
+            const file = new File(['hello'], 'test.txt', { type: 'text/plain' });
+            await expect(toBase64(file)).resolves.toBe('data:text/plain;base64,aGVsbG8=');
+        });
+    });
+});
+describe('dataURLtoFile', () => {
+    describe('given a valid data URL', () => {
+        const dataurl = 'data:text/plain;base64,aGVsbG8=';
+        it('should return a file that can be encoded back to the given string', async () => {
+            const file = base64dataUrltoFile(dataurl, 'test.txt');
+            expect(file).toBeInstanceOf(File);
+            expect(file.type).toBe('text/plain');
+            expect(file.name).toBe('test.txt');
+            await expect(toBase64(file)).resolves.toBe(dataurl);
+        });
+    });
+    describe('given an invalid data URL', () => {
+        it('should return null', () => {
+            expect(base64dataUrltoFile('invalid', 'test.txt')).toBeNull();
+        });
+    });
+});

package/build/domain/components/utils/getRandomId.js

@@ -0,0 +1 @@
+export const getRandomId = () => Math.random().toString(36).substring(2);

package/build/domain/components/utils/isExactLocalValueMatch.js

@@ -0,0 +1,14 @@
+import { isArrayLocalValue, isObjectLocalValue } from '../../../utils/type-utils';
+export const isExactLocalValueMatch = (valueA, valueB) => {
+    if (isArrayLocalValue(valueA) && isArrayLocalValue(valueB)) {
+        return (valueA.length === valueB.length &&
+            valueA.every((value, index) => isExactLocalValueMatch(value, valueB[index])));
+    }
+    if (isObjectLocalValue(valueA) && isObjectLocalValue(valueB)) {
+        const keysA = Object.keys(valueA);
+        const keysB = Object.keys(valueB);
+        return (keysA.length === keysB.length &&
+            keysA.every((key) => isExactLocalValueMatch(valueA[key], valueB[key])));
+    }
+    return valueA === valueB;
+};

package/build/domain/components/utils/isOrWasValid.js

@@ -0,0 +1,5 @@
+export const isOrWasValid = (getErrors, previous, current) => {
+    const wasValid = getErrors(previous).length === 0 && previous !== null;
+    const isValid = getErrors(current).length === 0;
+    return wasValid || isValid;
+};

package/build/domain/components/utils/isPartialModelMatch.js

@@ -0,0 +1,18 @@
+import { isArrayModel, isObjectModel } from '../../../utils/type-utils';
+import { isNullish } from '../../../utils/type-validators';
+export const isPartialModelMatch = (localModel, incomingModel) => {
+    if (isArrayModel(localModel) && isArrayModel(incomingModel)) {
+        return (localModel.length === incomingModel.length &&
+            localModel.every((value, index) => isPartialModelMatch(value, incomingModel[index])));
+    }
+    if (isObjectModel(localModel) && isObjectModel(incomingModel)) {
+        if (Object.keys(localModel).length === 0 && Object.keys(incomingModel).length === 0) {
+            return true;
+        }
+        const nonNullishKeysInBoth = nonNullishKeys(localModel).filter((key) => nonNullishKeys(incomingModel).includes(key));
+        return (nonNullishKeysInBoth.length > 0 &&
+            nonNullishKeysInBoth.every((key) => isPartialModelMatch(localModel[key], incomingModel[key])));
+    }
+    return localModel === incomingModel;
+};
+const nonNullishKeys = (model) => Object.keys(model).filter((key) => !isNullish(model[key]));

package/build/domain/components/utils/isPartialModelMatch.test.js

@@ -0,0 +1,74 @@
+import { isPartialModelMatch } from './isPartialModelMatch';
+describe('isPartialModelMatch', () => {
+    describe('when both models are arrays', () => {
+        it('will return true if both models are empty', () => {
+            expect(isPartialModelMatch([], [])).toBe(true);
+        });
+        it('will return false if the models have different lengths', () => {
+            expect(isPartialModelMatch([1], [1, 2])).toBe(false);
+            expect(isPartialModelMatch([1, 2], [1])).toBe(false);
+        });
+        it('will return false if any of the items in the array do not partially match', () => {
+            expect(isPartialModelMatch([1], [2])).toBe(false);
+            expect(isPartialModelMatch([[1]], [[2]])).toBe(false);
+            expect(isPartialModelMatch([{ prop: 'value' }], [{ prop: 'different value' }])).toBe(false);
+        });
+        it('will return true if all items in the arrays partially match', () => {
+            expect(isPartialModelMatch([1], [1])).toBe(true);
+        });
+    });
+    describe('when both models are objects', () => {
+        it('wil return true if both localModel and incomingModel are empty', () => {
+            expect(isPartialModelMatch({}, {})).toBe(true);
+        });
+        it('will return false if localModel is empty', () => {
+            expect(isPartialModelMatch({}, { prop: 1 })).toBe(false);
+        });
+        it('will return false if incomingModel is empty', () => {
+            expect(isPartialModelMatch({ prop: 1 }, {})).toBe(false);
+        });
+        it('will return false if the models have matching keys with different values', () => {
+            expect(isPartialModelMatch({ key: 1 }, { key: 2 })).toBe(false);
+            expect(isPartialModelMatch({ key: 2 }, { key: 1 })).toBe(false);
+        });
+        it('will return true if matching keys have the same value', () => {
+            expect(isPartialModelMatch({ key: 1 }, { key: 1 })).toBe(true);
+        });
+        it('will ignore the value of non-matching keys', () => {
+            expect(isPartialModelMatch({ matchingKey: 1 }, { matchingKey: 1, otherKey: 2 })).toBe(true);
+            expect(isPartialModelMatch({ otherKey: 2, matchingKey: 1 }, { matchingKey: 1 })).toBe(true);
+        });
+        it('will ignore the value of nullish keys', () => {
+            expect(isPartialModelMatch({ matchingKey: 1, otherKey: 2 }, { matchingKey: 1, otherKey: null })).toBe(true);
+            expect(isPartialModelMatch({ otherKey: null, matchingKey: 1 }, { matchingKey: 1, otherKey: 2 })).toBe(true);
+            expect(isPartialModelMatch({ matchingKey: 1, otherKey: null }, { matchingKey: 1 })).toBe(true);
+            expect(isPartialModelMatch({ matchingKey: 1 }, { matchingKey: 1, otherKey: null })).toBe(true);
+        });
+        it('looks for matches recursively', () => {
+            expect(isPartialModelMatch({ matchingKey: [{ matchingKey: 2 }] }, { matchingKey: [{ matchingKey: 2 }] })).toBe(true);
+            expect(isPartialModelMatch({ matchingKey: [{ matchingKey: 2 }] }, { matchingKey: [{ matchingKey: 3 }] })).toBe(false);
+        });
+    });
+    describe('when both models are matching primitives', () => {
+        it('will return true if the models are equal', () => {
+            expect(isPartialModelMatch(1, 1)).toBe(true);
+            expect(isPartialModelMatch('value', 'value')).toBe(true);
+            expect(isPartialModelMatch(true, true)).toBe(true);
+        });
+        it('will return false if the models are not equal', () => {
+            expect(isPartialModelMatch(1, 2)).toBe(false);
+            expect(isPartialModelMatch('value', 'different value')).toBe(false);
+            expect(isPartialModelMatch(true, false)).toBe(false);
+        });
+    });
+    describe('when models are of different types', () => {
+        it('will always return false', () => {
+            expect(isPartialModelMatch(null, 1)).toBe(false);
+            expect(isPartialModelMatch(1, null)).toBe(false);
+            expect(isPartialModelMatch({}, [])).toBe(false);
+            expect(isPartialModelMatch([], {})).toBe(false);
+            expect(isPartialModelMatch(1, {})).toBe(false);
+            expect(isPartialModelMatch({}, 1)).toBe(false);
+        });
+    });
+});

package/build/domain/features/eventNames.js

@@ -0,0 +1,24 @@
+export const eventNames = [
+    'Initiated',
+    'Succeeded',
+    'Failed',
+    'Cancelled',
+    'Step Shown',
+    'Action Triggered',
+    'Action Succeeded',
+    'Action Aborted',
+    'Action Failed',
+    'Refresh Triggered',
+    'Refresh Succeeded',
+    'Refresh Aborted',
+    'Refresh Failed',
+    'OneOf Selected',
+    'OneOf Option Selected',
+    'PersistAsync Triggered',
+    'PersistAsync Succeeded',
+    'PersistAsync Failed',
+    'Polling Failed',
+    'ValidationAsync Triggered',
+    'ValidationAsync Succeeded',
+    'ValidationAsync Failed',
+];

package/build/domain/features/events.js

@@ -0,0 +1 @@
+export {};