@wise/dynamic-flow-client 5.25.1 → 5.25.2

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

@@ -0,0 +1,301 @@
+import { mapLayoutToComponent } from '../../mappers/mapLayoutToComponent';
+import { getMockMapperProps } from '../../mappers/schema/tests/test-utils';
+import { getPerformSearchFunction } from './getPerformSearchFunction';
+import { vi } from 'vitest';
+const mockLayoutMapper = vi.fn().mockImplementation((layout) => {
+    return mapLayoutToComponent('uid', layout, getMockMapperProps(), []);
+});
+describe('getSearchFunction returns a function which', () => {
+    describe('when no config is provided', () => {
+        describe('when the default method is GET', () => {
+            const defaultConfig = {
+                url: '/testing',
+                method: 'GET',
+                param: 'query',
+            };
+            it('should use the default config', async () => {
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(httpClient).toHaveBeenCalledWith(`/testing?${defaultConfig.param}=query`, expect.objectContaining({}));
+            });
+        });
+        describe('when the default method is POST', () => {
+            const defaultConfig = {
+                url: '/testing',
+                method: 'POST',
+                param: 'query',
+            };
+            it('should use the default config', async () => {
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(httpClient).toHaveBeenCalledWith('/testing', expect.objectContaining({ method: 'POST', body: JSON.stringify({ query: 'query' }) }));
+            });
+        });
+    });
+    describe('when another config is provided', () => {
+        it('ignores the default config', async () => {
+            const defaultConfig = {
+                url: '/old-testing',
+                method: 'GET',
+                param: 'query',
+            };
+            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
+            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+            const abortController = new AbortController();
+            await searchFn({
+                query: 'query',
+                config: { method: 'POST', param: 'term', url: '/new-testing' },
+                signal: abortController.signal,
+            });
+            expect(httpClient).toHaveBeenCalledWith('/new-testing', expect.objectContaining({ method: 'POST', body: JSON.stringify({ term: 'query' }) }));
+        });
+    });
+    describe('when a response is valid (legacy results type)', () => {
+        describe('and the results are empty', () => {
+            it('returns an empty array', async () => {
+                const defaultConfig = {
+                    url: '/testing',
+                    method: 'GET',
+                    param: 'query',
+                };
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                const result = await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(result).toStrictEqual(expect.objectContaining({
+                    type: 'results',
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    results: expect.arrayContaining([]),
+                }));
+            });
+        });
+        describe('and the results is not empty', () => {
+            it('returns the results', async () => {
+                const defaultConfig = {
+                    url: '/testing',
+                    method: 'GET',
+                    param: 'query',
+                };
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
+                    results: [
+                        { type: 'action', title: '', value: {} },
+                        {
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        },
+                    ],
+                }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                const result = await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(result).toStrictEqual(expect.objectContaining({
+                    type: 'results',
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    results: expect.arrayContaining([
+                        expect.objectContaining({
+                            type: 'action',
+                            title: '',
+                            value: {},
+                        }),
+                        expect.objectContaining({
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        }),
+                    ]),
+                }));
+            });
+        });
+    });
+    describe('when a response is valid (modern results type)', () => {
+        describe('and the results are empty', () => {
+            it('returns an empty array', async () => {
+                const defaultConfig = {
+                    url: '/testing',
+                    method: 'GET',
+                    param: 'query',
+                };
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ type: 'results', results: [] }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                const result = await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(result).toStrictEqual(expect.objectContaining({
+                    type: 'results',
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    results: expect.arrayContaining([]),
+                }));
+            });
+        });
+        describe('and the results is not empty', () => {
+            it('returns the results', async () => {
+                const defaultConfig = {
+                    url: '/testing',
+                    method: 'GET',
+                    param: 'query',
+                };
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
+                    type: 'results',
+                    results: [
+                        { type: 'action', title: '', value: {} },
+                        {
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        },
+                    ],
+                }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                const result = await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(result).toStrictEqual(expect.objectContaining({
+                    type: 'results',
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    results: expect.arrayContaining([
+                        expect.objectContaining({
+                            type: 'action',
+                            title: '',
+                            value: {},
+                        }),
+                        expect.objectContaining({
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        }),
+                    ]),
+                }));
+            });
+        });
+    });
+    describe('when a response is valid (modern layout type)', () => {
+        it('returns the mapped layouts', async () => {
+            const defaultConfig = {
+                url: '/testing',
+                method: 'GET',
+                param: 'query',
+            };
+            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
+                type: 'layout',
+                content: [
+                    {
+                        type: 'markdown',
+                        content: 'Here is some markdown',
+                    },
+                ],
+            }))));
+            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+            const abortController = new AbortController();
+            const result = await searchFn({
+                query: 'query',
+                signal: abortController.signal,
+            });
+            expect(result).toStrictEqual(expect.objectContaining({
+                type: 'layout',
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                content: expect.arrayContaining([
+                    expect.objectContaining({
+                        type: 'markdown',
+                        uid: 'uid',
+                        content: 'Here is some markdown',
+                    }),
+                ]),
+            }));
+        });
+        describe('and the results is not empty', () => {
+            it('returns the results', async () => {
+                const defaultConfig = {
+                    url: '/testing',
+                    method: 'GET',
+                    param: 'query',
+                };
+                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
+                    type: 'results',
+                    results: [
+                        { type: 'action', title: '', value: {} },
+                        {
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        },
+                    ],
+                }))));
+                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+                const abortController = new AbortController();
+                const result = await searchFn({
+                    query: 'query',
+                    signal: abortController.signal,
+                });
+                expect(result).toStrictEqual(expect.objectContaining({
+                    type: 'results',
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    results: expect.arrayContaining([
+                        expect.objectContaining({
+                            type: 'action',
+                            title: '',
+                            value: {},
+                        }),
+                        expect.objectContaining({
+                            type: 'search',
+                            title: '',
+                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
+                        }),
+                    ]),
+                }));
+            });
+        });
+    });
+    describe('when a response has an invalid body', () => {
+        it('throws', async () => {
+            const defaultConfig = {
+                url: '/testing',
+                method: 'GET',
+                param: 'query',
+            };
+            const httpClient = vi.fn(async () => Promise.resolve(new Response('invalid body')));
+            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+            const abortController = new AbortController();
+            await expect(searchFn({
+                query: 'query',
+                signal: abortController.signal,
+            })).rejects.toThrow();
+        });
+    });
+    describe('when a response is non-2xx', () => {
+        it('throws', async () => {
+            const defaultConfig = {
+                url: '/testing',
+                method: 'GET',
+                param: 'query',
+            };
+            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }), { status: 400 })));
+            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
+            const abortController = new AbortController();
+            await expect(searchFn({
+                query: 'query',
+                signal: abortController.signal,
+            })).rejects.toThrow();
+        });
+    });
+});

