@wise/dynamic-flow-client-internal 5.28.2-experimental-a8a898e → 5.28.2

package/build/dynamicFlow/DynamicFlow.js

@@ -0,0 +1,11 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useDynamicFlow } from '@wise/dynamic-flow-client';
+import { useDFContextMenu } from './context-menu/useDFContextMenu';
+import { useWiseToCoreProps } from './useWiseToCoreProps';
+export function DynamicFlow(props) {
+    const { className = '' } = props;
+    const dfProps = useWiseToCoreProps(props);
+    const df = useDynamicFlow(dfProps);
+    const { onContextMenu, contextMenu } = useDFContextMenu(df.controller);
+    return (_jsxs("div", { className: className, onContextMenu: onContextMenu, children: [df.view, contextMenu] }));
+}

package/build/dynamicFlow/DynamicFlowModal.js

@@ -0,0 +1,21 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useDynamicFlowModal } from '@wise/dynamic-flow-client';
+import { useWiseToCoreProps } from './useWiseToCoreProps';
+import { Modal } from '@transferwise/components';
+export function DynamicFlowModal(props) {
+    const { className = '' } = props, rest = __rest(props, ["className"]);
+    const dfProps = useWiseToCoreProps(rest);
+    const df = useDynamicFlowModal(dfProps);
+    return (_jsx(Modal, Object.assign({ className: `dynamic-flow-modal ${className}`, disableDimmerClickToClose: true }, df.modal, { body: _jsx("div", { className: "dynamic-flow-modal", children: df.modal.body }) })));
+}

package/build/dynamicFlow/DynamicFlowWiseProps.js

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

package/build/dynamicFlow/DynamicFlowWithRef.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useImperativeHandle, } from 'react';
+import { useWiseToCoreProps } from './useWiseToCoreProps';
+import { useDynamicFlow } from '@wise/dynamic-flow-client';
+/**
+ * DynamicFlowWithRef is like DynamicFlow, but it also accepts a ForwardedRef.
+ * This ref conforms to the DynamicFlowRef type, containing two functions: `getValue` and `validate`.
+ * @experimental This component may be changed in the future without notice.
+ */
+export const DynamicFlowWithRef = forwardRef(function DynamicFlowWithRef(props, ref) {
+    const { className = '' } = props;
+    const dfProps = useWiseToCoreProps(props);
+    const df = useDynamicFlow(dfProps);
+    useImperativeHandle(ref, () => ({
+        getValue: () => { var _a; return (_a = df.controller.getValue()) !== null && _a !== void 0 ? _a : null; },
+        validate: () => df.controller.validate(),
+    }), [df]);
+    return _jsx("div", { className: className, children: df.view });
+});

package/build/dynamicFlow/context-menu/useContextMenu.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+export function useContextMenu({ title, subtitle, items, }) {
+    const { menuPosition, openMenuAt, closeMenu } = useMenuPosition();
+    const onContextMenu = (event) => {
+        if (items.length > 0 && !event.shiftKey) {
+            event.preventDefault();
+            openMenuAt({ x: event.clientX, y: event.clientY });
+        }
+    };
+    const contextMenu = menuPosition ? (_jsxs("div", { className: "df-context-menu", style: { top: menuPosition.y, left: menuPosition.x }, children: [_jsx("div", { className: "menu-header", children: title }), _jsx("div", { className: "menu-subtitle", children: subtitle }), items.map(({ label, onClick }) => (_jsx("button", { type: "button", className: "menu-button", onClick: () => {
+                    closeMenu();
+                    onClick();
+                }, children: label }, label)))] })) : null;
+    return {
+        onContextMenu,
+        contextMenu,
+    };
+}
+const useMenuPosition = () => {
+    const [menuPosition, setMenuPosition] = useState(null);
+    const clearMenu = useCallback(() => setMenuPosition(null), []);
+    const openMenuAt = useCallback((position) => {
+        setMenuPosition(position);
+        window.addEventListener('click', clearMenu);
+    }, [clearMenu]);
+    const closeMenu = useCallback(() => {
+        setMenuPosition(null);
+        window.removeEventListener('click', clearMenu);
+    }, [clearMenu]);
+    useEffect(() => clearMenu, [clearMenu]);
+    return { menuPosition, openMenuAt, closeMenu };
+};

