@wise/dynamic-flow-client 3.4.0 → 3.5.0-experimental-6654c72

package/build/revamp/flow/response-utils.js

@@ -0,0 +1,88 @@
+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 { isObject } from '../utils/type-validators';
+export var assertResponseIsValid = function (response) {
+    if (!isResponse(response)) {
+        throw new Error('Incorrect type of response from fetch. Expected object of type Response.');
+    }
+    if (response.bodyUsed) {
+        throw new Error('The body of the provided Response object has already been used. Every request must respond with a new Response object.');
+    }
+};
+var isResponse = function (response) {
+    return typeof response === 'object' &&
+        response !== null &&
+        'clone' in response &&
+        'bodyUsed' in response;
+};
+export var parseResponseBodyAsJsonElement = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 2, , 3]);
+                return [4 /*yield*/, response.json()];
+            case 1: return [2 /*return*/, (_b.sent())];
+            case 2:
+                _a = _b.sent();
+                return [2 /*return*/, null];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+export function assertActionResponseBody(body) {
+    // TODO: use zod to validate the action object instead of this
+    if (!isObject(body) || !isObject(body.action)) {
+        throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
+    }
+}
+export function isErrorResponseBody(body) {
+    return Boolean(isObject(body) &&
+        (body.refreshFormUrl || body.refreshUrl || body.validation || body.error || body.analytics));
+}
+export function assertErrorResponseBody(body) {
+    // TODO: use zod to validate the error object instead of this
+    if (!isErrorResponseBody(body)) {
+        throw new Error('Incorrect error response body in error response. Expected an object with either `refreshUrl`, `validation` or `error` properties.');
+    }
+}
+export function assertStepResponseBody(body) {
+    // TODO: use zod to validate the error object instead of this. Currently we just want to log, in future we can throw.
+    if (!isObject(body)) {
+        throw new Error('Incorrect response body in step response. Expected an object.');
+    }
+}

package/build/revamp/renderers/CoreContainerRenderer.js

@@ -0,0 +1,8 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export var CoreContainerRenderer = {
+    canRenderType: 'container',
+    render: function (_a) {
+        var children = _a.children;
+        return _jsx(_Fragment, { children: children });
+    }
+};

package/build/revamp/renderers/LoadingContext.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'react';
+var LoadingContext = createContext({ loadingState: 'idle' });
+export var LoadingContextProvider = LoadingContext.Provider;
+export var useLoadingContext = function () {
+    var loadingState = useContext(LoadingContext).loadingState;
+    return { loadingState: loadingState, isLoading: loadingState !== 'idle' };
+};

package/build/revamp/renderers/types.js

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

package/build/revamp/types.js

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

package/build/revamp/utils/component-utils.js

@@ -0,0 +1,86 @@
+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 { isObjectLocalValue, isObjectModel } from './type-utils';
+export var getSubmittableData = function (components) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, Promise.all(components.map(function (component) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                return [2 /*return*/, component.getSubmittableValue()];
+            }); }); })).then(function (values) {
+                return values.reduce(function (acc, value) { return mergeModels(acc, value); }, null);
+            })];
+    });
+}); };
+export var getLocalValues = function (components) {
+    return components
+        .map(function (component) { return component.getLocalValue(); })
+        .reduce(function (acc, value) { return mergeLocalValues(acc, value); }, null);
+};
+export var mergeLocalValues = function (valueA, valueB) {
+    if (valueA === null) {
+        return valueB;
+    }
+    if (valueB === null) {
+        return valueA;
+    }
+    if (isObjectLocalValue(valueA) && isObjectLocalValue(valueB)) {
+        return __assign(__assign({}, valueA), valueB);
+    }
+    return valueB;
+};
+export var mergeModels = function (valueA, valueB) {
+    if (valueA === null) {
+        return valueB;
+    }
+    if (valueB === null) {
+        return valueA;
+    }
+    if (isObjectModel(valueA) && isObjectModel(valueB)) {
+        return __assign(__assign({}, valueA), valueB);
+    }
+    return valueB;
+};

package/build/revamp/utils/type-utils.js

