@wise/dynamic-flow-client 3.5.0-experimental-63c768d → 3.5.1-experimental-ccbce45

package/build/legacy/common/hooks/usePolling/usePolling.js

@@ -32,12 +32,14 @@ export function createPollingClosure(asyncFn, maxAttempts, maxConsecutiveFails,
                     .then(function (pollingResponse) {
                     consecutiveFailures = 0;
                     isPolling = onPollingResponse(pollingResponse);
-                })["catch"](function (error) {
+                })
+                    .catch(function (error) {
                     // do not fail on network errors
                     if (error.message !== 'network failed') {
                         consecutiveFailures += 1;
                     }
-                })["finally"](function () {
+                })
+                    .finally(function () {
                     if (consecutiveFailures >= maxConsecutiveFails || attemptCount >= maxAttempts) {
                         onFailure();
                         isPolling = false;

package/build/legacy/common/hooks/useStepPolling/useStepPolling.js

@@ -11,10 +11,12 @@ export function useStepPolling(polling, onAction) {
                     if (response.ok) {
                         return response
                             .json()
-                            .then(function (pollingResponse) { return pollingResponse; })["catch"](function (error) { return null; });
+                            .then(function (pollingResponse) { return pollingResponse; })
+                            .catch(function (error) { return null; });
                     }
                     throw new Error('failed');
-                })["catch"](function (error) {
+                })
+                    .catch(function (error) {
                     throw new Error(error.message === 'failed' ? 'failed' : 'network failed');
                 });
             };
@@ -38,6 +40,6 @@ export function useStepPolling(polling, onAction) {
             if (polling) {
                 onAction(polling.onError.action);
             }
-        }, [onAction, polling])
+        }, [onAction, polling]),
     });
 }

package/build/legacy/common/hooks/useStepPolling/useStepPolling.spec.js

@@ -66,8 +66,8 @@ describe('useStepPolling', function () {
                 url: POLLING_URL,
                 interval: 5,
                 maxAttempts: MAX_ATTEMPTS,
-                onError: { action: { url: '/on-error' } }
-            }
+                onError: { action: { url: '/on-error' } },
+            },
         };
         it('makes a requests to the speficied URL with the given interval', function () { return __awaiter(void 0, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -93,8 +93,8 @@ describe('useStepPolling', function () {
                                                     action: {
                                                         url: '/success',
                                                         method: 'POST',
-                                                        data: { 'action-data': '1234567890' }
-                                                    }
+                                                        data: { 'action-data': '1234567890' },
+                                                    },
                                                 }))
                                                 : new Response("{}")];
                                     });

package/build/legacy/common/messages.js

@@ -3,6 +3,6 @@ export default defineMessages({
     required: {
         id: 'dynamicFlows.DefaultErrorMessages.required',
         defaultMessage: 'Please fill out this field.',
-        description: 'Customer has left the required field empty'
-    }
+        description: 'Customer has left the required field empty',
+    },
 });

package/build/legacy/common/utils/file-utils.spec.js

@@ -39,13 +39,13 @@ describe('Given a set of utility functions for file', function () {
                     id: 111,
                     status: Status.SUCCEEDED,
                     url: 'www.something.com/file.png',
-                    filename: 'filename1.png'
+                    filename: 'filename1.png',
                 };
                 var file = {
                     id: 111,
                     status: Status.SUCCEEDED,
                     url: 'www.somethingElse.com/file.png',
-                    filename: 'filename2.png'
+                    filename: 'filename2.png',
                 };
                 expect(areFilesSame([anotherFile], [file])).toBeTruthy();
             });
@@ -54,13 +54,13 @@ describe('Given a set of utility functions for file', function () {
                     id: 111,
                     status: Status.SUCCEEDED,
                     url: 'www.something.com/file.png',
-                    filename: 'filename.png'
+                    filename: 'filename.png',
                 };
                 var file = {
                     id: 112,
                     status: Status.SUCCEEDED,
                     url: 'www.something.com/file.png',
-                    filename: 'filename.png'
+                    filename: 'filename.png',
                 };
                 expect(areFilesSame([anotherFile], [file])).toBeFalsy();
             });