package/build/dynamicFlow/context-menu/useDFContextMenu.js

@@ -0,0 +1,135 @@
+import { appVersion } from '../telemetry/app-version';
+import { useContextMenu } from './useContextMenu';
+export const useDFContextMenu = (controller) => {
+    const getCurrentStep = () => {
+        const step = controller.getCurrentStep();
+        return step ? recursivelyRemoveNullish(step) : null;
+    };
+    const getCurrentStepWithModel = async () => {
+        const step = controller.getCurrentStep();
+        if (!step) {
+            return null;
+        }
+        const model = controller.getValue();
+        return recursivelyRemoveNullish(Object.assign(Object.assign({}, step), { model }));
+    };
+    const getEncodedCurrentStep = () => {
+        const step = getCurrentStep();
+        return step ? toBase64(JSON.stringify(step, null, 2)) : null;
+    };
+    const getEncodedCurrentStepWithModel = async () => {
+        const step = await getCurrentStepWithModel();
+        return step ? toBase64(JSON.stringify(step, null, 2)) : null;
+    };
+    return useContextMenu({
+        title: 'DynamicFlow Menu (Dev/Staging only)',
+        subtitle: 'Shift + right-click for browser menu',
+        items: isDevOrStaging()
+            ? [
+                {
+                    label: `DF client version: ${appVersion}`,
+                    onClick: () => {
+                        openVersionPage(appVersion);
+                    },
+                },
+                {
+                    label: 'Copy step JSON',
+                    onClick: () => {
+                        copyToClipboard(getCurrentStep());
+                    },
+                },
+                {
+                    label: 'Open in Studio (experimental)',
+                    onClick: () => {
+                        openIn('studio', getEncodedCurrentStep());
+                    },
+                },
+                {
+                    label: 'Open in Sandbox',
+                    onClick: () => {
+                        openIn('sandbox', getEncodedCurrentStep());
+                    },
+                },
+                {
+                    label: 'Open in Sandbox (with model)',
+                    onClick: () => {
+                        void getEncodedCurrentStepWithModel().then((base64Step) => openIn('sandbox', base64Step));
+                    },
+                },
+            ]
+            : [],
+    });
+};
+const toBase64 = (str) => {
+    const bytes = new TextEncoder().encode(str);
+    const binString = Array.from(bytes, (b) => String.fromCharCode(b)).join('');
+    return btoa(binString);
+};
+const openIn = (editor, base64Step) => {
+    if (base64Step) {
+        window.open(`https://df.wise.com/${editor}#${base64Step}`, '_blank', 'noopener,noreferrer');
+    }
+};
+const openVersionPage = (version) => {
+    const changelogUrl = getGitHubChangelogUrl(version);
+    if (changelogUrl) {
+        window.open(changelogUrl, '_blank', 'noopener,noreferrer');
+    }
+    else {
+        window.open(getNpmPackageUrl(version), '_blank', 'noopener,noreferrer');
+    }
+};
+const getGitHubChangelogUrl = (version) => {
+    const semverRegex = /^\d+\.\d+\.\d+$/;
+    if (semverRegex.test(version)) {
+        const hash = version.replace(/\./g, ''); // convert version like "1.2.3" to "123" for the GitHub changelog anchor
+        return `https://github.com/transferwise/dynamic-flow/blob/main/web/wise/CHANGELOG.md#${hash}`;
+    }
+    return undefined;
+};
+const getNpmPackageUrl = (version) => {
+    return `https://www.npmjs.com/package/@wise/dynamic-flow-client-internal/v/${version}`;
+};
+const copyToClipboard = (value) => {
+    if (typeof value === 'string') {
+        void navigator.clipboard.writeText(value);
+        return;
+    }
+    if (value) {
+        void navigator.clipboard.writeText(JSON.stringify(value, null, 2));
+    }
+};
+// We only want to show the context menu in dev and staging environments.
+const isDevOrStaging = () => {
+    const validHostNames = ['localhost', 'dev-wi.se'];
+    try {
+        if (typeof window === 'undefined' || !window.location) {
+            return false;
+        }
+        const currentHostname = window.location.hostname;
+        if (!currentHostname) {
+            return false;
+        }
+        return validHostNames.some((hostname) => currentHostname === hostname || currentHostname.endsWith(`.${hostname}`));
+    }
+    catch (_a) {
+        return false;
+    }
+};
+const recursivelyRemoveNullish = (element) => {
+    if (Array.isArray(element)) {
+        return element.map(recursivelyRemoveNullish);
+    }
+    if (element !== null && typeof element === 'object') {
+        return Object.entries(element).reduce((acc, [key, value]) => {
+            if (value !== null && value !== undefined) {
+                // Use mutation instead of object spread to avoid O(n²) complexity.
+                // Object spread would rebuild the accumulator on every property, causing performance issues for large steps.
+                // eslint-disable-next-line functional/immutable-data, no-param-reassign
+                acc[key] = recursivelyRemoveNullish(value);
+            }
+            return acc;
+        }, {});
+    }
+    return element;
+};

