@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/flow/fixtures/schemas/one-of.js

@@ -0,0 +1,223 @@
+var currencies = [
+    ['EUR', 'Euro'],
+    ['GBP', 'British pound'],
+    ['INR', 'Indian rupee'],
+    ['USD', 'United States dollar'],
+    ['AED', 'United Arab Emirates dirham'],
+    ['ARS', 'Argentine peso'],
+    ['AUD', 'Australian dollar'],
+    ['BDT', 'Bangladeshi taka'],
+    ['BGN', 'Bulgarian lev'],
+    ['BRL', 'Brazilian real'],
+    ['BWP', 'Botswana pula'],
+    ['CAD', 'Canadian dollar'],
+    ['CHF', 'Swiss franc'],
+    ['CLP', 'Chilean peso'],
+    ['CNY', 'Chinese yuan'],
+    ['COP', 'Colombian peso'],
+    ['CRC', 'Costa Rican colón'],
+    ['CZK', 'Czech koruna'],
+    ['DKK', 'Danish krone'],
+    ['EGP', 'Egyptian pound'],
+    ['FJD', 'Fijian dollar'],
+    ['GEL', 'Georgian lari'],
+    ['GHS', 'Ghanaian cedi'],
+    ['GTQ', 'Guatemalan quetzal'],
+    ['HKD', 'Hong Kong dollar'],
+    ['HRK', 'Croatian kuna'],
+    ['HUF', 'Hungarian forint'],
+    ['IDR', 'Indonesian rupiah'],
+    ['ILS', 'Israeli shekel'],
+    ['JPY', 'Japanese yen'],
+    ['KES', 'Kenyan shilling'],
+    ['KRW', 'South Korean won'],
+    ['LKR', 'Sri Lankan rupee'],
+    ['MAD', 'Moroccan dirham'],
+    ['MXN', 'Mexican peso'],
+    ['MYR', 'Malaysian ringgit'],
+    ['MZN', 'Mozambican metical'],
+    ['NAD', 'Namibian dollar'],
+    ['NGN', 'Nigerian naira'],
+    ['NOK', 'Norwegian krone'],
+    ['NPR', 'Nepalese rupee'],
+    ['NZD', 'New Zealand dollar'],
+    ['PEN', 'Peruvian nuevo sol'],
+    ['PHP', 'Philippine peso'],
+    ['PKR', 'Pakistani rupee'],
+    ['PLN', 'Polish złoty'],
+    ['RON', 'Romanian leu'],
+    ['RUB', 'Russian rouble'],
+    ['SEK', 'Swedish krona'],
+    ['SGD', 'Singapore dollar'],
+    ['THB', 'Thai baht'],
+    ['TRY', 'Turkish lira'],
+    ['TZS', 'Tanzanian shilling'],
+    ['UAH', 'Ukrainian hryvnia'],
+    ['UGX', 'Ugandan shilling'],
+    ['UYU', 'Uruguayan peso'],
+    ['VND', 'Vietnamese dong'],
+    ['XOF', 'West African CFA franc'],
+    ['ZAR', 'South African rand'],
+    ['ZMW', 'Zambian kwacha'],
+];
+var step = {
+    key: 'Schemas/OneOf',
+    title: 'OneOf Schemas',
+    description: 'OneOf Schema using select, radio buttons and tabs.',
+    type: 'form',
+    analytics: { custom: 'this is the oneOf fixture' },
+    actions: [],
+    schemas: [
+        {
+            $id: '#the-schema',
+            type: 'object',
+            displayOrder: ['account-type-radio', 'colour-select', 'currency', 'bank-details-tabs'],
+            required: ['bank-details-tabs'],
+            properties: {
+                'account-type-radio': {
+                    title: 'Personal or Business Account? (oneOf schema with two options default to control: "radio")',
+                    analyticsId: 'account-type-radio',
+                    oneOf: [
+                        {
+                            title: 'Personal',
+                            analyticsId: 'account-type-radio-personal',
+                            icon: {
+                                name: 'person'
+                            },
+                            "const": 'PERSONAL'
+                        },
+                        {
+                            title: 'Business',
+                            analyticsId: 'account-type-radio-business',
+                            icon: {
+                                name: 'briefcase'
+                            },
+                            "const": 'BUSINESS'
+                        },
+                    ]
+                },
+                'colour-select': {
+                    title: 'What is your favourite colour? (oneOf schema with more than two options default to control: "select")',
+                    placeholder: 'Please select a colour',
+                    analyticsId: 'colour-select',
+                    oneOf: [
+                        {
+                            title: 'Blue',
+                            analyticsId: 'colour-select-blue',
+                            image: {
+                                url: 'https://placeholder.pics/svg/64/0099ff/FFFFFF'
+                            },
+                            "const": 1
+                        },
+                        {
+                            title: 'Yellow',
+                            analyticsId: 'colour-select-yellow',
+                            image: {
+                                url: 'https://placeholder.pics/svg/64/ffcc00/FFFFFF'
+                            },
+                            "const": 2
+                        },
+                        {
+                            title: 'Red',
+                            analyticsId: 'colour-select-red',
+                            image: {
+                                url: 'https://placeholder.pics/svg/64/ff6600/FFFFFF'
+                            },
+                            "const": 3
+                        },
+                    ]
+                },
+                currency: {
+                    title: 'Currency (oneof schema of const schemas with default value)',
+                    type: 'string',
+                    analyticsId: 'currency',
+                    oneOf: currencies.map(function (_a) {
+                        var code = _a[0], name = _a[1];
+                        return ({
+                            title: code,
+                            analyticsId: code,
+                            icon: { name: "flag-".concat(code.toLowerCase()) },
+                            description: name,
+                            "const": code
+                        });
+                    }),
+                    validationMessages: { required: 'Please enter currency.' },
+                    "default": 'EUR'
+                },
+                'bank-details-tabs': {
+                    title: 'Bank Details (oneOf schema of object schemas and control: "tab")',
+                    control: 'tab',
+                    analyticsId: 'bank-details-tabs',
+                    oneOf: [
+                        {
+                            type: 'object',
+                            title: 'UK Sortcode and Account Number',
+                            analyticsId: 'bank-details-tabs-uk',
+                            displayOrder: ['account-number', 'sort-code'],
+                            required: ['account-number', 'sort-code'],
+                            properties: {
+                                'account-number': {
+                                    title: 'Account Number',
+                                    type: 'string'
+                                },
+                                'sort-code': {
+                                    title: 'Sort Code',
+                                    type: 'string'
+                                }
+                            }
+                        },
+                        {
+                            type: 'object',
+                            title: 'IBAN and BIC',
+                            analyticsId: 'bank-details-tabs-iban',
+                            displayOrder: ['iban', 'bic'],
+                            required: ['iban', 'bic'],
+                            properties: {
+                                iban: {
+                                    title: 'IBAN',
+                                    type: 'string'
+                                },
+                                bic: {
+                                    title: 'BIC',
+                                    type: 'string'
+                                }
+                            }
+                        },
+                        {
+                            type: 'object',
+                            title: 'US Routing Number and Account Number',
+                            analyticsId: 'bank-details-tabs-us',
+                            displayOrder: ['account-number', 'routing-number'],
+                            required: ['account-number', 'routing-number'],
+                            properties: {
+                                'account-number': {
+                                    title: 'Account Number',
+                                    type: 'string'
+                                },
+                                'routing-number': {
+                                    title: 'Routing Number',
+                                    type: 'string'
+                                }
+                            }
+                        },
+                    ]
+                }
+            }
+        },
+    ],
+    layout: [
+        {
+            type: 'form',
+            schema: { $ref: '#the-schema' }
+        },
+        {
+            type: 'button',
+            action: {
+                url: '/submit',
+                title: 'Submit',
+                type: 'primary'
+            }
+        },
+    ]
+};
+export default step;

