@wise/dynamic-flow-client 5.28.0 → 5.29.0-experimental-f7c2300

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,56 +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 are not made
-    const keys = new Set();
-    const start = (model) => {
-        if (keys.size > 0) {
-            return;
-        }
-        submissionBehaviors.forEach((behavior) => {
-            const request = getPrefetchableRequest(behavior, model);
-            if (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 };
-};
-export const createRequestFromSubflowLaunchConfig = (launchConfig) => {
-    return launchConfig.type === 'dynamic' ? launchConfig.request : undefined;
-};
-const getPrefetchableRequest = (behavior, model) => {
-    if (behavior.type === 'action' && behavior.action.prefetch) {
-        return createRequestFromAction(behavior.action, model);
-    }
-    if (behavior.type === 'subflow' &&
-        behavior.launchConfig.type === 'dynamic' &&
-        behavior.launchConfig.request.prefetch) {
-        return behavior.launchConfig.request;
-    }
-    return null;
-};

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' }, track: false });
-        }, 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}`);
-            });
-        });
-    });
-});

package/build/domain/features/schema-on-change/getDebouncedSchemaOnChange.js

@@ -1,50 +0,0 @@
-/* eslint-disable functional/immutable-data */
-import { debounce } from '../../components/utils/debounce';
-import { isOrWasValid } from '../../components/utils/isOrWasValid';
-const debounceDelay = 1000;
-export const getDebouncedSchemaOnChange = (onChange, getValidationErrors) => {
-    if (!onChange) {
-        return undefined;
-    }
-    const performOnChange = onChange.behaviorType === 'refresh'
-        ? getSelectiveDebouncedSchemaOnChange(onChange, getValidationErrors)
-        : debounce(onChange, debounceDelay);
-    return performOnChange;
-};
-const getSelectiveDebouncedSchemaOnChange = (onChange, getValidationErrors) => {
-    let behaviorControl = { abort: () => { } };
-    let timeoutId = null;
-    const clearTimer = () => {
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = null;
-    };
-    const flush = () => {
-        if (timeoutId !== null) {
-            void onChange().then((bc) => {
-                behaviorControl = bc;
-            });
-            clearTimer();
-        }
-    };
-    const debouncedOnChange = (prevValue, updatedValue) => {
-        var _a;
-        const valid = isOrWasValid(getValidationErrors, prevValue, updatedValue);
-        const isPending = timeoutId !== null;
-        if (valid || isPending) {
-            (_a = behaviorControl.abort) === null || _a === void 0 ? void 0 : _a.call(behaviorControl);
-            clearTimer();
-            timeoutId = setTimeout(() => flush(), debounceDelay);
-        }
-    };
-    debouncedOnChange.cancel = () => {
-        var _a;
-        clearTimer();
-        (_a = behaviorControl.abort) === null || _a === void 0 ? void 0 : _a.call(behaviorControl);
-    };
-    debouncedOnChange.flush = () => {
-        flush();
-    };
-    return debouncedOnChange;
-};

package/build/domain/features/schema-on-change/getSchemaOnChange.js

@@ -1,38 +0,0 @@
-import { normaliseBehavior } from '../../mappers/utils/behavior-utils';
-export const getSchemaOnChange = (schema, onBehavior) => {
-    var _a, _b;
-    const behavior = (_b = (_a = getBehaviorFromSchemaOnChange(schema)) !== null && _a !== void 0 ? _a : getBehaviorFromSchemaRefreshStepOnChange(schema)) !== null && _b !== void 0 ? _b : undefined;
-    if (behavior) {
-        const onChange = async () => onBehavior(behavior);
-        // eslint-disable-next-line functional/immutable-data
-        onChange.behaviorType = behavior.type;
-        return onChange;
-    }
-    return undefined;
-};
-const getBehaviorFromSchemaOnChange = (schema) => {
-    var _a;
-    if ('onChange' in schema && schema.onChange) {
-        const { $id, analyticsId, onChange } = schema;
-        const behavior = Object.assign(Object.assign({}, normaliseBehavior(onChange, [])), { analytics: { schema: (_a = analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id) !== null && _a !== void 0 ? _a : '' } });
-        return behavior;
-    }
-    return undefined;
-};
-const getBehaviorFromSchemaRefreshStepOnChange = (schema) => {
-    var _a, _b, _c;
-    if (('refreshStepOnChange' in schema && ((_a = schema.refreshStepOnChange) !== null && _a !== void 0 ? _a : false)) ||
-        ('refreshFormOnChange' in schema && ((_b = schema.refreshFormOnChange) !== null && _b !== void 0 ? _b : false))) {
-        const { $id, analyticsId } = schema;
-        const refreshUrl = 'refreshUrl' in schema ? schema.refreshUrl : undefined;
-        const refreshFormUrl = 'refreshFormUrl' in schema ? schema.refreshFormUrl : undefined;
-        const behavior = {
-            type: 'refresh',
-            analytics: { schema: (_c = analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id) !== null && _c !== void 0 ? _c : '' },
-            url: refreshUrl !== null && refreshUrl !== void 0 ? refreshUrl : refreshFormUrl,
-            track: false,
-        };
-        return behavior;
-    }
-    return undefined;
-};

package/build/domain/features/search/getPerformSearchFunction.js

@@ -1,75 +0,0 @@
-import { isArray, isObject } from '../../../utils/type-validators';
-export const getPerformSearchFunction = (httpClient, mapLayoutToDomainComponent, defaultConfig) => {
-    let latestSuccessfulRequestHash = hashRequest('', defaultConfig);
-    let latestSuccessfulResults = null;
-    return async ({ config = defaultConfig, query, signal }) => {
-        const requestHash = hashRequest(query, config);
-        if (requestHash !== latestSuccessfulRequestHash) {
-            const { method, param, url } = config;
-            const headers = { 'Content-Type': 'application/json' };
-            const response = await (method === 'GET'
-                ? httpClient(addQueryParameter(url, param, query), {
-                    method,
-                    headers,
-                    signal,
-                })
-                : httpClient(url, {
-                    method,
-                    headers,
-                    signal,
-                    body: JSON.stringify({ [param]: query }),
-                }));
-            const results = await parseResponse(response);
-            // eslint-disable-next-line require-atomic-updates
-            latestSuccessfulRequestHash = requestHash;
-            if (results.type === 'layout') {
-                const mappedLayoutResult = {
-                    type: 'layout',
-                    content: results.content.map(mapLayoutToDomainComponent),
-                };
-                latestSuccessfulResults = mappedLayoutResult;
-                return mappedLayoutResult;
-            }
-            latestSuccessfulResults = results;
-            return results;
-        }
-        return latestSuccessfulResults;
-    };
-};
-const parseResponse = async (response) => {
-    if (response.ok) {
-        const body = await response.json().catch(() => null);
-        if (isValidResponseBody(body)) {
-            if (body.type === 'layout') {
-                return body;
-            }
-            if (body.results) {
-                return {
-                    type: 'results',
-                    results: body.results,
-                };
-            }
-        }
-    }
-    throw Error('error response');
-};
-const addQueryParameter = (url, key, value) => {
-    const [urlBase, urlQuery] = url.split('?');
-    const urlQueryParams = new URLSearchParams(urlQuery);
-    urlQueryParams.set(key, value);
-    return `${urlBase}?${urlQueryParams.toString()}`;
-};
-const isValidResponseBody = (body) => {
-    if (!isObject(body)) {
-        return false;
-    }
-    if ('results' in body) {
-        return (isArray(body.results) &&
-            body.results.every((result) => isObject(result) && 'title' in result && 'type' in result && 'value' in result));
-    }
-    if ('type' in body && body.type === 'layout' && 'content' in body) {
-        return isArray(body.content);
-    }
-    return false;
-};
-const hashRequest = (query, config) => JSON.stringify({ query, config });