@@ -0,0 +1,56 @@
+import { isArray, isNullish, isObject } from './type-validators';
+export var hasChildren = function (component) {
+    return 'getChildren' in component && typeof component.getChildren === 'function';
+};
+export var isColumnsComponent = function (component) {
+    return Object.hasOwnProperty.call(component, 'startComponents') &&
+        Object.hasOwnProperty.call(component, 'endComponents');
+};
+export var isHiddenComponent = function (component) { return 'hidden' in component && component.hidden; };
+export var isRepeatableComponent = function (component) { return Object.hasOwnProperty.call(component, 'editableComponent'); };
+export var isObjectLocalValue = function (value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof File);
+};
+export var isObjectModel = function (model) {
+    return model != null && typeof model === 'object' && !Array.isArray(model);
+};
+export var isArrayModel = function (model) { return Array.isArray(model); };
+export var isAllOfSchema = function (schema) {
+    return 'allOf' in schema && !isNullish(schema.allOf);
+};
+export var isBooleanSchema = function (schema) {
+    return 'type' in schema && schema.type === 'boolean';
+};
+export var isBlobSchema = function (schema) {
+    return 'type' in schema && schema.type === 'blob';
+};
+export var isConstSchema = function (schema) {
+    return 'const' in schema && schema["const"] !== undefined;
+};
+export var isIntegerSchema = function (schema) {
+    return 'type' in schema && schema.type === 'integer';
+};
+export var isNumberSchema = function (schema) {
+    return 'type' in schema && schema.type === 'number';
+};
+export var isObjectSchema = function (schema) {
+    return 'type' in schema && schema.type === 'object';
+};
+export var isOneOfSchema = function (schema) {
+    return 'oneOf' in schema && !isNullish(schema.oneOf);
+};
+export var isArraySchema = function (schema) {
+    return 'items' in schema && !isNullish(schema.items);
+};
+export var isArrayListSchema = function (schema) {
+    return 'items' in schema && isObject(schema.items) && !isArray(schema.items);
+};
+export var isStringSchema = function (schema) {
+    return 'type' in schema && schema.type === 'string';
+};
+export var isStringSchemaWithUpload = function (schema) {
+    return isStringSchema(schema) && schema.format === 'base64url';
+};
+export var isSchemaWithPersistAsync = function (schema) {
+    return 'persistAsync' in schema && !isNullish(schema.persistAsync);
+};

package/build/revamp/utils/type-validators.js

@@ -0,0 +1,16 @@
+export var isString = function (value) { return typeof value === 'string'; };
+export var isNumber = function (value) {
+    return typeof value === 'number' && !Number.isNaN(value);
+};
+export var isInteger = function (value) {
+    return isNumber(value) && Math.floor(value) === value;
+};
+export var isBoolean = function (value) { return typeof value === 'boolean'; };
+export var isObject = function (value) {
+    return !isNullish(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
+};
+export var isArray = function (value) { return Array.isArray(value); };
+export var isNull = function (value) { return value === null; };
+export var isUndefined = function (value) { return typeof value === 'undefined'; };
+export var isNullish = function (v) { return isNull(v) || isUndefined(v); };
+export var isFile = function (value) { return value instanceof File; };

package/build/revamp/wise/renderers/AlertRenderer.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Alert } from '@transferwise/components';
+import { getMargin } from './utils/layout-utils';
+var AlertRenderer = {
+    canRenderType: 'alert',
+    render: function (_a) {
+        var context = _a.context, markdown = _a.markdown, margin = _a.margin;
+        return (_jsx(Alert, { type: context, className: getMargin(margin), message: markdown }));
+    }
+};
+export default AlertRenderer;

package/build/revamp/wise/renderers/BooleanInputRenderer.js

@@ -0,0 +1,34 @@
+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 __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 FieldInput from './components/FieldInput';
+import { Checkbox } from '@transferwise/components';
+var BooleanInputRenderer = {
+    canRenderType: 'input-boolean',
+    render: function (props) {
+        var id = props.id, control = props.control, _a = props.label, label = _a === void 0 ? '' : _a, description = props.description, help = props.help, error = props.error, type = props.type, value = props.value, rest = __rest(props, ["id", "control", "label", "description", "help", "error", "type", "value"]);
+        var checkboxProps = __assign(__assign({}, rest), { label: label, checked: value });
+        return (_jsx(FieldInput, __assign({ id: id, label: "", description: description, error: error, help: help }, { children: _jsx(Checkbox, __assign({ id: id }, checkboxProps)) })));
+    }
+};
+export default BooleanInputRenderer;

package/build/revamp/wise/renderers/BoxRenderer.js

