@wise/dynamic-flow-client 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wise/dynamic-flow-client",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Wise Dynamic Flow web client",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -33,10 +33,10 @@
     "@storybook/manager-webpack5": "6.5.16",
     "@storybook/react": "6.5.16",
     "@storybook/testing-library": "0.0.13",
-    "@testing-library/dom": "8.20.0",
-    "@testing-library/jest-dom": "5.14.1",
-    "@testing-library/react-hooks": "^8.0.1",
-    "@testing-library/react": "^12.0.0",
+    "@testing-library/dom": "9.2.0",
+    "@testing-library/jest-dom": "5.16.5",
+    "@testing-library/react-hooks": "8.0.1",
+    "@testing-library/react": "14.0.0",
     "@testing-library/user-event": "13.2.1",
     "@transferwise/components": "43.13.49",
     "@transferwise/eslint-config": "8.0.1",
@@ -61,6 +61,7 @@
     "eslint": "8.36.0",
     "jest-environment-jsdom": "29.5.0",
     "jest-fetch-mock": "^3.0.3",
+    "jest-watch-typeahead": "^2.2.2",
     "jest": "29.5.0",
     "npm-run-all": "4.1.5",
     "postcss-cli": "^10.1.0",
@@ -112,6 +113,7 @@
     "build:compiled-messages": "cpx 'src/i18n/*.json' build/i18n",
     "test": "npm-run-all test:once test:tz",
     "test:once": "jest --config jest.config.js --env=jsdom",
+    "test:coverage": "jest --config jest.config.js --env=jsdom --coverage",
     "test:tz": "TZ=US/Pacific jest ./src/jsonSchemaForm/basicTypeSchema/BasicTypeSchema.errors.spec.js ./src/formControl/FormControl.spec.js",
     "test:watch": "pnpm test:once --watch",
     "lint": "npm-run-all lint:ts lint:css",

package/build/common/hooks/useDebouncedFunction.test.d.ts

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

package/build/common/hooks/useDebouncedFunction.test.js