package/build/domain/features/summary/summary-utils.js

@@ -0,0 +1,37 @@
+import { isString } from '../../../utils/type-validators';
+import { getDomainLayerMedia } from '../../mappers/utils/media-utils';
+/** A summariser that accepts a schema and returns a function that can form a summary based on a value. */
+export const getSummariser = (schema) => (value) => {
+    const { summary, icon, image, media } = schema;
+    const stringValueOrNull = isString(value) ? value : null;
+    return summaryIfProvides(summary, { value: stringValueOrNull, icon, image, media });
+};
+export const getConstSummary = (schema, model) => {
+    const { summary, icon, image, media } = schema;
+    const value = isString(model) ? model : null;
+    return summaryIfProvides(summary, { value, icon, image, media });
+};
+export const summariseFromChildren = (components) => components.reduce((acc, component) => mergeSummaries(acc, component.getSummary()), {});
+// If there are duplicate props, the first takes precedence
+export const mergeSummaries = (summaryA, summaryB) => { var _a, _b, _c; return ({
+    title: (_a = summaryA.title) !== null && _a !== void 0 ? _a : summaryB.title,
+    description: (_b = summaryA.description) !== null && _b !== void 0 ? _b : summaryB.description,
+    media: (_c = summaryA.media) !== null && _c !== void 0 ? _c : summaryB.media,
+}); };
+const summaryIfProvides = (summary, { value = null, icon, image, media, }) => {
+    var _a;
+    if (!summary) {
+        return {};
+    }
+    const providesMedia = (_a = summary.providesMedia) !== null && _a !== void 0 ? _a : (Boolean(summary.providesIcon) || Boolean(summary.providesImage));
+    const providedMedia = getDomainLayerMedia({
+        icon: summary.providesIcon ? icon : undefined,
+        image: summary.providesImage ? image : undefined,
+        media,
+    });
+    return {
+        title: (summary.providesTitle && value) || undefined,
+        description: (summary.providesDescription && value) || undefined,
+        media: providesMedia ? providedMedia : undefined,
+    };
+};

