@wise/dynamic-flow-client 3.16.2 → 3.16.3-experimental-c0e84f1

package/build/common/makeHttpClient/makeHttpClient.spec.js

@@ -0,0 +1,140 @@
+import { makeHttpClient, mergeRequestInit } from './makeHttpClient';
+describe('makeHttpClient', function () {
+    var originalFetch;
+    var spyFetch;
+    beforeEach(function () {
+        originalFetch = global.fetch;
+        spyFetch = jest.spyOn(global, 'fetch').mockImplementation();
+    });
+    afterEach(function () {
+        global.fetch = originalFetch;
+        jest.clearAllMocks();
+    });
+    describe('when initialised with a with a baseUrl', function () {
+        var httpClient = makeHttpClient('http://foo.bar');
+        describe('and called with a relative url', function () {
+            it('prefixes the baseUrl to the url given', function () {
+                void httpClient('/banana');
+                expect(spyFetch).toHaveBeenCalledTimes(1);
+                expect(spyFetch).toHaveBeenCalledWith('http://foo.bar/banana', expect.anything());
+            });
+        });
+        describe('and called with an absolute url', function () {
+            it('does not prefix the baseUrl', function () {
+                void httpClient('http://banana.com/banana');
+                expect(spyFetch).toHaveBeenCalledTimes(1);
+                expect(spyFetch).toHaveBeenCalledWith('http://banana.com/banana', expect.anything());
+            });
+        });
+        describe('and called with an "data:" url', function () {
+            it('does not prefix the baseUrl', function () {
+                void httpClient('data:image/jpeg;base64,/9j');
+                expect(spyFetch).toHaveBeenCalledTimes(1);
+                expect(spyFetch).toHaveBeenCalledWith('data:image/jpeg;base64,/9j', expect.anything());
+            });
+        });
+    });
+    describe("when initialised with a an empty baseUrl", function () {
+        var httpClient = makeHttpClient('');
+        describe('and called with a relative url', function () {
+            it('uses the url as given', function () {
+                void httpClient('/banana');
+                expect(spyFetch).toHaveBeenCalledTimes(1);
+                expect(spyFetch).toHaveBeenCalledWith('/banana', expect.anything());
+            });
+        });
+    });
+    describe('with additional headers', function () {
+        describe('when initialised with a with additionalHeaders', function () {
+            var httpClient = makeHttpClient('', { 'X-Access-Token': 'QWERTYUIOP' });
+            describe('and called without an init argument', function () {
+                it('calls fetch with an init object containing the headers', function () {
+                    void httpClient('/banana');
+                    expect(spyFetch).toHaveBeenCalledTimes(1);
+                    expect(spyFetch).toHaveBeenCalledWith('/banana', {
+                        headers: expect.anything(),
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    var headers = spyFetch.mock.calls[0][1].headers;
+                    expect(headers).toMatchObject({
+                        'x-access-token': 'QWERTYUIOP',
+                    });
+                });
+            });
+            describe('and called with an init argument', function () {
+                it('calls fetch with an init object containing the headers and the rest of the original init object', function () {
+                    void httpClient('/banana', { method: 'POST' });
+                    expect(spyFetch).toHaveBeenCalledTimes(1);
+                    expect(spyFetch).toHaveBeenCalledWith('/banana', {
+                        method: 'POST',
+                        headers: expect.anything(),
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    var headers = spyFetch.mock.calls[0][1].headers;
+                    expect(headers).toMatchObject({
+                        'x-access-token': 'QWERTYUIOP',
+                    });
+                });
+            });
+            describe('and called with headers in the init argument', function () {
+                it('calls fetch with an init object containing all headers and the rest of the original init object', function () {
+                    void httpClient('/banana', { method: 'POST', headers: { 'X-DF-Exit': 'true' } });
+                    expect(spyFetch).toHaveBeenCalledTimes(1);
+                    expect(spyFetch).toHaveBeenCalledWith('/banana', {
+                        method: 'POST',
+                        headers: expect.anything(),
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    var headers = spyFetch.mock.calls[0][1].headers;
+                    expect(headers).toMatchObject({
+                        'x-access-token': 'QWERTYUIOP',
+                        'x-df-exit': 'true',
+                    });
+                });
+            });
+        });
+        describe('when initialised without additionalHeaders', function () {
+            var httpClient = makeHttpClient('');
+            it('calls fetch with whatever headers are passed in the call', function () {
+                void httpClient('/banana', { method: 'POST', headers: { 'X-DF-Exit': 'true' } });
+                expect(spyFetch).toHaveBeenCalledTimes(1);
+                expect(spyFetch).toHaveBeenCalledWith('/banana', {
+                    method: 'POST',
+                    headers: expect.anything(),
+                });
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                var headers = spyFetch.mock.calls[0][1].headers;
+                expect(headers).toMatchObject({
+                    'x-df-exit': 'true',
+                });
+            });
+        });
+    });
+});
+describe('mergeRequestInit', function () {
+    describe('when called with two RequestInit objects', function () {
+        it('merges the two objects and the headers', function () {
+            var result = mergeRequestInit({ credentials: 'include', headers: { 'X-DF-Response-Type': 'true' } }, { method: 'POST', headers: { 'X-Access-Token': 'QWERTYUIOP' } });
+            expect(result).toMatchObject({
+                credentials: 'include',
+                method: 'POST',
+            });
+            expect(result.headers).toMatchObject({
+                'x-df-response-type': 'true',
+                'x-access-token': 'QWERTYUIOP',
+            });
+        });
+    });
+    describe('when called with undefined as a first argument', function () {
+        it('returns the second argument and empty headers', function () {
+            var result = mergeRequestInit(undefined, { method: 'POST' });
+            expect(result).toEqual({ method: 'POST', headers: {} });
+        });
+    });
+    describe('when called with null as a first argument', function () {
+        it('returns the second argument and empty headers', function () {
+            var result = mergeRequestInit(null, { method: 'POST' });
+            expect(result).toEqual({ method: 'POST', headers: {} });
+        });
+    });
+});

package/build/common/messages/external-confirmation.messages.js

@@ -0,0 +1,23 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    title: {
+        id: 'dynamicFlows.ExternalConfirmation.title',
+        defaultMessage: 'Please confirm',
+        description: 'Heading for the confirmation screen.',
+    },
+    description: {
+        id: 'dynamicFlows.ExternalConfirmation.description',
+        defaultMessage: 'Please confirm you want to open **{origin}** in a new browser tab.',
+        description: 'Description for the confirmation screen.',
+    },
+    open: {
+        id: 'dynamicFlows.ExternalConfirmation.open',
+        defaultMessage: 'Open in new tab',
+        description: 'Button text confirming opening a new browser tab.',
+    },
+    cancel: {
+        id: 'dynamicFlows.ExternalConfirmation.cancel',
+        defaultMessage: 'Cancel',
+        description: 'Button text rejecting opening a new browser tab.',
+    },
+});

package/build/common/messages/generic-error.messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    genericErrorRetryHint: {
+        id: 'dynamicFlows.PersistAsyncSchema.genericError',
+        defaultMessage: 'Something went wrong, please try again.',
+        description: 'Generic error message for persist async schema',
+    },
+    genericError: {
+        id: 'dynamicFlows.ErrorBoundary.errorAlert',
+        defaultMessage: 'Something went wrong.',
+        description: 'Generic error message for when something has gone wrong.',
+    },
+    retry: {
+        id: 'dynamicFlows.ErrorBoundary.retry',
+        defaultMessage: 'Retry',
+        description: 'Usually this follows the generic error and contains a link.',
+    },
+});

package/build/common/messages/help.messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    helpAria: {
+        id: 'dynamicFlows.Help.ariaLabel',
+        defaultMessage: 'Click here for more info.',
+        description: 'Aria label for help.',
+    },
+});