package/build/dynamicFlow/context-menu/useDFContextMenu.test.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { fireEvent, screen, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { renderWithProviders } from '../../test-utils/rtl-utils';
+import { useDFContextMenu } from './useDFContextMenu';
+const mockedAppVersion = vi.hoisted(() => ({ current: '0.0.0' }));
+vi.mock('../telemetry/app-version', () => ({
+    get appVersion() {
+        return mockedAppVersion.current;
+    },
+}));
+const targetText = 'Right-click here to see the context menu';
+const step = {
+    id: 'step-id',
+    title: 'Test Step',
+    description: null,
+    layout: [],
+    schemas: [],
+};
+const base64EncodedStep = 'ewogICJpZCI6ICJzdGVwLWlkIiwKICAidGl0bGUiOiAiVGVzdCBTdGVwIiwKICAibGF5b3V0IjogW10sCiAgInNjaGVtYXMiOiBbXQp9';
+const base64EncodedStepWithModel = 'ewogICJpZCI6ICJzdGVwLWlkIiwKICAidGl0bGUiOiAiVGVzdCBTdGVwIiwKICAibGF5b3V0IjogW10sCiAgInNjaGVtYXMiOiBbXSwKICAibW9kZWwiOiB7fQp9';
+const controller = {
+    getCurrentStep: vi.fn(() => step),
+    getValue: vi.fn(() => ({})),
+};
+const TestComponent = () => {
+    const { onContextMenu, contextMenu } = useDFContextMenu(controller);
+    return (_jsxs("div", { onContextMenu: onContextMenu, children: [targetText, contextMenu] }));
+};
+describe('useDFContextMenu', () => {
+    const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+    beforeEach(() => {
+        vi.clearAllMocks();
+        Object.defineProperty(navigator, 'clipboard', {
+            writable: true,
+            value: { writeText: vi.fn().mockResolvedValue(undefined) },
+        });
+    });
+    describe('when right-clicking on localhost', () => {
+        beforeEach(() => {
+            Object.defineProperty(window, 'location', {
+                writable: true,
+                value: { hostname: 'localhost' },
+            });
+        });
+        describe('when the version is a release version', () => {
+            beforeEach(() => {
+                mockedAppVersion.current = '1.2.3';
+            });
+            it('shows the context menu with the version item, and on click opens the GitHub changelog', () => {
+                renderWithProviders(_jsx(TestComponent, {}));
+                fireEvent.contextMenu(screen.getByText(targetText));
+                expect(screen.getByText('DF client version: 1.2.3')).toBeInTheDocument();
+                fireEvent.click(screen.getByText('DF client version: 1.2.3'));
+                expect(openSpy).toHaveBeenCalledWith('https://github.com/transferwise/dynamic-flow/blob/main/web/wise/CHANGELOG.md#123', '_blank', 'noopener,noreferrer');
+            });
+        });
+        describe('when the version is a non-release version', () => {
+            beforeEach(() => {
+                mockedAppVersion.current = '1.2.3-beta';
+            });
+            it('shows the context menu with the version item, and on click opens the npm page for the current version', () => {
+                renderWithProviders(_jsx(TestComponent, {}));
+                fireEvent.contextMenu(screen.getByText(targetText));
+                expect(screen.getByText('DF client version: 1.2.3-beta')).toBeInTheDocument();
+                fireEvent.click(screen.getByText('DF client version: 1.2.3-beta'));
+                expect(openSpy).toHaveBeenCalledWith('https://www.npmjs.com/package/@wise/dynamic-flow-client-internal/v/1.2.3-beta', '_blank', 'noopener,noreferrer');
+            });
+        });
+        it('shows a menu item to open the current step in the sandbox', () => {
+            renderWithProviders(_jsx(TestComponent, {}));
+            fireEvent.contextMenu(screen.getByText(targetText));
+            expect(screen.getByText('Open in Sandbox')).toBeInTheDocument();
+            fireEvent.click(screen.getByText('Open in Sandbox'));
+            expect(openSpy).toHaveBeenCalledWith(expect.stringContaining(`https://df.wise.com/sandbox#${base64EncodedStep}`), '_blank', 'noopener,noreferrer');
+        });
+        it('shows a menu item to open the current step in Studio', () => {
+            renderWithProviders(_jsx(TestComponent, {}));
+            fireEvent.contextMenu(screen.getByText(targetText));
+            expect(screen.getByText('Open in Studio (experimental)')).toBeInTheDocument();
+            fireEvent.click(screen.getByText('Open in Studio (experimental)'));
+            expect(openSpy).toHaveBeenCalledWith(expect.stringContaining(`https://df.wise.com/studio#${base64EncodedStep}`), '_blank', 'noopener,noreferrer');
+        });
+        it('shows a menu item to open the current step in the sandbox with model', async () => {
+            renderWithProviders(_jsx(TestComponent, {}));
+            fireEvent.contextMenu(screen.getByText(targetText));
+            expect(screen.getByText('Open in Sandbox (with model)')).toBeInTheDocument();
+            fireEvent.click(screen.getByText('Open in Sandbox (with model)'));
+            await waitFor(() => {
+                expect(openSpy).toHaveBeenCalledWith(expect.stringContaining(`https://df.wise.com/sandbox#${base64EncodedStepWithModel}`), '_blank', 'noopener,noreferrer');
+            });
+        });
+        it('shows a menu item to copy the current step JSON', () => {
+            renderWithProviders(_jsx(TestComponent, {}));
+            fireEvent.contextMenu(screen.getByText(targetText));
+            expect(screen.getByText('Copy step JSON')).toBeInTheDocument();
+            fireEvent.click(screen.getByText('Copy step JSON'));
+            expect(navigator.clipboard.writeText).toHaveBeenCalledWith(JSON.stringify({ id: 'step-id', title: 'Test Step', layout: [], schemas: [] }, null, 2));
+        });
+    });
+});

package/build/dynamicFlow/getMergedRenderers.js

@@ -0,0 +1,36 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getDynamicSubflowRenderer } from '@wise/dynamic-flow-client';
+import { getWiseRenderers, InitialLoadingStateRenderer } from '@wise/dynamic-flow-renderers';
+import { DynamicFlow } from './DynamicFlow';
+import { DynamicFlowModal } from './DynamicFlowModal';
+const wiseRenderers = getWiseRenderers();
+export const getMergedRenderers = (props) => {
+    var _a;
+    var _b;
+    const { initialAction, initialStep } = props, restProps = __rest(props, ["initialAction", "initialStep"]);
+    const subflowFeatures = Object.assign(Object.assign({}, props.features), { nativeBack: true });
+    const subflowRenderer = getDynamicSubflowRenderer({
+        Component: (_a) => {
+            var { presentation, initialRequest } = _a, rest = __rest(_a, ["presentation", "initialRequest"]);
+            const action = {
+                url: initialRequest.url,
+                method: initialRequest.method,
+                data: initialRequest.body,
+            };
+            return presentation.type === 'push' ? (_jsx(DynamicFlow, Object.assign({}, restProps, rest, { features: subflowFeatures, initialAction: action }))) : (_jsx(DynamicFlowModal, Object.assign({}, restProps, rest, { features: subflowFeatures, initialAction: action })));
+        },
+    });
+    const loadingStateRenderer = ((_a = props.features) === null || _a === void 0 ? void 0 : _a.initialLoader) ? [InitialLoadingStateRenderer] : [];
+    return [...((_b = props.renderers) !== null && _b !== void 0 ? _b : []), subflowRenderer, ...loadingStateRenderer, ...wiseRenderers];
+};

