@wise/dynamic-flow-client-internal 3.15.2 → 3.15.3-experimental-9ab778d

package/build/dynamicFlow/DynamicFlow.js

@@ -0,0 +1,104 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useCallback, useMemo } from 'react';
+import { useIntl } from 'react-intl';
+import { DynamicFlow as DynamicFlowCoreLegacy, DynamicFlowCoreRevamp, DynamicFragmentCore, } from '@wise/dynamic-flow-client';
+import { RendererHttpClientProvider, getWiseRenderers } from '@wise/dynamic-flow-renderers';
+var wiseRenderers = getWiseRenderers();
+export function DynamicFlowLegacy(props) {
+    var _a = props.customFetch, customFetch = _a === void 0 ? globalThis.fetch : _a;
+    var coreProps = __assign(__assign({}, props), { httpClient: customFetch });
+    return _jsx(DynamicFlowCoreLegacy, __assign({}, coreProps));
+}
+export function DynamicFlowRevamp(props) {
+    var _a = props.customFetch, customFetch = _a === void 0 ? globalThis.fetch : _a, renderers = props.renderers;
+    var httpClient = useWiseHttpClient(customFetch);
+    var mergedRenderers = useMemo(function () { return __spreadArray(__spreadArray([], (renderers !== null && renderers !== void 0 ? renderers : []), true), wiseRenderers, true); }, [renderers]);
+    var coreProps = __assign(__assign({}, props), { httpClient: httpClient, renderers: mergedRenderers });
+    return (_jsx(RendererHttpClientProvider, { httpClient: httpClient, children: _jsx(DynamicFlowCoreRevamp, __assign({}, coreProps)) }));
+}
+/**
+ * DynamicFragment is like DynamicFlowRevamp, but it also accepts a ForwardedRef.
+ * This ref conforms to the DynamicFragmentController type, containing two functions: `getValue` and `validate`.
+ * @experimental This component may be changed in the future without notice.
+ */
+export var DynamicFragment = forwardRef(function DynamicFragment(props, ref) {
+    var _a = props.customFetch, customFetch = _a === void 0 ? globalThis.fetch : _a, renderers = props.renderers;
+    var httpClient = useWiseHttpClient(customFetch);
+    var mergedRenderers = useMemo(function () { return __spreadArray(__spreadArray([], (renderers !== null && renderers !== void 0 ? renderers : []), true), wiseRenderers, true); }, [renderers]);
+    var coreProps = __assign(__assign({}, props), { httpClient: httpClient, renderers: mergedRenderers });
+    return (_jsx(RendererHttpClientProvider, { httpClient: httpClient, children: _jsx(DynamicFragmentCore, __assign({}, coreProps, { ref: ref })) }));
+});
+var useWiseHttpClient = function (httpClient) {
+    var locale = useIntl().locale;
+    return useCallback(function (input_1) {
+        var args_1 = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args_1[_i - 1] = arguments[_i];
+        }
+        return __awaiter(void 0, __spreadArray([input_1], args_1, true), void 0, function (input, init) {
+            var headers;
+            if (init === void 0) { init = {}; }
+            return __generator(this, function (_a) {
+                headers = new Headers(init.headers);
+                headers.set('accept-language', locale);
+                return [2 /*return*/, httpClient(input, __assign(__assign({}, init), { credentials: 'include', headers: headers }))];
+            });
+        });
+    }, [httpClient, locale]);
+};

package/build/dynamicFlow/DynamicFlow.test.js

@@ -0,0 +1,116 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { waitFor } from '@testing-library/react';
+import { renderWithProviders } from '../test-utils/rtl-utils';
+import { DynamicFlowLegacy, DynamicFlowRevamp, DynamicFragment } from './DynamicFlow';
+describe.each([
+    { name: 'DynamicFlowLegacy', DFComponent: DynamicFlowLegacy },
+    { name: 'DynamicFlowRevamp', DFComponent: DynamicFlowRevamp },
+    { name: 'DynamicFragment', DFComponent: DynamicFragment },
+])('Wise-Specific Headers', function (_a) {
+    var name = _a.name, DFComponent = _a.DFComponent;
+    it("".concat(name, " - makes an initial request with additional RequestInit parameters, as specified in the wise-specific fetcher"), function () { return __awaiter(void 0, void 0, void 0, function () {
+        var props, customFetch, requestInit, credentials, headers;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    props = {
+                        flowId: 'test',
+                        initialAction: { url: '/initial' },
+                        onCompletion: jest.fn(),
+                        onError: jest.fn(),
+                    };
+                    customFetch = jest.fn();
+                    renderWithProviders(_jsx(DFComponent, __assign({}, props, { customFetch: customFetch })));
+                    return [4 /*yield*/, waitFor(function () {
+                            expect(customFetch).toHaveBeenCalledWith('/initial', expect.anything());
+                        })];
+                case 1:
+                    _a.sent();
+                    requestInit = customFetch.mock.calls[0][1];
+                    credentials = requestInit === null || requestInit === void 0 ? void 0 : requestInit.credentials;
+                    expect(credentials).toBe('include');
+                    headers = Array.from(new Headers(requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers).entries());
+                    expect(headers).toContainEqual(['accept-language', 'en-GB']);
+                    expect(headers).toContainEqual(['content-type', 'application/json']);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('DynamicFlowLegacy', function () {
+    describe('when initialised with customFetch', function () {
+        it('uses the "correct" casing of Content-Type header', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var props, customFetch, requestInit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        props = {
+                            flowId: 'test',
+                            initialAction: { url: '/initial' },
+                            onCompletion: jest.fn(),
+                            onError: jest.fn(),
+                        };
+                        customFetch = jest.fn();
+                        renderWithProviders(_jsx(DynamicFlowLegacy, __assign({}, props, { customFetch: customFetch })));
+                        return [4 /*yield*/, waitFor(function () {
+                                expect(customFetch).toHaveBeenCalledWith('/initial', expect.anything());
+                            })];
+                    case 1:
+                        _a.sent();
+                        requestInit = customFetch.mock.calls[0][1];
+                        expect(requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers).toMatchObject({
+                            'Content-Type': 'application/json',
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/build/i18n/index.js

@@ -0,0 +1,62 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { translations as coreTranslations } from '@wise/dynamic-flow-client';
+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 wiseTranslations = {
+    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,
+};
+var languages = Array.from(new Set(__spreadArray(__spreadArray([], Object.keys(coreTranslations), true), Object.keys(wiseTranslations), true)));
+var translations = languages.reduce(function (acc, lang) {
+    var _a;
+    return (__assign(__assign({}, acc), (_a = {}, _a[lang] = __assign(__assign({}, coreTranslations[lang]), wiseTranslations[lang]), _a)));
+}, {});
+export default translations;

package/build/index.js

@@ -0,0 +1,5 @@
+import { makeHttpClient } from '@wise/dynamic-flow-client';
+export { JsonSchemaForm, isValidSchema } from '@wise/dynamic-flow-client';
+export { default as translations } from './i18n';
+export { DynamicFlowLegacy as DynamicFlow, DynamicFlowLegacy, DynamicFlowRevamp, DynamicFragment, } from './dynamicFlow/DynamicFlow';
+export var makeCustomFetch = makeHttpClient;