package/build/common/messages/multi-file-upload.messages.js

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    minItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.minItemsError',
+        defaultMessage: 'Please upload at least {minItems} file(s).',
+        description: 'Customer has uploaded not enough files. To fix: upload more files.',
+    },
+    maxItemsError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxItemsError',
+        defaultMessage: 'Please upload {maxItems} or fewer files.',
+        description: 'Customer has uploaded too many files. To fix: upload fewer files.',
+    },
+    maxFileSizeError: {
+        id: 'dynamicFlows.MultipleFileUploadSchema.maxFileSizeError',
+        defaultMessage: 'Sorry, that file is too big. Please upload a smaller file.',
+        description: "Customer has uploaded a file that's too big. To fix: upload a smaller file.",
+    },
+});

package/build/common/messages/multi-select.messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    summary: {
+        id: 'dynamicFlows.MultiSelect.summary',
+        defaultMessage: '{first} and {count} more',
+        description: 'A summary of the multiple items selected. Showing the title of the first selected item, and the number of other items that have been selected.',
+    },
+});

package/build/common/messages/paragraph.messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    copy: {
+        id: 'dynamicFlows.DynamicParagraph.copy',
+        defaultMessage: 'Copy',
+        description: 'Copy to clipboard button label.',
+    },
+    copied: {
+        id: 'dynamicFlows.DynamicParagraph.copied',
+        defaultMessage: 'Copied to clipboard',
+        description: 'Appears in a snackbar when the copy operation succeeds.',
+    },
+});