package/build/dynamicFlow/messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+    copied: {
+        id: 'df.wise.CopyFeedback.copy',
+        defaultMessage: 'Copied to clipboard',
+        description: 'Appears in a snackbar when the copy operation succeeds.',
+    },
+    copyFailed: {
+        id: 'df.wise.CopyFeedback.copyFailed',
+        defaultMessage: 'Failed to copy to clipboard',
+        description: 'Appears in a snackbar when the copy operation fails.',
+    },
+});

package/build/dynamicFlow/renderers.js

@@ -0,0 +1,10 @@
+import { Header as RendererHeader, Media as RendererMedia, getMargin as rendererGetMargin, createCollectionRenderer as rendererCreateCollectionRenderer, } from '@wise/dynamic-flow-renderers';
+/**
+ * We need to redefine these because @wise/dynamic-flow-renderers is a private package that
+ * cannot be installed. There is likely a better solution, but until we find it we can
+ * redefine and re-export.
+ */
+export const Header = RendererHeader;
+export const Media = RendererMedia;
+export const getMargin = rendererGetMargin;
+export const createCollectionRenderer = rendererCreateCollectionRenderer;

package/build/dynamicFlow/telemetry/app-version.js

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+export const appVersion = 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+typeof process !== 'undefined' ? process.env.APP_VERSION : '0.0.0';