package/build/legacy/common/utils/mobile-utils.spec.js

@@ -44,7 +44,7 @@ describe('hasMobileScreenSize', function () {
 });
 describe('hasTouchScreen', function () {
     var mockNavigator = {
-        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36'
+        userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
     };
     it('should return true if the device has a touch screen', function () {
         expect(isTouchScreen(__assign(__assign({}, mockNavigator), { maxTouchPoints: 1 }))).toBe(true);

package/build/legacy/common/utils/schema-utils.js

@@ -1,6 +1,6 @@
 import { isObject, isUndefined } from '../validators';
 export function isConstSchema(schema) {
-    return !isUndefined(schema === null || schema === void 0 ? void 0 : schema["const"]);
+    return !isUndefined(schema === null || schema === void 0 ? void 0 : schema.const);
 }
 export function isNoNConstSchema(schema) {
     return Boolean(schema) && !isConstSchema(schema);
@@ -14,7 +14,7 @@ export var isPromotedOneOfSchema = function (schema) {
 export var basicTypes = new Set(['string', 'number', 'integer', 'boolean']);
 export function isBasicSchema(schema) {
     return (basicTypes.has(schema.type || '') ||
-        ('const' in schema && schema["const"] !== undefined && !isObject(schema["const"])));
+        ('const' in schema && schema.const !== undefined && !isObject(schema.const)));
 }
 export function isObjectSchema(schema) {
     return schema.type === 'object';

package/build/legacy/common/validators/models/model-utils.spec.js

@@ -3,8 +3,8 @@ var basicArray = {
     type: 'array',
     items: {
         title: 'Email',
-        type: 'string'
-    }
+        type: 'string',
+    },
 };
 var objectArray = {
     type: 'array',
@@ -16,14 +16,14 @@ var objectArray = {
         properties: {
             name: {
                 title: 'Full name',
-                type: 'string'
+                type: 'string',
             },
             terms: {
                 title: 'I agree to the terms and conditions',
-                type: 'boolean'
-            }
-        }
-    }
+                type: 'boolean',
+            },
+        },
+    },
 };
 describe('cleanModelWithArraySchema', function () {
     it('should return null if the model is not an array', function () {

package/build/legacy/common/validators/models/model-validators.js

@@ -17,7 +17,7 @@ export function getValidBasicModelOrNull(model, schema) {
     if (schema.oneOf) {
         return cleanBasicModelWithOneOfSchema(model, schema);
     }
-    if (!isUndefined(schema["const"]) && model === schema["const"]) {
+    if (!isUndefined(schema.const) && model === schema.const) {
         return model;
     }
     if (schema.type) {
@@ -46,7 +46,7 @@ export function getValidObjectModelParts(model, schema) {
     if (schema.oneOf) {
         return cleanObjectModelWithOneOfSchema(model, schema);
     }
-    if (!isUndefined(schema["const"]) && isEqual(model, schema["const"])) {
+    if (!isUndefined(schema.const) && isEqual(model, schema.const)) {
         return model;
     }
     return isObjectSchema(schema) ? cleanObjectModelWithObjectSchema(model, schema) : null;

package/build/legacy/common/validators/models/model-validators.spec.js

@@ -97,7 +97,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
     });
     describe('when cleaning a const schema', function () {
         describe('when the const is a number', function () {
-            var schema = { "const": 1 };
+            var schema = { const: 1 };
             describe('if the model matches the const', function () {
                 it('should return the original model', function () {
                     var result = getValidModelParts(1, schema);
@@ -119,13 +119,13 @@ describe('Given a library for returning the valid parts of a model based on a sc
             });
             describe('if the const evaluates to false', function () {
                 it('should still return matches', function () {
-                    var result = getValidModelParts(0, { "const": 0 });
+                    var result = getValidModelParts(0, { const: 0 });
                     expect(result).toBe(0);
                 });
             });
         });
         describe('when the const is a string', function () {
-            var schema = { "const": 'one' };
+            var schema = { const: 'one' };
             describe('if the model matches the const', function () {
                 it('should return the original model', function () {
                     var result = getValidModelParts('one', schema);
@@ -147,13 +147,13 @@ describe('Given a library for returning the valid parts of a model based on a sc
             });
             describe('if the const evaluates to false', function () {
                 it('should still return matches', function () {
-                    var result = getValidModelParts('', { "const": '' });
+                    var result = getValidModelParts('', { const: '' });
                     expect(result).toBe('');
                 });
             });
         });
         describe('when the const is a boolean', function () {
-            var schema = { "const": true };
+            var schema = { const: true };
             describe('if the model matches the const', function () {
                 it('should return the original model', function () {
                     var result = getValidModelParts(true, schema);
@@ -174,7 +174,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
             });
             describe('if the const evaluates to false', function () {
                 it('should still return matches', function () {
-                    var result = getValidModelParts(false, { "const": false });
+                    var result = getValidModelParts(false, { const: false });
                     expect(result).toBe(false);
                 });
             });
@@ -185,10 +185,10 @@ describe('Given a library for returning the valid parts of a model based on a sc
             type: 'object',
             properties: {
                 a: {
-                    type: 'number'
-                }
+                    type: 'number',
+                },
             },
-            displayOrder: ['a']
+            displayOrder: ['a'],
         };
         describe('if the model has a property with the correct name and the correct type', function () {
             it('should return the property', function () {
@@ -225,25 +225,25 @@ describe('Given a library for returning the valid parts of a model based on a sc
             type: 'object',
             properties: {
                 a: {
-                    type: 'number'
+                    type: 'number',
                 },
                 b: {
                     type: 'object',
                     properties: {
                         c: {
-                            type: 'number'
-                        }
+                            type: 'number',
+                        },
                     },
-                    displayOrder: ['c']
+                    displayOrder: ['c'],
                 },
                 d: {
-                    "const": 1
+                    const: 1,
                 },
                 e: {
-                    "const": { f: 2 }
-                }
+                    const: { f: 2 },
+                },
             },
-            displayOrder: ['a', 'b', 'c', 'd', 'e']
+            displayOrder: ['a', 'b', 'c', 'd', 'e'],
         };
         describe('if the nested model is valid', function () {
             it('should be returned', function () {
@@ -265,21 +265,21 @@ describe('Given a library for returning the valid parts of a model based on a sc
                     type: 'object',
                     properties: {
                         a: {
-                            type: 'number'
-                        }
+                            type: 'number',
+                        },
                     },
-                    displayOrder: ['a']
+                    displayOrder: ['a'],
                 },
                 {
                     type: 'object',
                     properties: {
                         b: {
-                            type: 'number'
-                        }
+                            type: 'number',
+                        },
                     },
-                    displayOrder: ['b']
+                    displayOrder: ['b'],
                 },
-            ]
+            ],
         };
         describe('if all of the properties are valid', function () {
             it('should return them', function () {
@@ -320,7 +320,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
     describe('when cleaning a oneOf schema of const', function () {
         describe('when the consts are numbers', function () {
             var schema = {
-                oneOf: [{ "const": 0 }, { "const": 1 }, { "const": 2 }]
+                oneOf: [{ const: 0 }, { const: 1 }, { const: 2 }],
             };
             describe('when the value is in the const collection', function () {
                 it('should return the value', function () {
@@ -346,7 +346,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
         });
         describe('when the consts are strings', function () {
             var schema = {
-                oneOf: [{ "const": 'zero' }, { "const": 'one' }, { "const": 'two' }]
+                oneOf: [{ const: 'zero' }, { const: 'one' }, { const: 'two' }],
             };
             describe('when the value is in the const collection', function () {
                 it('should return the value', function () {
@@ -371,7 +371,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
         });
         describe('when the consts are booleans', function () {
             var schema = {
-                oneOf: [{ "const": false }, { "const": true }]
+                oneOf: [{ const: false }, { const: true }],
             };
             describe('when the value is in the const collection', function () {
                 it('should return the value', function () {
@@ -393,7 +393,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
         });
         describe('when the consts are objects', function () {
             var schema = {
-                oneOf: [{ "const": { a: 1 } }, { "const": { b: 2 } }]
+                oneOf: [{ const: { a: 1 } }, { const: { b: 2 } }],
             };
             describe('when the value is in the const collection', function () {
                 it('should return the value', function () {
@@ -423,15 +423,15 @@ describe('Given a library for returning the valid parts of a model based on a sc
                     type: 'array',
                     addItemTitle: '',
                     editItemTitle: '',
-                    items: { type: 'string' }
+                    items: { type: 'string' },
                 },
                 {
                     type: 'array',
                     addItemTitle: '',
                     editItemTitle: '',
-                    items: { type: 'number' }
+                    items: { type: 'number' },
                 },
-            ]
+            ],
         };
         describe('when the model is valid for one of the one-ofs', function () {
             it('should return the model', function () {
@@ -458,21 +458,21 @@ describe('Given a library for returning the valid parts of a model based on a sc
                     type: 'object',
                     properties: {
                         a: {
-                            type: 'number'
-                        }
+                            type: 'number',
+                        },
                     },
-                    displayOrder: ['a']
+                    displayOrder: ['a'],
                 },
                 {
                     type: 'object',
                     properties: {
                         b: {
-                            type: 'number'
-                        }
+                            type: 'number',
+                        },
                     },
-                    displayOrder: ['b']
+                    displayOrder: ['b'],
                 },
-            ]
+            ],
         };
         describe('if all of the properties are valid', function () {
             it('should return them', function () {
@@ -513,12 +513,12 @@ describe('Given a library for returning the valid parts of a model based on a sc
                         nested: {
                             type: 'object',
                             properties: {
-                                a: { type: 'string' }
+                                a: { type: 'string' },
                             },
-                            displayOrder: ['a']
-                        }
+                            displayOrder: ['a'],
+                        },
                     },
-                    displayOrder: ['nested']
+                    displayOrder: ['nested'],
                 },
                 {
                     type: 'object',
@@ -526,14 +526,14 @@ describe('Given a library for returning the valid parts of a model based on a sc
                         nested: {
                             type: 'object',
                             properties: {
-                                b: { type: 'string' }
+                                b: { type: 'string' },
                             },
-                            displayOrder: ['b']
-                        }
+                            displayOrder: ['b'],
+                        },
                     },
-                    displayOrder: ['nested']
+                    displayOrder: ['nested'],
                 },
-            ]
+            ],
         };
         it('should deep merge the content of the nested objects', function () {
             var model = { nested: { a: 'one', b: 'two' } };
@@ -557,10 +557,10 @@ describe('Given a library for returning the valid parts of a model based on a sc
                         type: 'string',
                         format: 'base64url',
                         maxSize: 5242000,
-                        title: 'Invoice (optional)'
-                    }
-                }
-            }
+                        title: 'Invoice (optional)',
+                    },
+                },
+            },
         };
         it('should deep merge the content of the nested objects', function () {
             var result = getValidModelParts(['file-123', 'file-234'], schema);
@@ -572,7 +572,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
             type: 'array',
             addItemTitle: '',
             editItemTitle: '',
-            items: { type: 'number' }
+            items: { type: 'number' },
         };
         describe('when the model is an array of numbers', function () {
             var model = [1, 2, 3];
@@ -598,7 +598,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
             type: 'array',
             addItemTitle: '',
             editItemTitle: '',
-            items: { type: 'string' }
+            items: { type: 'string' },
         };
         describe('when the model is an array of strings', function () {
             var model = ['a', 'b', 'c'];
@@ -624,7 +624,7 @@ describe('Given a library for returning the valid parts of a model based on a sc
             type: 'array',
             addItemTitle: '',
             editItemTitle: '',
-            items: { type: 'boolean' }
+            items: { type: 'boolean' },
         };
         describe('when the model is an array of booleans', function () {
             var model = [true, false, true];

package/build/legacy/common/validators/schemas/schema-validators.js

@@ -76,7 +76,7 @@ function isValidSchema(value, schema) {
     if (schema.allOf) {
         return isValidAllOfSchema(value, schema);
     }
-    if (schema["const"]) {
+    if (schema.const) {
         return isValidConstSchema(value, schema);
     }
     switch (schema.type) {

package/build/legacy/common/validators/schemas/schema-validators.spec.js

@@ -8,18 +8,18 @@ describe('Given a library for validating json schema models', function () {
                 properties: {
                     a: {
                         type: 'number',
-                        minimum: 2
+                        minimum: 2,
                     },
                     b: {
                         type: 'string',
-                        minLength: 3
+                        minLength: 3,
                     },
                     c: {
-                        "const": true
-                    }
+                        const: true,
+                    },
                 },
                 required: ['a', 'c'],
-                displayOrder: ['a', 'b', 'c']
+                displayOrder: ['a', 'b', 'c'],
             };
         });
         it('should return false if the value is of an incorrect type', function () {
@@ -49,10 +49,10 @@ describe('Given a library for validating json schema models', function () {
                 editItemTitle: '',
                 items: {
                     type: 'string',
-                    minLength: 2
+                    minLength: 2,
                 },
                 minItems: 2,
-                maxItems: 2
+                maxItems: 2,
             };
         });
         it('should return false if not an array', function () {
@@ -77,13 +77,13 @@ describe('Given a library for validating json schema models', function () {
                 oneOf: [
                     {
                         type: 'string',
-                        minLength: 2
+                        minLength: 2,
                     },
                     {
                         type: 'number',
-                        minimum: 2
+                        minimum: 2,
                     },
-                ]
+                ],
             };
         });
         it('should return false if neither schema validates', function () {
@@ -105,24 +105,24 @@ describe('Given a library for validating json schema models', function () {
                         properties: {
                             a: {
                                 type: 'string',
-                                minLength: 2
-                            }
+                                minLength: 2,
+                            },
                         },
                         displayOrder: ['a'],
-                        required: ['a']
+                        required: ['a'],
                     },
                     {
                         type: 'object',
                         properties: {
                             b: {
                                 type: 'number',
-                                minimum: 2
-                            }
+                                minimum: 2,
+                            },
                         },
                         displayOrder: ['b'],
-                        required: ['b']
+                        required: ['b'],
                     },
-                ]
+                ],
             };
         });
         it('should return false if only one schema is present', function () {
@@ -143,11 +143,11 @@ describe('Given a library for validating json schema models', function () {
                 a: {
                     hidden: true,
                     type: 'number',
-                    minimum: 2
-                }
+                    minimum: 2,
+                },
             },
             required: ['a'],
-            displayOrder: ['a']
+            displayOrder: ['a'],
         };
         it('should return true for both valid and invalid schemas', function () {
             expect(isValidSchema({ a: 3 }, schema)).toBe(true);

package/build/legacy/common/validators/validationFailures/validation-failures.js

@@ -2,7 +2,7 @@ import { isEqual, isObjectModel, isStringSchema } from '../../utils';
 import { isArray, isString, isNumber, isInteger, isBoolean, isNull, } from '../types/type-validators';
 import { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from './validation-failures.utils';
 function getValidationFailures(value, schema, isRequired) {
-    if (schema["const"]) {
+    if (schema.const) {
         return getConstValidationFailures(value, schema, isRequired);
     }
     if (isNull(value)) {
@@ -90,7 +90,7 @@ function getConstValidationFailures(value, schema, isRequired) {
     if (!isValidRequired(value, isRequired)) {
         return ['required'];
     }
-    if (!isEqual(value, schema["const"])) {
+    if (!isEqual(value, schema.const)) {
         return ['const'];
     }
     return [];