@@ -0,0 +1,30 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import classNames from 'classnames';
+import { getMargin } from './utils/layout-utils';
+var BoxRenderer = {
+    canRenderType: 'box',
+    render: function (_a) {
+        var _b;
+        var border = _a.border, children = _a.children, margin = _a.margin, width = _a.width;
+        var hasFixedWidth = width !== 'xl';
+        var contents = (_jsx("div", __assign({ className: classNames((_b = {
+                    'df-box-renderer-border': border
+                },
+                _b["df-box-renderer-width-".concat(width)] = hasFixedWidth,
+                _b[getMargin(margin)] = !hasFixedWidth,
+                _b)) }, { children: children })));
+        return hasFixedWidth ? (_jsx("div", __assign({ className: classNames('df-box-renderer-fixed-width', getMargin(margin)) }, { children: contents }))) : (contents);
+    }
+};
+export default BoxRenderer;

package/build/revamp/wise/renderers/ButtonRenderer.js

@@ -0,0 +1,64 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from '@transferwise/components';
+import { getMargin } from './utils/layout-utils';
+import { useLoadingContext } from '../../renderers/LoadingContext';
+var ButtonRenderer = {
+    canRenderType: 'button',
+    render: ButtonRendererComponent
+};
+function ButtonRendererComponent(_a) {
+    var control = _a.control, context = _a.context, disabled = _a.disabled, margin = _a.margin, title = _a.title, size = _a.size, onClick = _a.onClick;
+    var className = getMargin(margin);
+    var priority = mapControl(control);
+    // Button doesn't support tertiary buttons with a context, and will render as
+    // secondary. This is inconsistent with mobile, so for now we remove context
+    var type = priority === 'tertiary' ? undefined : mapContext(context);
+    var isLoading = useLoadingContext().isLoading;
+    return (_jsx(Button, __assign({ block: true, className: className, disabled: isLoading || disabled, priority: mapControl(control), size: mapSize(size), type: type, onClick: onClick }, { children: title })));
+}
+var mapContext = function (context) {
+    switch (context) {
+        case 'neutral':
+        case 'warning':
+            return 'accent';
+        default:
+            return context;
+    }
+};
+var mapControl = function (control) {
+    switch (control) {
+        case 'primary':
+        case 'tertiary':
+            return control;
+        default:
+            return 'secondary';
+    }
+};
+var mapSize = function (size) {
+    if (!size) {
+        return undefined;
+    }
+    switch (size) {
+        case 'xs':
+        case 'sm':
+            return 'sm';
+        case 'lg':
+        case 'xl':
+            return 'lg';
+        case 'md':
+        default:
+            return 'md';
+    }
+};
+export default ButtonRenderer;

package/build/revamp/wise/renderers/ColumnsRenderer.js

@@ -0,0 +1,25 @@
+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);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import classNames from 'classnames';
+import { getMargin } from './utils/layout-utils';
+var ColumnsRenderer = {
+    canRenderType: 'columns',
+    render: function (_a) {
+        var bias = _a.bias, margin = _a.margin, startChildren = _a.startChildren, endChildren = _a.endChildren;
+        return (_jsxs("div", __assign({ className: classNames('df-columns-renderer-container', getMargin(margin), {
+                'df-columns-renderer-bias-start': bias === 'start',
+                'df-columns-renderer-bias-end': bias === 'end'
+            }) }, { children: [_jsx("div", __assign({ className: "df-columns-renderer-column" }, { children: startChildren })), _jsx("div", __assign({ className: "df-columns-renderer-column" }, { children: endChildren }))] })));
+    }
+};
+export default ColumnsRenderer;

package/build/revamp/wise/renderers/components/FieldInput.js

@@ -0,0 +1,20 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Field } from '@wise/forms';
+import { LabelContentWithHelp } from './LabelContentWithHelp';
+function FieldInput(_a) {
+    var id = _a.id, children = _a.children, label = _a.label, error = _a.error, description = _a.description, help = _a.help;
+    var labelContent = label && help ? _jsx(LabelContentWithHelp, { text: label, help: help }) : label;
+    return (_jsx(Field, __assign({ id: id, label: labelContent, hint: description, error: error }, { children: children })));
+}
+export default FieldInput;

package/build/revamp/wise/renderers/components/Help.js

@@ -0,0 +1,21 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Info, Markdown } from '@transferwise/components';
+import { useIntl } from 'react-intl';
+import helpMessages from '../../../../common/messages/help.messages';
+function Help(_a) {
+    var help = _a.help;
+    var intl = useIntl();
+    return (_jsx(Info, { className: "m-l-1", content: _jsx(Markdown, __assign({ config: { link: { target: '_blank' } } }, { children: help })), presentation: "POPOVER", size: "sm", "aria-label": intl.formatMessage(helpMessages.helpAria) }));
+}
+export default Help;