package/build/flow/fixtures/schemas/string-formats.d.ts

@@ -0,0 +1,3 @@
+import { Step } from '../../../dynamic-flow-types';
+declare const step: Step;
+export default step;

package/build/flow/fixtures/schemas/string-formats.js

@@ -0,0 +1,58 @@
+var step = {
+    key: 'Schemas/String Formats',
+    title: 'String Schema Formats',
+    description: 'String schemas with different formats (password, date, telephone).',
+    type: 'form',
+    actions: [],
+    schemas: [
+        {
+            $id: '#the-schema',
+            type: 'object',
+            displayOrder: ['name', 'password', 'dob', 'date-lookup', 'telephone'],
+            properties: {
+                name: {
+                    title: 'Name (string schema no format)',
+                    type: 'string'
+                },
+                password: {
+                    title: 'Password (string schema with format: "password")',
+                    type: 'string',
+                    format: 'password'
+                },
+                dob: {
+                    title: 'Date of birth (string schema with format: "date")',
+                    type: 'string',
+                    format: 'date'
+                },
+                'date-lookup': {
+                    title: 'Date Lookup (string schema with format: "date" and control: "date-lookup")',
+                    type: 'string',
+                    format: 'date',
+                    control: 'date-lookup',
+                    minimum: '2023-01-01',
+                    maximum: '2023-12-31'
+                },
+                telephone: {
+                    title: 'Phone number (string schema with format: "phone-number")',
+                    type: 'string',
+                    format: 'phone-number'
+                }
+            }
+        },
+    ],
+    layout: [
+        {
+            type: 'form',
+            schema: { $ref: '#the-schema' }
+        },
+        {
+            type: 'button',
+            action: {
+                url: '/submit',
+                title: 'Submit',
+                type: 'primary'
+            }
+        },
+    ]
+};
+export default step;

