@wise/dynamic-flow-client 5.13.2 → 5.13.3

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' }));
-    });
-});

package/build/domain/features/polling/getStepPolling.js

@@ -1,50 +0,0 @@
-import { getDomainLayerBehavior } from '../../mappers/utils/behavior-utils';
-export const getStepPolling = ({ pollingConfig, logEvent, onBehavior, onPoll, registerSubmissionBehavior, }) => {
-    const { interval, delay = interval, maxAttempts, url, onError } = pollingConfig;
-    let abortController = new AbortController();
-    let intervalRef = null;
-    let hasCompleted = false;
-    if (delay == null) {
-        throw new Error('Polling configuration must include delay or interval');
-    }
-    const onErrorBehavior = getDomainLayerBehavior(onError, [], registerSubmissionBehavior);
-    let attempts = 0;
-    const poll = () => {
-        attempts += 1;
-        abortController.abort();
-        abortController = new AbortController();
-        const { signal } = abortController;
-        onPoll(url, onErrorBehavior, signal)
-            .then((result) => {
-            if (result) {
-                complete();
-                return;
-            }
-            if (attempts >= maxAttempts && !signal.aborted) {
-                complete();
-                void onBehavior(onErrorBehavior);
-            }
-        })
-            .catch(() => { });
-    };
-    const complete = () => {
-        hasCompleted = true;
-        stop();
-    };
-    const start = () => {
-        if (hasCompleted) {
-            return;
-        }
-        intervalRef = setInterval(poll, delay * 1000);
-        poll();
-    };
-    const stop = () => {
-        if (!intervalRef) {
-            logEvent('warning', 'Attempted to stop polling but it was not started');
-            return;
-        }
-        clearInterval(intervalRef);
-        abortController.abort();
-    };
-    return { start, stop };
-};

package/build/domain/features/polling/getStepPolling.test.js

@@ -1,115 +0,0 @@
-import { getStepPolling } from './getStepPolling';
-import { vi } from 'vitest';
-describe('getStepPolling', () => {
-    it('when called will start polling', async () => {
-        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
-        getStepPolling({
-            pollingConfig: {
-                url: '/polling',
-                maxAttempts: 5,
-                interval: 1,
-                onError: { action: { url: '/failure' } },
-            },
-            logEvent: vi.fn(),
-            onBehavior: vi.fn(),
-            onPoll,
-            registerSubmissionBehavior: vi.fn(),
-        }).start();
-        expect(onPoll).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(1000);
-        expect(onPoll).toHaveBeenCalledTimes(2);
-        await vi.advanceTimersByTimeAsync(1000);
-        expect(onPoll).toHaveBeenCalledTimes(3);
-    });
-    it('the interval between polls is defined by the pollingConfig', async () => {
-        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
-        const interval = 4;
-        getStepPolling({
-            pollingConfig: {
-                url: '/polling',
-                maxAttempts: 5,
-                interval,
-                onError: { action: { url: '/failure' } },
-            },
-            logEvent: vi.fn(),
-            onBehavior: vi.fn(),
-            onPoll,
-            registerSubmissionBehavior: vi.fn(),
-        }).start();
-        expect(onPoll).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(interval * 1000);
-        expect(onPoll).toHaveBeenCalledTimes(2);
-        await vi.advanceTimersByTimeAsync(interval * 1000);
-        expect(onPoll).toHaveBeenCalledTimes(3);
-    });
-    it('will only poll a number of times defined by maxAttempts - and will trigger the onError action if it reaches this without a valid response', async () => {
-        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve(false));
-        const onBehavior = vi.fn();
-        getStepPolling({
-            pollingConfig: {
-                url: '/polling',
-                maxAttempts: 5,
-                interval: 1,
-                onError: { action: { url: '/failure' } },
-            },
-            logEvent: vi.fn(),
-            onBehavior,
-            onPoll,
-            registerSubmissionBehavior: vi.fn(),
-        }).start();
-        await vi.advanceTimersByTimeAsync(5000);
-        expect(onPoll).toHaveBeenCalledTimes(5);
-        expect(onBehavior).toHaveBeenCalledTimes(1);
-        expect(onBehavior).toHaveBeenCalledWith(expect.objectContaining({
-            type: 'action',
-            action: expect.objectContaining({ url: '/failure' }),
-        }));
-    });
-    it('will stop polling once a flow response is received, and it will not restart polling if start is called again', async () => {
-        const onPoll = vi.fn().mockImplementation(async () => {
-            // Simulate receiving a flow response, which should stop polling and resolve to true
-            return Promise.resolve(true);
-        });
-        const polling = getStepPolling({
-            pollingConfig: {
-                url: '/polling',
-                maxAttempts: 5,
-                interval: 1,
-                onError: { action: { url: '/failure' } },
-            },
-            logEvent: vi.fn(),
-            onBehavior: vi.fn(),
-            onPoll,
-            registerSubmissionBehavior: vi.fn(),
-        });
-        polling.start();
-        expect(onPoll).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(1000);
-        expect(onPoll).toHaveBeenCalledTimes(1);
-        polling.start();
-        await vi.advanceTimersByTimeAsync(1000);
-        expect(onPoll).toHaveBeenCalledTimes(1);
-    });
-    it('returns an object with a function that stops polling', async () => {
-        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
-        const { start, stop } = getStepPolling({
-            pollingConfig: {
-                url: '/polling',
-                maxAttempts: 5,
-                interval: 1,
-                onError: { action: { url: '/failure' } },
-            },
-            logEvent: vi.fn(),
-            onBehavior: vi.fn(),
-            onPoll,
-            registerSubmissionBehavior: vi.fn(),
-        });
-        start();
-        expect(onPoll).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(onPoll).toHaveBeenCalledTimes(3);
-        stop();
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(onPoll).toHaveBeenCalledTimes(3);
-    });
-});

