@wise/dynamic-flow-client 3.11.3 → 3.11.4-experiment-node20-aa45bc2

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

@@ -0,0 +1,385 @@
+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 { createBoxComponent } from '../domain/components/BoxComponent';
+import { createButtonComponent } from '../domain/components/ButtonComponent';
+import { createColumnsComponent } from '../domain/components/ColumnsComponent';
+import { createContainerComponent } from '../domain/components/ContainerComponent';
+import { createHeadingComponent } from '../domain/components/HeadingComponent';
+import { createObjectComponent } from '../domain/components/ObjectComponent';
+import { createParagraphComponent } from '../domain/components/ParagraphComponent';
+import { createMockTextInputComponent } from '../test-utils/component-utils';
+import { getSubmittableData } from './component-utils';
+describe('getSubmittableData', function () {
+    it('should return null if no components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData([])];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should ignore layout components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createHeadingComponent({
+                            uid: '0',
+                            text: 'This is a step title',
+                            align: 'start',
+                            margin: 'md',
+                            size: 'md',
+                        }),
+                        createHeadingComponent({
+                            uid: '1',
+                            text: 'This is a heading',
+                            align: 'start',
+                            margin: 'md',
+                            size: 'sm',
+                        }),
+                        createParagraphComponent({
+                            uid: '2',
+                            text: 'This is a paragraph',
+                            align: 'start',
+                            margin: 'md',
+                        }),
+                        createButtonComponent({
+                            uid: '3',
+                            title: 'This is a button',
+                            context: 'neutral',
+                            disabled: false,
+                            margin: 'md',
+                            onClick: jest.fn(),
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return data from object schemas', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createObjectComponent({
+                            uid: '0',
+                            displayOrder: ['name', 'email'],
+                            componentMap: {
+                                name: createMockTextInputComponent({
+                                    uid: '0.0',
+                                    id: 'name',
+                                    value: 'Florence Jones',
+                                }),
+                                email: createMockTextInputComponent({
+                                    uid: '0.1',
+                                    id: 'email',
+                                    value: 'florencejones@fake.com',
+                                }),
+                            },
+                            hidden: false,
+                            summariser: function () { return ({}); },
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toStrictEqual({
+                        name: 'Florence Jones',
+                        email: 'florencejones@fake.com',
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return data from schemas inside box layout components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createBoxComponent({
+                            uid: '0',
+                            border: false,
+                            margin: 'md',
+                            width: 'xl',
+                            components: [
+                                createObjectComponent({
+                                    uid: '0',
+                                    displayOrder: ['name', 'email'],
+                                    componentMap: {
+                                        name: createMockTextInputComponent({
+                                            uid: '0.0',
+                                            id: 'name',
+                                            value: 'Florence Jones',
+                                        }),
+                                        email: createMockTextInputComponent({
+                                            uid: '0.1',
+                                            id: 'email',
+                                            value: 'florencejones@fake.com',
+                                        }),
+                                    },
+                                    hidden: false,
+                                    summariser: function () { return ({}); },
+                                }),
+                            ],
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toStrictEqual({
+                        name: 'Florence Jones',
+                        email: 'florencejones@fake.com',
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return data from schemas container components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createContainerComponent({
+                            uid: '0',
+                            components: [
+                                createObjectComponent({
+                                    uid: '0',
+                                    displayOrder: ['name', 'email'],
+                                    componentMap: {
+                                        name: createMockTextInputComponent({
+                                            uid: '0.0',
+                                            id: 'name',
+                                            value: 'Florence Jones',
+                                        }),
+                                        email: createMockTextInputComponent({
+                                            uid: '0.1',
+                                            id: 'email',
+                                            value: 'florencejones@fake.com',
+                                        }),
+                                    },
+                                    hidden: false,
+                                    summariser: function () { return ({}); },
+                                }),
+                            ],
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toStrictEqual({
+                        name: 'Florence Jones',
+                        email: 'florencejones@fake.com',
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should take the last valid value, if components are not mergeable', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createMockTextInputComponent({
+                            uid: '0',
+                            id: 'name',
+                            value: 'Florence Jones',
+                        }),
+                        createMockTextInputComponent({
+                            uid: '1',
+                            id: 'email',
+                            value: 'florencejones@fake.com',
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toBe('florencejones@fake.com');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should ignore fields with no value', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createMockTextInputComponent({
+                            uid: '0',
+                            id: 'name',
+                            value: 'Florence Jones',
+                        }),
+                        createMockTextInputComponent({
+                            uid: '1',
+                            id: 'email',
+                            value: null,
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toBe('Florence Jones');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should merge data from nested components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createObjectComponent({
+                            uid: '0',
+                            displayOrder: ['name', 'bankInfo'],
+                            componentMap: {
+                                name: createMockTextInputComponent({
+                                    uid: '0.0',
+                                    id: 'name',
+                                    value: 'Florence Jones',
+                                }),
+                                bankInfo: createObjectComponent({
+                                    uid: '0.1',
+                                    displayOrder: ['accountNumber', 'sortCode'],
+                                    componentMap: {
+                                        accountNumber: createMockTextInputComponent({
+                                            uid: '0.1.0',
+                                            id: 'account',
+                                            value: '12345678',
+                                        }),
+                                        sortCode: createMockTextInputComponent({
+                                            uid: '0.1.1',
+                                            id: 'sortCode',
+                                            value: '04-00-04',
+                                        }),
+                                    },
+                                    hidden: false,
+                                    summariser: function () { return ({}); },
+                                }),
+                            },
+                            hidden: false,
+                            summariser: function () { return ({}); },
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toStrictEqual({
+                        name: 'Florence Jones',
+                        bankInfo: {
+                            accountNumber: '12345678',
+                            sortCode: '04-00-04',
+                        },
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should return data from schemas inside columns layout components', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var components, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    components = [
+                        createColumnsComponent({
+                            uid: '0',
+                            bias: 'none',
+                            margin: 'md',
+                            startComponents: [
+                                createObjectComponent({
+                                    uid: '0',
+                                    displayOrder: ['accountNumber', 'sortCode'],
+                                    componentMap: {
+                                        accountNumber: createMockTextInputComponent({
+                                            uid: '0.0',
+                                            id: 'account',
+                                            value: '12345678',
+                                        }),
+                                        sortCode: createMockTextInputComponent({
+                                            uid: '0.1',
+                                            id: 'sortCode',
+                                            value: '04-00-04',
+                                        }),
+                                    },
+                                    hidden: false,
+                                    summariser: function () { return ({}); },
+                                }),
+                            ],
+                            endComponents: [
+                                createObjectComponent({
+                                    uid: '1',
+                                    displayOrder: ['name'],
+                                    componentMap: {
+                                        name: createMockTextInputComponent({
+                                            uid: '0.1',
+                                            id: 'name',
+                                            value: 'Florence Jones',
+                                        }),
+                                    },
+                                    hidden: false,
+                                    summariser: function () { return ({}); },
+                                }),
+                            ],
+                        }),
+                    ];
+                    _a = expect;
+                    return [4 /*yield*/, getSubmittableData(components)];
+                case 1:
+                    _a.apply(void 0, [_b.sent()]).toStrictEqual({
+                        accountNumber: '12345678',
+                        sortCode: '04-00-04',
+                        name: 'Florence Jones',
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

package/build/revamp/utils/findComponent.js

@@ -0,0 +1,29 @@
+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 { hasChildren } from './type-utils';
+export var findComponent = function (components, id) {
+    var flattened = flattenComponents(components);
+    var matching = flattened.filter(function (component) { return component.uid === id; });
+    if (matching.length === 1) {
+        return matching[0];
+    }
+    if (matching.length > 1) {
+        throw new Error("Multiple components with the same uid: ".concat(id));
+    }
+    throw new Error("Failed to find any components with uid: ".concat(id));
+};
+var flattenComponents = function (components) {
+    return components.reduce(function (acc, component) {
+        if (hasChildren(component)) {
+            return __spreadArray(__spreadArray(__spreadArray([], acc, true), [component], false), flattenComponents(component.getChildren()), true);
+        }
+        return __spreadArray(__spreadArray([], acc, true), [component], false);
+    }, []);
+};

package/build/revamp/utils/findComponent.spec.js

@@ -0,0 +1,92 @@
+import { createObjectComponent } from '../domain/components/ObjectComponent';
+import { createMockTextInputComponent } from '../test-utils/component-utils';
+import { findComponent } from './findComponent';
+describe('findComponent', function () {
+    describe('given a valid component tree with unique ids', function () {
+        var accountNumberComponent = createMockTextInputComponent({
+            uid: '0.1.0',
+            id: 'account',
+            value: '12345678',
+        });
+        var getComponents = function () { return [
+            createObjectComponent({
+                uid: '0',
+                displayOrder: ['name', 'bankInfo'],
+                componentMap: {
+                    name: createMockTextInputComponent({
+                        uid: '0.0',
+                        id: 'name',
+                        value: 'Florence Jones',
+                    }),
+                    bankInfo: createObjectComponent({
+                        uid: '0.1',
+                        displayOrder: ['accountNumber', 'sortCode'],
+                        componentMap: {
+                            accountNumber: accountNumberComponent,
+                            sortCode: createMockTextInputComponent({
+                                uid: '0.1.1',
+                                id: 'sortCode',
+                                value: '04-00-04',
+                            }),
+                        },
+                        hidden: false,
+                        summariser: function () { return ({}); },
+                    }),
+                },
+                hidden: false,
+                summariser: function () { return ({}); },
+            }),
+        ]; };
+        it('should find component at root level', function () {
+            var components = getComponents();
+            expect(findComponent(components, '0')).toStrictEqual(components[0]);
+        });
+        it('should find nested components', function () {
+            var components = getComponents();
+            expect(findComponent(components, '0.1.0')).toStrictEqual(accountNumberComponent);
+        });
+        it('should throw if component not found', function () {
+            var components = getComponents();
+            expect(function () { return findComponent(components, '0.9999.0'); }).toThrow('Failed to find any components with uid: 0.9999.0');
+        });
+    });
+    describe('given a component tree with non-unique ids', function () {
+        var getComponents = function () { return [
+            createObjectComponent({
+                uid: '0',
+                displayOrder: ['name', 'bankInfo'],
+                componentMap: {
+                    name: createMockTextInputComponent({
+                        uid: '0.0',
+                        id: 'name',
+                        value: 'Florence Jones',
+                    }),
+                    bankInfo: createObjectComponent({
+                        uid: '0.1',
+                        displayOrder: ['accountNumber', 'sortCode'],
+                        componentMap: {
+                            accountNumber: createMockTextInputComponent({
+                                uid: '0.1.0',
+                                id: 'account',
+                                value: '12345678',
+                            }),
+                            sortCode: createMockTextInputComponent({
+                                uid: '0.1.0',
+                                id: 'sortCode',
+                                value: '04-00-04',
+                            }),
+                        },
+                        hidden: false,
+                        summariser: function () { return ({}); },
+                    }),
+                },
+                hidden: false,
+                summariser: function () { return ({}); },
+            }),
+        ]; };
+        it('should throw if multiple components with the same id', function () {
+            var components = getComponents();
+            expect(function () { return findComponent(components, '0.1.0'); }).toThrow(/multiple components with the same uid: 0.1.0/i);
+        });
+    });
+});

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

@@ -0,0 +1,59 @@
+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 isArrayLocalValue = function (value) {
+    return Array.isArray(value);
+};
+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; };