package/build/domain/features/summary/summary-utils.test.js

@@ -0,0 +1,125 @@
+import { getSummariser, getConstSummary, summariseFromChildren, mergeSummaries, } from './summary-utils';
+import { createMockTextInputComponent } from '../../../test-utils/component-utils';
+describe('summary-utils', () => {
+    describe('getSummariser', () => {
+        it('returns a function that constructs a summary based on the schema and value', () => {
+            const stringSchema = {
+                title: 'title',
+                type: 'string',
+                summary: {
+                    providesTitle: true,
+                    providesIcon: true,
+                },
+                icon: {
+                    name: 'email',
+                },
+            };
+            const summariser = getSummariser(stringSchema);
+            const summary = summariser('test value');
+            expect(summary).toEqual({
+                title: 'test value',
+                media: {
+                    type: 'legacy',
+                    icon: { name: 'email' },
+                },
+            });
+        });
+    });
+    describe('getConstSummary', () => {
+        it('returns a function that constructs a summary based on the schema', () => {
+            const schema = {
+                type: 'string',
+                const: 'const value',
+                summary: {
+                    providesTitle: true,
+                    providesIcon: true,
+                },
+                icon: {
+                    name: 'email',
+                },
+            };
+            const summary = getConstSummary(schema, 'const value');
+            expect(summary).toEqual({
+                title: 'const value',
+                media: {
+                    type: 'legacy',
+                    icon: { name: 'email' },
+                },
+            });
+        });
+        it('prefers ignores non-string values', () => {
+            const schema = {
+                type: 'array',
+                const: [],
+                summary: {
+                    providesTitle: true,
+                    providesIcon: true,
+                },
+                icon: {
+                    name: 'email',
+                },
+            };
+            const summary = getConstSummary(schema, []);
+            expect(summary).toEqual({
+                media: {
+                    type: 'legacy',
+                    icon: { name: 'email' },
+                },
+            });
+        });
+    });
+    describe('summariseFromChildren', () => {
+        it('should merge summaries from an array of components', () => {
+            const components = [
+                createMockTextInputComponent({
+                    summariser: () => ({
+                        title: 'title one',
+                    }),
+                }),
+                createMockTextInputComponent({
+                    summariser: () => ({
+                        title: 'title two',
+                        description: 'description',
+                    }),
+                }),
+            ];
+            expect(summariseFromChildren(components)).toEqual({
+                title: 'title one',
+                description: 'description',
+            });
+        });
+    });
+    describe('mergeSummaries', () => {
+        it('should merge two summaries, prefering earlier props if there are duplicates', () => {
+            const summaryOne = {
+                title: 'title one',
+                description: 'description',
+            };
+            const summaryTwo = {
+                title: 'title two',
+                media: {
+                    type: 'avatar',
+                    content: [
+                        {
+                            type: 'uri',
+                            uri: 'urn:wise:icons:email',
+                        },
+                    ],
+                },
+            };
+            expect(mergeSummaries(summaryOne, summaryTwo)).toEqual({
+                title: 'title one',
+                description: 'description',
+                media: {
+                    type: 'avatar',
+                    content: [
+                        {
+                            type: 'uri',
+                            uri: 'urn:wise:icons:email',
+                        },
+                    ],
+                },
+            });
+        });
+    });
+});

package/build/domain/features/utils/http-utils.js