package/build/domain/features/prefetch/getStepPrefetch.js

@@ -1,43 +0,0 @@
-import { createRequestFromAction } from '../../../controller/executeSubmission';
-import { makeRequestCacheKey, makeRequestCacheWithParent } from './request-cache';
-export const getStepPrefetch = (httpClient, flowRequestCache, submissionBehaviors) => {
-    const requestCache = makeRequestCacheWithParent(flowRequestCache);
-    // keep track of all prefetched actions in this step so duplicate requests
-    // aren't made
-    const keys = new Set();
-    const start = (model) => {
-        if (keys.size > 0) {
-            return;
-        }
-        submissionBehaviors.forEach((behavior) => {
-            const request = behavior.type === 'action'
-                ? createRequestFromAction(behavior.action, model)
-                : behavior.launchConfig.request;
-            const requestParams = [
-                request.url,
-                {
-                    body: JSON.stringify(request.body),
-                    method: request.method,
-                    headers: { 'Content-Type': 'application/json' },
-                },
-            ];
-            try {
-                const key = makeRequestCacheKey(requestParams);
-                if (keys.has(key)) {
-                    return;
-                }
-                const responsePromise = httpClient(...requestParams).catch(() => null);
-                requestCache.set(requestParams, responsePromise);
-                // eslint-disable-next-line functional/immutable-data
-                keys.add(key);
-            }
-            catch (_a) {
-                // if fetch fails synchronously, we do not cache the request
-            }
-        });
-    };
-    const stop = () => {
-        // no-op for now
-    };
-    return { requestCache, start, stop };
-};

package/build/domain/features/prefetch/request-cache.js