package/build/common/messages/repeatable.messages.js

@@ -0,0 +1,23 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    addItemTitle: {
+        id: 'dynamicFlows.ArraySchema.addItemTitle',
+        defaultMessage: 'Add Item',
+        description: 'Label on the button used to open a form to add an item',
+    },
+    addItem: {
+        id: 'dynamicFlows.ArraySchema.addItem',
+        defaultMessage: 'Save',
+        description: 'Label on the add button used to submit a form that adds an item',
+    },
+    editItem: {
+        id: 'dynamicFlows.ArraySchema.editItem',
+        defaultMessage: 'Save',
+        description: 'Label on the edit button used to submit a form that edits an item',
+    },
+    removeItem: {
+        id: 'dynamicFlows.ArraySchema.removeItem',
+        defaultMessage: 'Remove',
+        description: 'Label on the remove button used to confirm deletion of an item',
+    },
+});

package/build/common/messages/validation.array.messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    minItemsError: {
+        id: 'dynamicFlows.ArraySchema.minItemsError',
+        defaultMessage: 'Please add at least {minItems}.',
+        description: 'Customer inputs less than the expected number of values',
+    },
+    maxItemsError: {
+        id: 'dynamicFlows.ArraySchema.maxItemsError',
+        defaultMessage: 'Please add {maxItems} or fewer.',
+        description: 'Customer inputs more than the allowed number of values',
+    },
+});

package/build/common/messages/validation.messages.js

@@ -0,0 +1,53 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    type: {
+        id: 'dynamicFlows.ControlFeedback.type',
+        defaultMessage: 'Incorrect type',
+        description: '',
+    },
+    minimum: {
+        id: 'dynamicFlows.ControlFeedback.minimum',
+        defaultMessage: "Please enter a number that's {minimum} or more.",
+        description: '',
+    },
+    maximum: {
+        id: 'dynamicFlows.ControlFeedback.maximum',
+        defaultMessage: "Please enter a number that's {maximum} or less.",
+        description: '',
+    },
+    minLength: {
+        id: 'dynamicFlows.ControlFeedback.minLength',
+        defaultMessage: 'Please enter at least {minLength} characters.',
+        description: '',
+    },
+    maxLength: {
+        id: 'dynamicFlows.ControlFeedback.maxLength',
+        defaultMessage: 'Please enter {maxLength} or fewer characters.',
+        description: '',
+    },
+    minimumDate: {
+        id: 'dynamicFlows.ControlFeedback.minimumDate',
+        defaultMessage: "Please enter a date that's on or after {minimum}.",
+        description: '',
+    },
+    maximumDate: {
+        id: 'dynamicFlows.ControlFeedback.maximumDate',
+        defaultMessage: "Please enter a date that's on or before {maximum}.",
+        description: '',
+    },
+    pattern: {
+        id: 'dynamicFlows.ControlFeedback.pattern',
+        defaultMessage: 'Please enter this in the correct format.',
+        description: '',
+    },
+    patternDate: {
+        id: 'dynamicFlows.ControlFeedback.patternDate',
+        defaultMessage: 'Please enter a date in the corrrect format.',
+        description: '',
+    },
+    required: {
+        id: 'dynamicFlows.ControlFeedback.required',
+        defaultMessage: 'Please fill out this field.',
+        description: '',
+    },
+});