@@ -0,0 +1,21 @@
+export function constructPayload({ value, signal, requestConfig, }) {
+    const isFile = value instanceof File;
+    const { method, param } = requestConfig;
+    const body = isFile ? wrapInFormData(param, value) : JSON.stringify({ [param]: value });
+    const headers = Object.assign({}, (!isFile && { 'Content-Type': 'application/json' }));
+    return {
+        method,
+        headers,
+        body,
+        signal,
+    };
+}
+const wrapInFormData = (key, file) => {
+    const formData = new FormData();
+    formData.append(key, file);
+    return formData;
+};
+export const abortAndResetController = (abortController) => {
+    abortController.abort();
+    return new AbortController();
+};

package/build/domain/features/utils/response-utils.js

@@ -0,0 +1,9 @@
+import { isErrorResponseBody } from '../../../controller/response-utils';
+import { isObject } from '../../../utils/type-validators';
+export const getAnalyticsFromErrorResponse = (json) => {
+    if (!isErrorResponseBody(json)) {
+        return undefined;
+    }
+    const { analytics } = json;
+    return isObject(analytics) ? analytics : undefined;
+};

package/build/domain/features/validation/date-availability.js

@@ -0,0 +1,54 @@
+const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+export const normaliseDateAvailability = (availability, logEvent) => {
+    if (!availability) {
+        return undefined;
+    }
+    const unavailable = availability.unavailable.flatMap((rule) => {
+        if (rule.type === 'weekdays') {
+            return [rule];
+        }
+        if (rule.type === 'dates') {
+            const dates = rule.dates.filter((date) => {
+                const valid = isCanonicalDate(date);
+                if (!valid) {
+                    logInvalidRule(date, logEvent);
+                }
+                return valid;
+            });
+            return dates.length > 0 ? [Object.assign(Object.assign({}, rule), { dates })] : [];
+        }
+        if (!isCanonicalDate(rule.start) || !isCanonicalDate(rule.end) || rule.start > rule.end) {
+            logInvalidRule(`${rule.start}/${rule.end}`, logEvent);
+            return [];
+        }
+        return [rule];
+    });
+    return Object.assign(Object.assign({}, availability), { unavailable });
+};
+export const getUnavailableDateReason = (date, availability) => { var _a; var _b; return (_b = (_a = availability === null || availability === void 0 ? void 0 : availability.unavailable.find((rule) => matchesDateRule(date, rule))) === null || _a === void 0 ? void 0 : _a.reason) !== null && _b !== void 0 ? _b : null; };
+const matchesDateRule = (date, rule) => {
+    switch (rule.type) {
+        case 'dates':
+            return rule.dates.includes(date);
+        case 'weekdays': {
+            const weekday = WEEKDAYS[new Date(`${date}T00:00:00Z`).getUTCDay()];
+            return rule.weekdays.includes(weekday);
+        }
+        case 'range':
+            return date >= rule.start && date <= rule.end;
+    }
+};
+const isCanonicalDate = (value) => {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (!match) {
+        return false;
+    }
+    const [, year, month, day] = match.map(Number);
+    const date = new Date(0);
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCFullYear(year, month - 1, day);
+    return (date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day);
+};
+const logInvalidRule = (value, logEvent) => {
+    logEvent('warning', 'Ignoring invalid date availability rule value', { value });
+};

package/build/domain/features/validation/date-availability.test.js