package/build/dynamicFlow/telemetry/dispatchAnalyticsEvent.js

@@ -0,0 +1,8 @@
+export const dispatchAnalyticsEvent = (eventName, properties) => {
+    const props = Object.assign({ dfFallbackAnalytics: true }, properties);
+    if (typeof window !== 'undefined' &&
+        window.mixpanel &&
+        typeof window.mixpanel.track === 'function') {
+        window.mixpanel.track(eventName, props);
+    }
+};

package/build/dynamicFlow/telemetry/getLogEvent.js

@@ -0,0 +1,22 @@
+import { appVersion } from './app-version';
+export const getLogEvent = (onLog) => (level, message, extra) => {
+    const extraWithVersion = Object.assign(Object.assign({}, extra), { dfWiseVersion: appVersion });
+    if (level !== 'info' && onLog) {
+        if (onLog) {
+            onLog(level, message, extraWithVersion);
+        }
+        else {
+            logToRollbar(level, message, extraWithVersion);
+        }
+    }
+};
+const logToRollbar = (level, message, extra) => {
+    try {
+        const rollbar = typeof window.Rollbar !== 'undefined' ? window.Rollbar : undefined;
+        rollbar === null || rollbar === void 0 ? void 0 : rollbar[level](message, extra);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to log to Rollbar', error);
+    }
+};

package/build/dynamicFlow/telemetry/getTrackEvent.js

@@ -0,0 +1,39 @@
+import { eventNames } from '@wise/dynamic-flow-client';
+import { dispatchAnalyticsEvent } from './dispatchAnalyticsEvent';
+const prefix = 'Dynamic Flow - ';
+export const getTrackEvent = (onEvent, onAnalytics) => {
+    return (name, properties) => {
+        /*
+         * By adding an `$insert_id`, mixpanel can deduplicate events
+         * https://docs.mixpanel.com/reference/event-deduplication
+         *
+         * This means we do not need to rely on onEvent/onAnalytics to track events
+         * correctly, and can safely send our own. For integrations that are
+         * tracking correctly, they will be deduplicated at query time immediately,
+         * or at compaction time (for data exports) after a few hours and again
+         * after ~20 days.
+         */
+        const propsWithUuid = Object.assign(Object.assign({}, properties), { $insert_id: crypto.randomUUID() });
+        onEvent === null || onEvent === void 0 ? void 0 : onEvent(name, propsWithUuid);
+        if (includeInAnalytics(name)) {
+            dispatchAnalyticsEvent(name, propsWithUuid);
+            onAnalytics === null || onAnalytics === void 0 ? void 0 : onAnalytics(name, propsWithUuid);
+        }
+    };
+};
+const includeInAnalytics = (name) => {
+    const eventName = name.startsWith(prefix) ? name.slice(prefix.length) : name;
+    if (isCoreEventName(eventName)) {
+        return true; // for now, all core events are sent to analytics
+    }
+    if (eventName in customEventsToAnalytics) {
+        return customEventsToAnalytics[eventName];
+    }
+    return true; // unknown custom events are sent to analytics by default
+};
+const isCoreEventName = (eventName) => {
+    return eventNames.includes(eventName);
+};
+const customEventsToAnalytics = {
+    'Theme Required': false, // Excluded from analytics
+};