package/build/common/utils/api-utils.js

@@ -0,0 +1,4 @@
+export function isRelativePath(url) {
+    if (url === void 0) { url = ''; }
+    return !['https://', 'http://', 'data:'].some(function (prefix) { return url.startsWith(prefix) && url.length > prefix.length; });
+}

package/build/common/utils/debounce.js

@@ -0,0 +1,44 @@
+export var debounce = function (callback, waitMs) {
+    var timeoutId;
+    var lastArgs;
+    var clearTimer = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        lastArgs = null;
+    };
+    var debouncedFn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        lastArgs = args;
+        if (timeoutId !== null) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(function () {
+            // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+            callback.apply(void 0, lastArgs);
+            timeoutId = null;
+            lastArgs = null;
+        }, waitMs);
+    };
+    // eslint-disable-next-line functional/immutable-data
+    debouncedFn.cancel = function () {
+        if (timeoutId !== null) {
+            clearTimer();
+        }
+    };
+    // eslint-disable-next-line functional/immutable-data
+    debouncedFn.flush = function () {
+        if (timeoutId !== null) {
+            // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+            callback.apply(void 0, lastArgs);
+            clearTimer();
+        }
+    };
+    // eslint-disable-next-line functional/immutable-data
+    debouncedFn.isPending = function () { return timeoutId !== null; };
+    return debouncedFn;
+};

package/build/common/utils/debounce.spec.js