@@ -0,0 +1,54 @@
+import { getUnavailableDateReason, normaliseDateAvailability } from './date-availability';
+describe('date availability', () => {
+    it('uses the first matching availability reason', () => {
+        const availability = {
+            unavailable: [
+                { type: 'dates', dates: ['2026-12-27'], reason: 'Bank holiday' },
+                { type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' },
+                { type: 'range', start: '2026-12-20', end: '2026-12-31', reason: 'Winter closure' },
+            ],
+        };
+        expect(getUnavailableDateReason('2026-12-27', availability)).toBe('Bank holiday');
+    });
+    it('removes malformed and impossible dates while retaining valid dates', () => {
+        const logEvent = vi.fn();
+        const availability = {
+            message: 'Some dates are unavailable',
+            unavailable: [
+                {
+                    type: 'dates',
+                    dates: ['2026-09-07', '2026-09-0a', '2026-02-30', '2026-09-08T00:00:00Z'],
+                    reason: 'Unavailable',
+                },
+            ],
+        };
+        expect(normaliseDateAvailability(availability, logEvent)).toEqual({
+            message: 'Some dates are unavailable',
+            unavailable: [{ type: 'dates', dates: ['2026-09-07'], reason: 'Unavailable' }],
+        });
+        expect(logEvent).toHaveBeenCalledTimes(3);
+    });
+    it.each([
+        { start: '2026-09-0a', end: '2026-09-30' },
+        { start: '2026-09-01', end: '2026-02-30' },
+        { start: '2026-09-30', end: '2026-09-01' },
+    ])('removes an invalid range from $start to $end', ({ start, end }) => {
+        const logEvent = vi.fn();
+        const availability = {
+            unavailable: [{ type: 'range', start, end, reason: 'Unavailable' }],
+        };
+        expect(normaliseDateAvailability(availability, logEvent)).toEqual({ unavailable: [] });
+        expect(logEvent).toHaveBeenCalledWith('warning', 'Ignoring invalid date availability rule value', { value: `${start}/${end}` });
+    });
+    it('retains valid ranges and weekday rules', () => {
+        const logEvent = vi.fn();
+        const availability = {
+            unavailable: [
+                { type: 'range', start: '2026-09-01', end: '2026-09-30', reason: 'Closure' },
+                { type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' },
+            ],
+        };
+        expect(normaliseDateAvailability(availability, logEvent)).toEqual(availability);
+        expect(logEvent).not.toHaveBeenCalled();
+    });
+});

package/build/domain/features/validation/getPatternRegExp.js

@@ -0,0 +1,25 @@
+export const getPatternRegExp = (pattern, logEvent) => {
+    if (!pattern) {
+        return;
+    }
+    try {
+        return new RegExp(pattern, 'u');
+    }
+    catch (error) {
+        const message = `Invalid schema pattern. Failed to instantiate RegExp with Unicode support.`;
+        if (logEvent) {
+            logEvent('warning', message, {
+                pattern,
+                error: error === null || error === void 0 ? void 0 : error.toString(),
+            });
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn(`Dynamic Flow - ${message}`, {
+                pattern,
+                error: error === null || error === void 0 ? void 0 : error.toString(),
+            });
+        }
+        return new RegExp(pattern);
+    }
+};

package/build/domain/features/validation/spec-utils.js

@@ -0,0 +1,23 @@
+import { vi } from 'vitest';
+export const mockErrorMessageFunctions = {
+    minimum: vi.fn().mockReturnValue('minimum'),
+    maximum: vi.fn().mockReturnValue('maximum'),
+    minimumDate: vi.fn().mockReturnValue('minimumDate'),
+    maximumDate: vi.fn().mockReturnValue('maximumDate'),
+    invalidDate: vi.fn().mockReturnValue('invalidDate'),
+    minLength: vi.fn().mockReturnValue('minLength'),
+    maxLength: vi.fn().mockReturnValue('maxLength'),
+    minFiles: vi.fn().mockReturnValue('minFiles'),
+    maxFiles: vi.fn().mockReturnValue('maxFiles'),
+    minItems: vi.fn().mockReturnValue('minItems'),
+    maxItems: vi.fn().mockReturnValue('maxItems'),
+    maxSize: vi.fn().mockReturnValue('maxSize'),
+    accepts: vi.fn().mockReturnValue('accepts'),
+    pattern: vi.fn().mockReturnValue('pattern'),
+    required: vi.fn().mockReturnValue('required'),
+    genericError: vi.fn().mockReturnValue('genericError'),
+    genericErrorWithRetry: vi.fn().mockReturnValue('genericErrorWithRetry'),
+    downloadStarted: vi.fn().mockReturnValue('downloadStarted'),
+    downloadFailed: vi.fn().mockReturnValue('downloadFailed'),
+    downloadSuccessful: vi.fn().mockReturnValue('downloadSuccessful'),
+};

package/build/domain/features/validation/validation-functions.js

@@ -0,0 +1,6 @@
+import { isString } from '../../../utils/type-validators';
+export const validateComponents = (components) => components.reduce((acc, component) => component.validate() && acc, true);
+/**
+ * Returns a function that takes a local value and returns an array of validation errors
+ */
+export const getLocalValueValidator = (checks) => (currentValue) => checks.map((check) => check(currentValue)).filter(isString);