package/build/revamp/wise/renderers/components/LabelContentWithHelp.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Help from './Help';
+export function LabelContentWithHelp(_a) {
+    var text = _a.text, help = _a.help;
+    return (_jsxs("div", { children: [text, _jsx(Help, { help: help })] }));
+}

package/build/revamp/wise/renderers/utils/layout-utils.js

@@ -0,0 +1,31 @@
+var getMargin = function (size) {
+    switch (size) {
+        case 'xs':
+            return 'm-b-0';
+        case 'sm':
+            return 'm-b-1';
+        case 'md':
+            return 'm-b-2';
+        case 'lg':
+            return 'm-b-3';
+        case 'xl':
+            return 'm-b-5';
+        default:
+            return '';
+    }
+};
+var getTextAlignment = function (align) {
+    switch (align) {
+        case 'end':
+            return 'text-xs-right';
+        case 'center':
+            return 'text-xs-center';
+        case 'start':
+        default:
+            return '';
+    }
+};
+var getTextAlignmentAndMargin = function (component) {
+    return "".concat(getTextAlignment(component.align), " ").concat(getMargin(component.margin));
+};
+export { getMargin, getTextAlignmentAndMargin };

package/build/types/legacy/step/externalConfirmationStep/ExternalConfirmationStep.d.ts

@@ -2,5 +2,5 @@ type Props = {
     url: string;
     onClose: () => void;
 };
-declare const ExternalConfirmationStep: ({ url, onClose }: Props) => JSX.Element;
+declare function ExternalConfirmationStep({ url, onClose }: Props): JSX.Element;
 export default ExternalConfirmationStep;

package/build/types/revamp/domain/components/StepDomainComponent.d.ts

@@ -1,13 +1,15 @@
 import type { BaseComponent, DomainComponent, LoadingState, LocalValue, UpdateComponent } from '../types';
+import type { External } from '@wise/dynamic-flow-types/build/next/feature/External';
 export type StepDomainComponent = BaseComponent & {
     type: 'step';
-    loadingState: LoadingState;
     components: DomainComponent[];
+    external?: External;
+    loadingState: LoadingState;
     setLoadingState: (loadingState: LoadingState) => void;
     getChildren: () => DomainComponent[];
     getLocalValue: () => LocalValue;
 };
-export declare const createStepComponent: (stepProps: Pick<StepDomainComponent, "components" | "loadingState" | "uid"> & {
+export declare const createStepComponent: (stepProps: Pick<StepDomainComponent, "external" | "components" | "loadingState" | "uid"> & {
     updateComponent: UpdateComponent;
 }) => StepDomainComponent;
 export declare const createEmptyStepComponent: (updateComponent: UpdateComponent) => StepDomainComponent;

package/build/types/revamp/renderers/step/ExternalConfirmationDialog.d.ts

@@ -0,0 +1,6 @@
+export declare function ExternalConfirmationDialog({ external, onClose, }: {
+    external: {
+        url: string;
+    };
+    onClose: () => void;
+}): JSX.Element;

package/build/types/revamp/renderers/{StepRenderer.d.ts → step/StepRenderer.d.ts}

@@ -1,2 +1,2 @@
-import type { Renderer, StepRendererProps } from './types';
+import type { Renderer, StepRendererProps } from '../types';
 export declare const StepRenderer: Renderer<StepRendererProps>;

package/build/types/revamp/renderers/step/useExternal.d.ts

@@ -0,0 +1,4 @@
+export declare function useExternal(url?: string): {
+    requiresUserConfirmation: boolean;
+    dismissConfirmation: () => void;
+};

package/build/types/revamp/renderers/stepComponentToProps.d.ts

@@ -1,4 +1,4 @@
 import type { ReactNode } from 'react';
 import type { StepDomainComponent } from '../domain/components/StepDomainComponent';
 import type { StepRendererProps } from './types';
-export declare const stepComponentToProps: ({ loadingState }: StepDomainComponent, children: ReactNode) => StepRendererProps;
+export declare const stepComponentToProps: ({ external, loadingState }: StepDomainComponent, children: ReactNode) => StepRendererProps;

package/build/types/revamp/renderers/types.d.ts

@@ -24,6 +24,9 @@ export type RendererProps = StepRendererProps | CoreContainerRendererProps | Ale
 export type StepRendererProps = {
     type: 'step';
     control?: string;
+    external?: {
+        url: string;
+    };
     loadingState: LoadingState;
     children: ReactNode;
 };