package/build/dynamicFlow/telemetry/index.js

@@ -0,0 +1,2 @@
+export { getLogEvent } from './getLogEvent';
+export { getTrackEvent } from './getTrackEvent';

package/build/dynamicFlow/useCreateSnackBar.js

@@ -0,0 +1,9 @@
+import { useSnackBarIfAvailable } from '@wise/dynamic-flow-renderers';
+/**
+ * Wrapper around `useSnackBarIfAvailable` so tests can mock this module without
+ * mocking `@wise/dynamic-flow-renderers` directly.
+ */
+export const useCreateSnackBar = () => {
+    const createSnackBar = useSnackBarIfAvailable();
+    return createSnackBar;
+};

package/build/dynamicFlow/useOnCopy.js

@@ -0,0 +1,16 @@
+import { useSnackBarIfAvailable } from '@wise/dynamic-flow-renderers';
+import { useCallback } from 'react';
+import { useIntl } from 'react-intl';
+import messages from './messages';
+export const useOnCopy = () => {
+    const { formatMessage } = useIntl();
+    const createSnackBar = useSnackBarIfAvailable();
+    return useCallback((copiedContent) => {
+        if (copiedContent) {
+            createSnackBar({ text: formatMessage(messages.copied) });
+        }
+        else {
+            createSnackBar({ text: formatMessage(messages.copyFailed) });
+        }
+    }, [createSnackBar, formatMessage]);
+};

package/build/dynamicFlow/useWiseHttpClient.js

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+import { useIntl } from 'react-intl';
+export const useWiseHttpClient = (httpClient) => {
+    const { locale } = useIntl();
+    return useCallback(async (input, init = {}) => {
+        const headers = new Headers(init.headers);
+        headers.set('accept-language', locale);
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || undefined;
+        if (timeZone) {
+            headers.set('time-zone', timeZone);
+        }
+        const requestInit = Object.assign(Object.assign({}, init), { credentials: 'include', headers });
+        return httpClient(input, requestInit).catch(handleRejection);
+    }, [httpClient, locale]);
+};
+const handleRejection = (error) => {
+    if (error instanceof Error && error.message === 'SCA_MODAL_CLOSED') {
+        // This is a special case for the SCA modal.
+        // By responding with an empty `validation` object, and an error status code,
+        // we can avoid showing any error messages.
+        return new Response(JSON.stringify({ validation: {} }), { status: 400 });
+    }
+    throw error;
+};

package/build/dynamicFlow/useWiseToCoreProps.js

@@ -0,0 +1,42 @@
+import { useMemo } from 'react';
+import { getMergedRenderers } from './getMergedRenderers';
+import { getLogEvent, getTrackEvent } from './telemetry';
+import { useOnCopy } from './useOnCopy';
+import { useWiseHttpClient } from './useWiseHttpClient';
+import { useCreateSnackBar } from './useCreateSnackBar';
+export const useWiseToCoreProps = (props) => {
+    const { displayStepTitle = true, features = {}, customFetch = globalThis.fetch, renderers, onAnalytics, onEvent, onLink = openLinkInNewTab, onNotification, onLog, } = props;
+    const httpClient = useWiseHttpClient(customFetch);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const mergedRenderers = useMemo(() => getMergedRenderers(props), [renderers]);
+    const createSnackBar = useCreateSnackBar();
+    const logEvent = useMemo(() => getLogEvent(onLog), [onLog]);
+    const trackEvent = useMemo(() => getTrackEvent(onEvent, onAnalytics), [onEvent, onAnalytics]);
+    const onCopy = useOnCopy();
+    return Object.assign(Object.assign({}, props), { httpClient, features: Object.assign({ hideStepTitle: !displayStepTitle }, features), renderers: mergedRenderers, onEvent: trackEvent, onLog: logEvent, onCopy, onNotification: onNotification !== null && onNotification !== void 0 ? onNotification : createSnackBar, onLink });
+};
+const openLinkInNewTab = (url) => {
+    if (typeof window === 'undefined' || typeof window.open !== 'function') {
+        return false;
+    }
+    // eslint-disable-next-line no-script-url
+    if (url.startsWith('javascript:')) {
+        return false;
+    }
+    try {
+        const w = window.open(url, '_blank');
+        if (w) {
+            try {
+                // eslint-disable-next-line functional/immutable-data
+                w.opener = null;
+            }
+            catch (_a) {
+                // ignore
+            }
+        }
+        return Boolean(w);
+    }
+    catch (_b) {
+        return false;
+    }
+};

