@wise/dynamic-flow-client 5.12.1 → 5.13.0-experimental-13d828c

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

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

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

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

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

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

@@ -1,12 +0,0 @@
-/**
- * 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

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

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

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

@@ -1,27 +0,0 @@
-/* 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

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

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

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

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

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

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

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

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

package/build/domain/features/persistAsync/getComponentMultiPersistAsync.js

@@ -1,50 +0,0 @@
-import { isNullish } from '../../../utils/type-validators';
-import { getRandomId } from '../../components/utils/getRandomId';
-/**
- * Creates an onPersistAsync handler for a component.
- */
-export const getComponentMultiPersistAsync = (update, performPersistAsync) => 
-/**
- * Will update the persistedState when a new request is made, and will update
- * the value or set errors when the request completes.
- */
-async (component, index, value) => {
-    if (isNullish(value)) {
-        throw new Error('Value must be a file or base64 string.');
-    }
-    const newAbortController = new AbortController();
-    const { signal } = newAbortController;
-    const newSubmission = performPersistAsync({ value, signal })
-        .then((newValue) => {
-        update(component, (draft) => {
-            draft.persistedState[index].lastResponse = newValue;
-        });
-        return newValue;
-    })
-        .catch((error) => {
-        update(component, (draft) => {
-            // The file was not persisted, so delete it
-            draft.persistedState = [
-                ...draft.persistedState.slice(0, index),
-                ...draft.persistedState.slice(index + 1),
-            ];
-            draft.value.splice(index, 1);
-            draft.files.splice(index, 1);
-        });
-        throw error;
-    });
-    update(component, (draft) => {
-        draft.persistedState = [
-            ...draft.persistedState.slice(0, index),
-            {
-                id: getRandomId(),
-                abortController: newAbortController,
-                lastResponse: null,
-                lastSubmitted: null,
-                submission: newSubmission,
-            },
-            ...draft.persistedState.slice(index),
-        ];
-    });
-    return newSubmission;
-};

package/build/domain/features/persistAsync/getInitialPersistedState.js

@@ -1,7 +0,0 @@
-import { isNullish } from '../../../utils/type-validators';
-export const getInitialPersistedState = (lastSubmitted, model) => ({
-    abortController: new AbortController(),
-    lastSubmitted: !isNullish(model) ? (lastSubmitted !== null && lastSubmitted !== void 0 ? lastSubmitted : null) : null,
-    lastResponse: model !== null && model !== void 0 ? model : null,
-    submission: Promise.resolve(model !== null && model !== void 0 ? model : null),
-});

package/build/domain/features/persistAsync/getPerformPersistAsync.js

@@ -1,43 +0,0 @@
-import { isObject, isString } from '../../../utils/type-validators';
-import { constructPayload } from '../utils/http-utils';
-import { getAnalyticsFromErrorResponse } from '../utils/response-utils';
-/**
- * Takes an httpClient and schema persist async config and returns a function that can
- * execute a persist async request.
- */
-export const getPerformPersistAsync = ({ genericErrorMessage, httpClient, persistAsyncConfig, schemaId, logEvent, trackEvent, }) => {
-    const { idProperty, param, method, url } = persistAsyncConfig;
-    const trackFailure = (json) => {
-        const analytics = getAnalyticsFromErrorResponse(json);
-        trackEvent('PersistAsync Failed', Object.assign({ schema: schemaId }, analytics));
-    };
-    return async function performPersistAsync({ value, signal }) {
-        let response;
-        let json;
-        try {
-            trackEvent('PersistAsync Triggered', { schema: schemaId });
-            response = await httpClient(url, constructPayload({ value, signal, requestConfig: { method, param } }));
-            json = (await response.json());
-            if (response.ok && isObject(json)) {
-                trackEvent('PersistAsync Succeeded', { schema: schemaId });
-                if (json[idProperty] === undefined) {
-                    logEvent('error', `Response from persist async did not contain expected property ${idProperty}.`);
-                    throw new Error(genericErrorMessage);
-                }
-                return json[idProperty];
-            }
-        }
-        catch (_a) {
-            trackFailure();
-            throw new Error(genericErrorMessage);
-        }
-        const validationError = !response.ok && isObject(json) ? getValidationError(param, json) : null;
-        trackFailure(json);
-        throw new Error(validationError !== null && validationError !== void 0 ? validationError : genericErrorMessage);
-    };
-};
-const getValidationError = (param, response) => {
-    var _a;
-    const message = (_a = response.validation) === null || _a === void 0 ? void 0 : _a[param];
-    return isString(message) ? message : null;
-};

package/build/domain/features/persistAsync/getPerformPersistAsync.test.js

@@ -1,139 +0,0 @@
-import { vi } from 'vitest';
-import { getMockHttpClient, respondWith } from '../../../test-utils';
-import { getPerformPersistAsync } from './getPerformPersistAsync';
-describe('getPerformPersistAsync', () => {
-    const genericErrorMessage = 'Error';
-    const trackEvent = vi.fn();
-    const logEvent = vi.fn();
-    const signal = {};
-    const persistAsyncConfig = {
-        idProperty: 'id',
-        method: 'POST',
-        param: 'param',
-        url: '/persist',
-    };
-    it('should make the request using the specified parameter', async () => {
-        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ id: 1 }));
-        const spyTrackEvent = vi.fn();
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient: spyHttpClient,
-            trackEvent: spyTrackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-            schemaId: 'schemaId',
-        });
-        await performPersistAsync({ value: 'value', signal });
-        expect(spyHttpClient).toHaveBeenCalledWith('/persist', {
-            body: '{"param":"value"}',
-            headers: { 'Content-Type': 'application/json' },
-            method: 'POST',
-            signal,
-        });
-        expect(spyTrackEvent).toHaveBeenCalledWith('PersistAsync Triggered', expect.objectContaining({ schema: 'schemaId' }));
-    });
-    it('should wrap blobs in form data before submitting', async () => {
-        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ id: 1 }));
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient: spyHttpClient,
-            trackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-        });
-        const file = new File(['file'], 'file.txt');
-        await performPersistAsync({ value: file, signal });
-        expect(spyHttpClient).toHaveBeenCalledWith('/persist', {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            body: expect.any(FormData),
-            headers: {},
-            method: 'POST',
-            signal,
-        });
-    });
-    describe('when the response is ok', () => {
-        it('should read response value from idProperty', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ id: 1 }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            const result = await performPersistAsync({ value: 'value', signal });
-            expect(result).toBe(1);
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Succeeded', expect.objectContaining({ schema: 'schemaId' }));
-        });
-        it('should throw a generic error if the response is not an object', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith(1),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow(genericErrorMessage);
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-        });
-    });
-    describe.each([[401], [422], [504]])('when the response is %s', (errorStatusCode) => {
-        it('should throw if the response includes a validation message', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ validation: { param: 'error with this field' } }, { status: errorStatusCode }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow('error with this field');
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-        });
-        it('should include analytics if passed', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ validation: { param: 'error with this field' }, analytics: { some: 'extras' } }, { status: errorStatusCode }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow('error with this field');
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId', some: 'extras' }));
-        });
-    });
-    it('should throw a generic error if request fails', async () => {
-        const httpClient = getMockHttpClient({
-            '/persist': async () => Promise.reject(new Error()),
-        });
-        const spyTrackEvent = vi.fn();
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient,
-            trackEvent: spyTrackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-            schemaId: 'schemaId',
-        });
-        await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow(genericErrorMessage);
-        expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-    });
-});