@@ -0,0 +1,72 @@
+import { debounce } from './debounce';
+describe('debounce', function () {
+    beforeAll(function () {
+        jest.useFakeTimers();
+    });
+    afterAll(function () {
+        jest.useRealTimers();
+    });
+    it('will delay function execution until the wait period has passed', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        expect(fn).toHaveBeenCalledTimes(0);
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(1);
+    });
+    it('will call function with provided arguments', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn('a', 'b', 'c');
+        jest.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', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn(1, 2, 3);
+        jest.advanceTimersByTime(4);
+        debouncedFn('a', 'b', 'c');
+        jest.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', function () {
+        var fn = jest.fn();
+        var debouncedFn = debounce(fn, 5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        debouncedFn();
+        jest.advanceTimersByTime(5);
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    describe('flush', function () {
+        it('will call the callback immediately', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.flush();
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('uses the last passed args', function () {
+            var fn = jest.fn();
+            var 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', function () {
+        it('cancels any waiting callback', function () {
+            var fn = jest.fn();
+            var debouncedFn = debounce(fn, 5);
+            debouncedFn();
+            debouncedFn.cancel();
+            jest.advanceTimersByTime(5);
+            expect(fn).toHaveBeenCalledTimes(0);
+        });
+    });
+});

package/build/i18n/index.js

@@ -0,0 +1,36 @@
+import de from './de.json';
+import en from './en.json';
+import es from './es.json';
+import fr from './fr.json';
+import hu from './hu.json';
+import id from './id.json';
+import it from './it.json';
+import ja from './ja.json';
+import pl from './pl.json';
+import pt from './pt.json';
+import ro from './ro.json';
+import ru from './ru.json';
+import th from './th.json';
+import tr from './tr.json';
+import zhCN from './zh_CN.json';
+import zhHK from './zh_HK.json';
+var translations = {
+    en: en,
+    de: de,
+    es: es,
+    fr: fr,
+    hu: hu,
+    id: id,
+    it: it,
+    ja: ja,
+    pl: pl,
+    pt: pt,
+    ro: ro,
+    ru: ru,
+    th: th,
+    tr: tr,
+    zh: zhCN,
+    'zh-CN': zhCN,
+    'zh-HK': zhHK,
+};
+export default translations;

package/build/index.js

@@ -0,0 +1,13 @@
+export { makeHttpClient } from './common/makeHttpClient';
+export { default as translations } from './i18n';
+export { DynamicFlowCore as DynamicFlowCoreRevamp } from './revamp/DynamicFlowCore';
+export { default as DynamicFlowRevamp } from './revamp/DynamicFlowWise';
+export { default as DynamicFragmentWise } from './revamp/DynamicFragmentWise';
+export { DynamicFragmentCore } from './revamp/DynamicFragmentCore';
+export { convertStepToLayout, inlineReferences } from './legacy/step/layoutStep/utils';
+export { default as DynamicFlow } from './legacy/dynamicFlow';
+export { default as JsonSchemaForm } from './legacy/jsonSchemaForm';
+export { DynamicLayout as Layout } from './legacy/layout';
+export { isValidSchema } from './legacy/common/validators';
+// eslint-disable-next-line import/export
+export * from './legacy/dynamicFlow/DynamicFlow';

package/build/legacy/common/constants/DateMode.js

@@ -0,0 +1,4 @@
+export var DateMode = {
+    DAY_MONTH_YEAR: 'day-month-year',
+    MONTH_YEAR: 'month-year',
+};

package/build/legacy/common/constants/FeatureName.js

@@ -0,0 +1,4 @@
+export var FeatureName;
+(function (FeatureName) {
+    FeatureName["SAMPLE_FEATURE"] = "sample-feature";
+})(FeatureName || (FeatureName = {}));

package/build/legacy/common/constants/FormControlType.js

@@ -0,0 +1,21 @@
+export var FormControlType = {
+    RADIO: 'radio',
+    CHECKBOX: 'checkbox',
+    SELECT: 'select',
+    EMAIL: 'email',
+    FILE: 'file',
+    DATE: 'date',
+    DATETIME: 'date-time',
+    DATELOOKUP: 'date-lookup',
+    TEL: 'tel',
+    // For string schemas with number format
+    NUMERIC: 'numeric',
+    // For number schemas
+    NUMBER: 'number',
+    HIDDEN: 'hidden',
+    PASSWORD: 'password',
+    TEXT: 'text',
+    TEXTAREA: 'textarea',
+    UPLOAD: 'upload',
+    TAB: 'tab',
+};

package/build/legacy/common/constants/MonthFormat.js

@@ -0,0 +1,4 @@
+export var MonthFormat = {
+    SHORT: 'short',
+    LONG: 'long',
+};

package/build/legacy/common/constants/Size.js

@@ -0,0 +1,7 @@
+export var Size = {
+    EXTRA_SMALL: 'xs',
+    SMALL: 'sm',
+    MEDIUM: 'md',
+    LARGE: 'lg',
+    EXTRA_LARGE: 'xl',
+};

package/build/legacy/common/constants/index.js

@@ -0,0 +1,4 @@
+export * from './DateMode';
+export * from './FormControlType';
+export * from './MonthFormat';
+export * from './Size';

package/build/legacy/common/contexts/dynamicFlowContexts/DynamicFlowContexts.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { usePendingPromiseCounter } from './usePendingPromiseCounter';
+var defaultContextValue = {
+    loading: false,
+    registerPersistAsyncPromise: function (promise) {
+        //
+    },
+};
+var DFContext = createContext(defaultContextValue);
+export var DynamicFlowProvider = function (_a) {
+    var loading = _a.loading, children = _a.children;
+    var _b = usePendingPromiseCounter(), pendingPromises = _b.pendingPromises, addPendingPromise = _b.addPendingPromise;
+    var providerValue = useMemo(function () {
+        return {
+            loading: loading || pendingPromises > 0,
+            registerPersistAsyncPromise: addPendingPromise,
+        };
+    }, [loading, pendingPromises, addPendingPromise]);
+    return _jsx(DFContext.Provider, { value: providerValue, children: children });
+};
+export var useDynamicFlow = function () {
+    var context = useContext(DFContext);
+    return context || defaultContextValue;
+};

package/build/legacy/common/contexts/dynamicFlowContexts/usePendingPromiseCounter.js

@@ -0,0 +1,15 @@
+import { useCallback, useState } from 'react';
+export function usePendingPromiseCounter() {
+    var _a = useState(0), count = _a[0], setCount = _a[1];
+    var addPendingPromise = useCallback(function (promise) {
+        setCount(function (c) { return c + 1; });
+        promise
+            .catch(noop)
+            .finally(function () { return delayUntilNextCycle(function () { return setCount(function (c) { return Math.max(0, c - 1); }); }); });
+    }, [setCount]);
+    return { addPendingPromise: addPendingPromise, pendingPromises: count };
+}
+var delayUntilNextCycle = function (fn) { return setTimeout(function () { return fn(); }, 0); };
+var noop = function () {
+    // no-op
+};