@@ -1,49 +0,0 @@
-/* we can disable this rule here because a cache is inherently mutable */
-/* eslint-disable functional/immutable-data */
-export const makeRequestCacheWithParent = (parent) => {
-    const map = new Map();
-    const cache = {
-        get: (requestParams) => {
-            var _a;
-            const key = makeRequestCacheKey(requestParams);
-            const promise = (_a = map.get(key)) !== null && _a !== void 0 ? _a : parent === null || parent === void 0 ? void 0 : parent.get(requestParams);
-            map.delete(key);
-            return promise;
-        },
-        set: (requestParams, responsePromise) => {
-            return map.set(makeRequestCacheKey(requestParams), responsePromise);
-        },
-    };
-    return cache;
-};
-export const makeRequestCache = (initialValues = []) => {
-    const cache = makeRequestCacheWithParent(undefined);
-    initialValues.forEach(([requestParams, responsePromise]) => {
-        cache.set(requestParams, responsePromise);
-    });
-    return cache;
-};
-export const normaliseRequestCache = (cache) => {
-    if (cache === undefined) {
-        return makeRequestCache();
-    }
-    if (isRequestCacheInstance(cache)) {
-        return cache;
-    }
-    return makeRequestCache(cache);
-};
-const isRequestCacheInstance = (cache) => {
-    return !cache || !Array.isArray(cache);
-};
-export const makeRequestCacheKey = (requestParams) => {
-    var _a, _b;
-    const [input, init] = requestParams;
-    const url = typeof input === 'string' || input instanceof URL ? input.toString() : input.url;
-    const key = JSON.stringify({
-        url,
-        method: (_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : 'GET',
-        headers: (init === null || init === void 0 ? void 0 : init.headers) ? Array.from(new Headers(init.headers).entries()) : [],
-        body: (_b = init === null || init === void 0 ? void 0 : init.body) !== null && _b !== void 0 ? _b : null,
-    });
-    return key;
-};

package/build/domain/features/prefetch/request-cache.test.js

@@ -1,70 +0,0 @@
-import { makeRequestCache, makeRequestCacheWithParent } from './request-cache';
-describe('RequestCache', () => {
-    it('should.set and.get requests correctly, discriminating by URL and method', async () => {
-        var _a, _b, _c, _d;
-        const cache = makeRequestCache();
-        cache.set(['/request-a', { method: 'GET' }], Promise.resolve(new Response('cached response: a GET')));
-        cache.set(['/request-a', { method: 'POST' }], Promise.resolve(new Response('cached response: a POST')));
-        cache.set(['/request-b', { method: 'GET' }], Promise.resolve(new Response('cached response: b GET')));
-        cache.set(['/request-b', { method: 'POST' }], Promise.resolve(new Response('cached response: b POST')));
-        const promiseAget = cache.get(['/request-a', { method: 'GET' }]);
-        expect(promiseAget).toBeDefined();
-        expect(promiseAget && (await ((_a = (await promiseAget)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: a GET');
-        const nonCachedPromise = cache.get(['/request-c', { method: 'GET' }]);
-        expect(nonCachedPromise).toBeUndefined();
-        const promiseApost = cache.get(['/request-a', { method: 'POST' }]);
-        expect(promiseApost).toBeDefined();
-        expect(promiseApost && (await ((_b = (await promiseApost)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: a POST');
-        const promiseBget = cache.get(['/request-b', { method: 'GET' }]);
-        expect(promiseBget).toBeDefined();
-        expect(promiseBget && (await ((_c = (await promiseBget)) === null || _c === void 0 ? void 0 : _c.text()))).toBe('cached response: b GET');
-        const promiseBpost = cache.get(['/request-b', { method: 'POST' }]);
-        expect(promiseBpost).toBeDefined();
-        expect(promiseBpost && (await ((_d = (await promiseBpost)) === null || _d === void 0 ? void 0 : _d.text()))).toBe('cached response: b POST');
-    });
-    it('should also discriminate when headers are different', async () => {
-        var _a, _b;
-        const cache = makeRequestCache();
-        cache.set(['/request-a', { headers: { 'X-Custom-Header': 'Value1' } }], Promise.resolve(new Response('cached response: header Value1')));
-        cache.set(['/request-a', { headers: { 'X-Custom-Header': 'Value2' } }], Promise.resolve(new Response('cached response: header Value2')));
-        const promiseHeader1 = cache.get(['/request-a', { headers: { 'X-Custom-Header': 'Value1' } }]);
-        expect(promiseHeader1).toBeDefined();
-        expect(promiseHeader1 && (await ((_a = (await promiseHeader1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: header Value1');
-        const promiseHeader2 = cache.get(['/request-a', { headers: { 'X-Custom-Header': 'Value2' } }]);
-        expect(promiseHeader2).toBeDefined();
-        expect(promiseHeader2 && (await ((_b = (await promiseHeader2)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: header Value2');
-    });
-    it('should also discriminate when bodies are different', async () => {
-        var _a, _b;
-        const cache = makeRequestCache();
-        cache.set(['/request-a', { method: 'POST', body: 'body1' }], Promise.resolve(new Response('cached response: body1')));
-        cache.set(['/request-a', { method: 'POST', body: 'body2' }], Promise.resolve(new Response('cached response: body2')));
-        const promiseBody1 = cache.get(['/request-a', { method: 'POST', body: 'body1' }]);
-        expect(promiseBody1).toBeDefined();
-        expect(promiseBody1 && (await ((_a = (await promiseBody1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: body1');
-        const promiseBody2 = cache.get(['/request-a', { method: 'POST', body: 'body2' }]);
-        expect(promiseBody2).toBeDefined();
-        expect(promiseBody2 && (await ((_b = (await promiseBody2)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: body2');
-    });
-    describe('when given a parent cache', () => {
-        it('gets from the child cache first if present', async () => {
-            var _a;
-            const parent = makeRequestCache();
-            parent.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: abc')));
-            const child = makeRequestCacheWithParent(parent);
-            child.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: def')));
-            const promiseBody = child.get(['/abc', { method: 'POST', body: 'abc' }]);
-            expect(promiseBody).toBeDefined();
-            expect(promiseBody && (await ((_a = (await promiseBody)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: def');
-        });
-        it('gets from the parent cache if not present in the child', async () => {
-            var _a;
-            const parent = makeRequestCache();
-            parent.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: abc')));
-            const child = makeRequestCacheWithParent(parent);
-            const promiseBody1 = child.get(['/abc', { method: 'POST', body: 'abc' }]);
-            expect(promiseBody1).toBeDefined();
-            expect(promiseBody1 && (await ((_a = (await promiseBody1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: abc');
-        });
-    });
-});

package/build/domain/features/refreshAfter/getStepRefreshAfter.js

@@ -1,24 +0,0 @@
-const ONE_SECOND = 1000;
-export const getStepRefreshAfter = ({ refreshAfter, logEvent, onBehavior, }) => {
-    let timeout = null;
-    const targetTime = new Date(refreshAfter).getTime();
-    if (typeof refreshAfter !== 'string' || Number.isNaN(targetTime)) {
-        throw new Error(`Invalid refreshAfter value: ${String(refreshAfter)}`);
-    }
-    const start = () => {
-        const timeLeft = Math.max(targetTime - Date.now(), ONE_SECOND);
-        timeout = setTimeout(() => {
-            void onBehavior({ type: 'refresh', analytics: { schema: 'refreshAfter' } });
-        }, timeLeft);
-    };
-    return {
-        start,
-        stop: () => {
-            if (!timeout) {
-                logEvent('warning', 'Attempted to stop refreshAfter but it was not started');
-                return;
-            }
-            clearTimeout(timeout);
-        },
-    };
-};

package/build/domain/features/refreshAfter/getStepRefreshAfter.test.js

@@ -1,40 +0,0 @@
-import { vi } from 'vitest';
-import { getStepRefreshAfter } from './getStepRefreshAfter';
-describe('getStepRefreshAfter', () => {
-    describe('valid ISO 8601 strings (and supported by JS Date)', () => {
-        const validIso8601Strings = [
-            ['date, hours, minutes, seconds, no timezone', '2025-03-12T12:00:00'],
-            ['date, hours, minutes, seconds, timezone Z', '2025-03-12T12:00:00Z'],
-            ['date, hours, minutes, seconds, timezone +01:00', '2025-03-12T12:00:00+01:00'],
-            ['date, hours, minutes, seconds, timezone -01:00', '2025-03-12T12:00:00-01:00'],
-            ['date, hours, minutes, seconds.milliseconds, timezone Z', '2025-03-12T12:00:00.000Z'],
-            [
-                'date, hours, minutes, seconds.milliseconds, timezone +HH:mm',
-                '2025-03-12T12:00:00.000+01:00',
-            ],
-            [
-                'date, hours, minutes, seconds.milliseconds, timezone +HHmm',
-                '2025-03-12T12:00:00.000+0100',
-            ],
-        ];
-        describe.each(validIso8601Strings)('%s', (_, refreshAfter) => {
-            it(`it returns a StepRefreshAfter object for "${refreshAfter}"`, () => {
-                expect(getStepRefreshAfter({ refreshAfter, logEvent: vi.fn(), onBehavior: vi.fn() })).toBeDefined();
-            });
-        });
-    });
-    describe('invalid ISO 8601 strings (or not supported by JS Date)', () => {
-        const invalidIso8601Strings = [
-            ['random word', 'banana'],
-            ['random word', 'now'],
-            ['unix timestamp', '1741780800'],
-            ['basic date string: missing dashes and colons', '20250312T120000'],
-            ['two-digit timezone +HH', '2025-03-12T12:00:00.000+01'],
-        ];
-        describe.each(invalidIso8601Strings)('%s', (_, refreshAfter) => {
-            it(`it should throw for "${refreshAfter}"`, () => {
-                expect(() => getStepRefreshAfter({ refreshAfter, logEvent: vi.fn(), onBehavior: vi.fn() })).toThrow(`Invalid refreshAfter value: ${refreshAfter}`);
-            });
-        });
-    });
-});