@@ -1,59 +0,0 @@
-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 { waitFor } from '@testing-library/react';
-import { renderHook } from '@testing-library/react-hooks';
-import { useDebouncedFunction } from './useDebouncedFunction';
-describe('useDebouncedFunction hook', function () {
-    it('debounces a callback', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var callback, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    callback = jest.fn();
-                    result = renderHook(function () { return useDebouncedFunction(callback, 200); }).result;
-                    result.current();
-                    expect(callback).not.toHaveBeenCalled();
-                    return [4 /*yield*/, waitFor(function () {
-                            expect(callback).toHaveBeenCalledTimes(1);
-                        }, { interval: 200 })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-});

package/build/common/logging/spec.d.ts

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

package/build/common/logging/spec.js

@@ -1,45 +0,0 @@
-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 { render } from '@testing-library/react';
-import { useEffect } from 'react';
-import { useLogger, LogProvider } from '.';
-describe('Logging Provider', function () {
-    var TestChild = function () {
-        var log = useLogger();
-        useEffect(function () {
-            // eslint-disable-next-line testing-library/no-debugging-utils
-            log.debug('Deprecation advanced warning', 'Some description.');
-            log.info('Invalid schema or model', 'Some description.');
-            log.warning('Action supressed', 'Some description.');
-            log.error('Deprecated schema', 'This schema is no longer supported.');
-            log.critical('Deprecated schema', 'This schema is no longer supported.');
-        }, []);
-        return _jsx("span", { children: "info,error" });
-    };
-    describe('when provider is initialised with flowId and stepId', function () {
-        describe('and is called within a component', function () {
-            function renderComponent(onLog) {
-                render(_jsx(LogProvider, __assign({ flowId: "myFlowId", stepId: "myStepId", onLog: onLog }, { children: _jsx(TestChild, {}) })));
-            }
-            it('calls the onLog callback', function () {
-                var onLog = jest.fn();
-                renderComponent(onLog);
-                expect(onLog).toHaveBeenCalledWith('debug', 'Dynamic Flow debug - Deprecation advanced warning - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
-                expect(onLog).toHaveBeenCalledWith('info', 'Dynamic Flow info - Invalid schema or model - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
-                expect(onLog).toHaveBeenCalledWith('warning', 'Dynamic Flow warning - Action supressed - Some description.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
-                expect(onLog).toHaveBeenCalledWith('error', 'Dynamic Flow error - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
-                expect(onLog).toHaveBeenCalledWith('critical', 'Dynamic Flow critical - Deprecated schema - This schema is no longer supported.', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId' }));
-            });
-        });
-    });
-});

package/build/common/tracking/spec.d.ts

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

package/build/common/tracking/spec.js

@@ -1,49 +0,0 @@
-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 { render } from '@testing-library/react';
-import { useEffect } from 'react';
-import { TrackingContextProvider, useTracking } from '.';
-describe('Tracking Provider', function () {
-    var TestChild = function (_a) {
-        var eventName = _a.eventName, properties = _a.properties;
-        var trackEvent = useTracking();
-        useEffect(function () {
-            trackEvent(eventName, properties);
-        }, []);
-        return _jsx("span", { children: eventName });
-    };
-    describe('when provider is initialised with metadata', function () {
-        describe('and is called upon mounting', function () {
-            function renderComponent(onTrackableEvent) {
-                render(_jsx(TrackingContextProvider, __assign({ metadata: { flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }, onTrackableEvent: onTrackableEvent }, { children: _jsx(TestChild, { eventName: "Dynamic Flow - Flow Started", properties: { custom: 'property' } }) })));
-            }
-            describe('it calls the onTrackableEvent callback', function () {
-                it('with the specified eventName', function () {
-                    var onTrackableEvent = jest.fn();
-                    renderComponent(onTrackableEvent);
-                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.anything());
-                });
-                it('with the specified custom properties', function () {
-                    var onTrackableEvent = jest.fn();
-                    renderComponent(onTrackableEvent);
-                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ custom: 'property' }));
-                });
-                it('with the specified flow and step ids any custom properties', function () {
-                    var onTrackableEvent = jest.fn();
-                    renderComponent(onTrackableEvent);
-                    expect(onTrackableEvent).toHaveBeenCalledWith('Dynamic Flow - Flow Started', expect.objectContaining({ flowId: 'myFlowId', stepId: 'myStepId', custom: 'property' }));
-                });
-            });
-        });
-    });
-});

package/build/common/utils/generate-random-id.test.d.ts

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

package/build/common/utils/generate-random-id.test.js

@@ -1,12 +0,0 @@
-import { generateRandomId } from './generate-random-id';
-jest.spyOn(Math, 'random').mockReturnValue(0.123456789);
-describe('generateRandomId', function () {
-    it('should generate a random id', function () {
-        var id = generateRandomId();
-        expect(id).toBe('12345678');
-    });
-    it('should generate a random id with a prefix', function () {
-        var id = generateRandomId('prefix');
-        expect(id).toBe('prefix-12345678');
-    });
-});

package/build/common/validation/rule-validators/spec.d.ts

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

package/build/common/validation/rule-validators/spec.js

@@ -1,145 +0,0 @@
-import { isValidRequired, isValidMinLength, isValidMaxLength, isValidMinimum, isValidMaximum, isValidPattern, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from '.';
-describe('Given a library for validating json schema rules', function () {
-    describe('when establishing if a value passes required validation', function () {
-        it('should return true if required and value defined', function () {
-            expect(isValidRequired('something', true)).toBe(true);
-        });
-        it('should return false if required and value undefined', function () {
-            expect(isValidRequired(undefined, true)).toBe(false);
-        });
-        it('should return true if not required', function () {
-            expect(isValidRequired(undefined, false)).toBe(true);
-            expect(isValidRequired('something', false)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes minLength validation', function () {
-        it('should return true if minLength exists and value matches or exceeds it', function () {
-            expect(isValidMinLength('a', 1)).toBe(true);
-            expect(isValidMinLength('ab', 1)).toBe(true);
-        });
-        it('should return false if minLength exists and value undefined', function () {
-            expect(isValidMinLength(undefined, 1)).toBe(false);
-        });
-        it('should return false if minLength exists and value too short', function () {
-            expect(isValidMinLength('', 1)).toBe(false);
-        });
-        it('should return true if minLength not defined', function () {
-            expect(isValidMinLength('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes maxLength validation', function () {
-        it('should return true if maxLength exists and value matches or shorter than it', function () {
-            expect(isValidMaxLength('', 2)).toBe(true);
-            expect(isValidMaxLength('a', 2)).toBe(true);
-            expect(isValidMaxLength('ab', 2)).toBe(true);
-        });
-        it('should return false if maxLength exists and value undefined', function () {
-            expect(isValidMaxLength(undefined, 2)).toBe(false);
-        });
-        it('should return false if maxLength exists and value too long', function () {
-            expect(isValidMaxLength('abc', 2)).toBe(false);
-        });
-        it('should return true if maxLength not defined', function () {
-            expect(isValidMaxLength('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes pattern validation', function () {
-        it('should return true if pattern exists and value matches it', function () {
-            expect(isValidPattern('a', '[a-z]+')).toBe(true);
-        });
-        it('should return false if pattern exists and value undefined', function () {
-            expect(isValidPattern(undefined, '[a-z]+')).toBe(false);
-        });
-        it('should return false if pattern exists and value invalid', function () {
-            expect(isValidPattern('012', '[a-z]+')).toBe(false);
-        });
-        it('should return true if pattern not defined', function () {
-            expect(isValidPattern('a', undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes minimum validation', function () {
-        it('should return true if min exists and value matches or exceeds it', function () {
-            expect(isValidMinimum(1, 1)).toBe(true);
-            expect(isValidMinimum(0, 0)).toBe(true);
-            // FIXME - these are not valid
-            // expect(isValidMinimum('2', '1')).toBe(true);
-            // expect(isValidMinimum('1', '1')).toBe(true);
-            // expect(isValidMinimum('0', '0')).toBe(true);
-        });
-        it('should return false if min exists and value undefined', function () {
-            expect(isValidMinimum(undefined, 1)).toBe(false);
-        });
-        it('should return false if min exists and value too low', function () {
-            expect(isValidMinimum(1, 2)).toBe(false);
-            expect(isValidMinimum(-1, 0)).toBe(false);
-        });
-        it('should return true if min not defined', function () {
-            expect(isValidMinimum(1, undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if a value passes maximum validation', function () {
-        it('should return true if max exists and value matches or is lower than it', function () {
-            expect(isValidMaximum(2, 2)).toBe(true);
-            expect(isValidMaximum(-1, 0)).toBe(true);
-            // FIXME - these are not valid
-            // expect(isValidMaximum('2', '2')).toBe(true);
-            // expect(isValidMaximum('0', '2')).toBe(true);
-        });
-        it('should return false if max exists and value undefined', function () {
-            expect(isValidMaximum(undefined, 2)).toBe(false);
-        });
-        it('should return false if max exists and value too high', function () {
-            expect(isValidMaximum(3, 2)).toBe(false);
-        });
-        it('should return true if max not defined', function () {
-            expect(isValidMaximum(2, undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if an array passes minItems validation', function () {
-        it('should return true if minItems exists and value length matches or exceeds it', function () {
-            expect(isValidMinItems([1], 1)).toBe(true);
-            expect(isValidMinItems([], 0)).toBe(true);
-        });
-        it('should return false if minItems exists and value undefined', function () {
-            expect(isValidMinItems(undefined, 1)).toBe(false);
-        });
-        it('should return false if minItems exists and value too short', function () {
-            expect(isValidMinItems([1], 2)).toBe(false);
-            expect(isValidMinItems([], 1)).toBe(false);
-        });
-        it('should return true if minItems not defined', function () {
-            expect(isValidMinItems([], undefined)).toBe(true);
-        });
-    });
-    describe('when establishing if an array passes maxItems validation', function () {
-        it('should return true if maxItems exists and value length matches or is less than it', function () {
-            expect(isValidMaxItems([1], 1)).toBe(true);
-            expect(isValidMaxItems([], 0)).toBe(true);
-        });
-        it('should return false if maxItems exists and value undefined', function () {
-            expect(isValidMaxItems(undefined, 1)).toBe(false);
-        });
-        it('should return false if maxItems exists and value too long', function () {
-            expect(isValidMaxItems([1, 2], 1)).toBe(false);
-        });
-        it('should return true if maxItems not defined', function () {
-            expect(isValidMaxItems([], undefined)).toBe(true);
-        });
-    });
-    describe('when establishing validations an array', function () {
-        it('should return true all values for a non-required input', function () {
-            expect(isValidRequiredArray([1], false)).toBe(true);
-            expect(isValidRequiredArray([], false)).toBe(true);
-            expect(isValidRequiredArray(undefined, false)).toBe(true);
-            expect(isValidRequiredArray(null, false)).toBe(true);
-        });
-        it('should return true for only array values for a required input', function () {
-            expect(isValidRequiredArray([1], true)).toBe(true);
-            expect(isValidRequiredArray([], true)).toBe(true);
-        });
-        it('should return false for values for a required input', function () {
-            expect(isValidRequiredArray(null, true)).toBe(false);
-            expect(isValidRequiredArray(undefined, true)).toBe(false);
-        });
-    });
-});

package/build/common/validation/schema-validators/spec.d.ts

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

package/build/common/validation/schema-validators/spec.js

@@ -1,137 +0,0 @@
-import { isValidSchema } from '.';
-describe('Given a library for validating json schema models', function () {
-    var schema;
-    describe('when validating an object schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'object',
-                properties: {
-                    a: {
-                        type: 'number',
-                        minimum: 2
-                    },
-                    b: {
-                        type: 'string',
-                        minLength: 3
-                    },
-                    c: {
-                        "const": true
-                    }
-                },
-                required: ['a', 'c'],
-                displayOrder: ['a', 'b', 'c']
-            };
-        });
-        it('should return false if the value is of an incorrect type', function () {
-            expect(isValidSchema([1], schema)).toBe(false);
-        });
-        it('should return false if a required property is missing', function () {
-            expect(isValidSchema({}, schema)).toBe(false);
-        });
-        it('should return false is a required property does not validate', function () {
-            expect(isValidSchema({ a: 1, c: true }, schema)).toBe(false);
-        });
-        it('should return false if an optional property is invalid', function () {
-            expect(isValidSchema({ a: 2, b: 'c', c: true }, schema)).toBe(false);
-        });
-        it('should return true if required properties validate and non-required fields are missing', function () {
-            expect(isValidSchema({ a: 2, c: true }, schema)).toBe(true);
-        });
-        it('should return true if all properties validate', function () {
-            expect(isValidSchema({ a: 2, b: 'cde', c: true }, schema)).toBe(true);
-        });
-    });
-    describe('when validating an array schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'array',
-                items: {
-                    type: 'string',
-                    minLength: 2
-                },
-                minItems: 2,
-                maxItems: 2
-            };
-        });
-        it('should return false if not an array', function () {
-            expect(isValidSchema({ a: 1 }, schema)).toBe(false);
-        });
-        it('should return false if the array is too small', function () {
-            expect(isValidSchema(['ab'], schema)).toBe(false);
-        });
-        it('should return false if the array is too long', function () {
-            expect(isValidSchema(['ab', 'cd', 'ef'], schema)).toBe(false);
-        });
-        it('should return false if any of the items do not validate', function () {
-            expect(isValidSchema(['ab', 'c'], schema)).toBe(false);
-        });
-        it('should return true is the array is correct size and items are valid', function () {
-            expect(isValidSchema(['ab', 'cd'], schema)).toBe(true);
-        });
-    });
-    describe('when validating a oneOf schema', function () {
-        beforeEach(function () {
-            schema = {
-                oneOf: [
-                    {
-                        type: 'string',
-                        minLength: 2
-                    },
-                    {
-                        type: 'number',
-                        minimum: 2
-                    },
-                ]
-            };
-        });
-        it('should return false if neither schema validates', function () {
-            expect(isValidSchema(true, schema)).toBe(false);
-            expect(isValidSchema('a', schema)).toBe(false);
-            expect(isValidSchema(1, schema)).toBe(false);
-        });
-        it('should return true if either schema validates', function () {
-            expect(isValidSchema('ab', schema)).toBe(true);
-            expect(isValidSchema(2, schema)).toBe(true);
-        });
-    });
-    describe('when validating an allOf schema', function () {
-        beforeEach(function () {
-            schema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            a: {
-                                type: 'string',
-                                minLength: 2
-                            }
-                        },
-                        displayOrder: ['a'],
-                        required: ['a']
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            b: {
-                                type: 'number',
-                                minimum: 2
-                            }
-                        },
-                        displayOrder: ['b'],
-                        required: ['b']
-                    },
-                ]
-            };
-        });
-        it('should return false if only one schema is present', function () {
-            expect(isValidSchema({ a: 'bc' }, schema)).toBe(false);
-            expect(isValidSchema({ b: 2 }, schema)).toBe(false);
-        });
-        it('should return false if any schemas are invalid', function () {
-            expect(isValidSchema({ a: 'bc', b: 1 }, schema)).toBe(false);
-        });
-        it('should return true if both schemas validate', function () {
-            expect(isValidSchema({ a: 'bc', b: 2 }, schema)).toBe(true);
-        });
-    });
-});

package/build/common/validation/valid-model/spec.d.ts

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