package/build/i18n/fr.json

@@ -20,7 +20,7 @@
   "df.wise.ControlFeedback.type": "Type incorrect",
   "df.wise.CopyFeedback.copy": "Copié dans le presse-papier",
   "df.wise.CopyFeedback.copyFailed": "Impossible de copier dans le presse-papier",
-  "df.wise.DateInput.unavailableDates": "Some dates are unavailable.",
+  "df.wise.DateInput.unavailableDates": "Certaines dates ne sont pas disponibles.",
   "df.wise.DynamicParagraph.copied": "Copié dans le presse-papier",
   "df.wise.DynamicParagraph.copy": "Copier",
   "df.wise.ErrorBoundary.errorAlert": "Une erreur s'est produite.",

package/build/i18n/index.js

@@ -0,0 +1,43 @@
+import { translations as coreTranslations } from '@wise/dynamic-flow-client';
+import cs from './cs.json';
+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 nl from './nl.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';
+const wiseTranslations = {
+    cs,
+    en,
+    de,
+    es,
+    fr,
+    hu,
+    id,
+    it,
+    ja,
+    nl,
+    pl,
+    pt,
+    ro,
+    ru,
+    th,
+    tr,
+    zh: zhCN,
+    'zh-CN': zhCN,
+    'zh-HK': zhHK,
+};
+const languages = Array.from(new Set([...Object.keys(coreTranslations), ...Object.keys(wiseTranslations)]));
+const translations = languages.reduce((acc, lang) => (Object.assign(Object.assign({}, acc), { [lang]: Object.assign(Object.assign({}, coreTranslations[lang]), wiseTranslations[lang]) })), {});
+export default translations;

package/build/index.js

@@ -0,0 +1,6 @@
+export { makeHttpClient as makeCustomFetch } from '@wise/dynamic-flow-client';
+export { DynamicFlow } from './dynamicFlow/DynamicFlow';
+export { DynamicFlowWithRef } from './dynamicFlow/DynamicFlowWithRef';
+export { findRendererPropsByType } from '@wise/dynamic-flow-client';
+export { createCollectionRenderer, getMargin, Header, Media } from './dynamicFlow/renderers';
+export { default as translations } from './i18n';

package/build/main.js

@@ -146,7 +146,7 @@ var import_dynamic_flow_client4 = require("@wise/dynamic-flow-client");
 // src/dynamicFlow/telemetry/app-version.ts
 var appVersion = (
   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-  typeof process !== "undefined" ? "5.28.1" : "0.0.0"
+  typeof process !== "undefined" ? "5.28.2" : "0.0.0"
 );
 
 // src/dynamicFlow/context-menu/useContextMenu.tsx
@@ -7503,7 +7503,7 @@ var fr_default = {
   "df.wise.ControlFeedback.type": "Type incorrect",
   "df.wise.CopyFeedback.copy": "Copi\xE9 dans le presse-papier",
   "df.wise.CopyFeedback.copyFailed": "Impossible de copier dans le presse-papier",
-  "df.wise.DateInput.unavailableDates": "Some dates are unavailable.",
+  "df.wise.DateInput.unavailableDates": "Certaines dates ne sont pas disponibles.",
   "df.wise.DynamicParagraph.copied": "Copi\xE9 dans le presse-papier",
   "df.wise.DynamicParagraph.copy": "Copier",
   "df.wise.ErrorBoundary.errorAlert": "Une erreur s'est produite.",