package/build/flow/index.d.ts

@@ -0,0 +1 @@
+export { default } from './DynamicFlow';

package/build/flow/index.js

@@ -0,0 +1 @@
+export { default } from './DynamicFlow';

package/build/flow/response-parsers/index.d.ts

@@ -0,0 +1,17 @@
+import { ActionResponseBody, ErrorResponseBody, Step } from '../../dynamic-flow-types';
+import { DynamicFlowProps } from '../types';
+type ParsedBody = {
+    type: 'exit';
+    result: Parameters<DynamicFlowProps['onClose']>[0];
+} | {
+    type: 'action';
+    action: ActionResponseBody['action'];
+} | {
+    type: 'step';
+    step: Step;
+    etag?: string;
+};
+export declare const parseFetchResponse: (response: Response) => Promise<ParsedBody>;
+export declare const parseErrorResponse: (response: Response) => Promise<ErrorResponseBody>;
+export declare const parseExitResponse: (response: Response) => Promise<Parameters<DynamicFlowProps['onClose']>[0]>;
+export {};

package/build/flow/response-parsers/index.js

@@ -0,0 +1,112 @@
+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 '@transferwise/neptune-validation';
+export var parseFetchResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody, action, etag;
+    var _a;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (!((_b = response.headers) === null || _b === void 0 ? void 0 : _b.has('X-Df-Exit'))) return [3 /*break*/, 2];
+                _a = { type: 'exit' };
+                return [4 /*yield*/, parseExitResponse(response)];
+            case 1: return [2 /*return*/, (_a.result = _c.sent(), _a)];
+            case 2: return [4 /*yield*/, parseResponseJson(response.clone())];
+            case 3:
+                jsonBody = _c.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in response. Expected an object.');
+                }
+                if (jsonBody.action) {
+                    if (!isObject(jsonBody.action)) {
+                        throw new Error('Incorrect response body in action response. Expected an object satisfying the type { action: Action }.');
+                    }
+                    action = jsonBody.action;
+                    if (action.exit === true && isObject(action.result)) {
+                        return [2 /*return*/, { type: 'exit', result: action.result }];
+                    }
+                    return [2 /*return*/, { type: 'action', action: jsonBody.action }];
+                }
+                etag = response.headers.get('etag') || undefined;
+                return [2 /*return*/, { type: 'step', step: jsonBody, etag: etag }];
+        }
+    });
+}); };
+export var parseErrorResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var jsonBody;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response.clone())];
+            case 1:
+                jsonBody = _a.sent();
+                if (!isObject(jsonBody)) {
+                    throw new Error('Incorrect response body in error response. Expected an object.');
+                }
+                return [2 /*return*/, jsonBody];
+        }
+    });
+}); };
+export var parseExitResponse = function (response) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, parseResponseJson(response.clone())];
+            case 1:
+                result = _a.sent();
+                if (isObject(result) || result === null) {
+                    return [2 /*return*/, result];
+                }
+                return [2 /*return*/, null];
+        }
+    });
+}); };
+var parseResponseJson = 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*/];
+        }
+    });
+}); };

package/build/flow/response-parsers/spec.d.ts

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