@wise/dynamic-flow-client 3.3.2 → 3.4.0-experimental-9862ccf

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

@@ -0,0 +1,119 @@
+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 { isObjectModel, isArraySchema, isListArraySchema } from '../../utils';
+import { isArray, isBoolean, isNull, isNumber, isString, isUndefined, } from '../types/type-validators';
+import { isEmpty } from '../values/value-validators';
+import { getValidBasicModelOrNull, getValidModelParts, getValidObjectModelParts, } from './model-validators';
+export function cleanBasicModelWithOneOfSchema(model, schema) {
+    return schema.oneOf.some(function (nestedSchema) { return getValidBasicModelOrNull(model, nestedSchema) === model; })
+        ? model
+        : null;
+}
+export function cleanArrayModelWithOneOfSchema(model, schema) {
+    var _a;
+    var validModels = schema.oneOf
+        .map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); })
+        .filter(function (item) { return item !== null; });
+    if (validModels.length === 0) {
+        return null;
+    }
+    return (_a = validModels.find(function (model) { return model.some(function (item) { return item !== null; }); })) !== null && _a !== void 0 ? _a : validModels[0];
+}
+function getValidArrayModelOrNull(model, schema) {
+    if (!isArraySchema(schema)) {
+        return null;
+    }
+    if (!isListArraySchema(schema)) {
+        return null; // we don't support tuples at the moment
+    }
+    return cleanModelWithArraySchema(model, schema);
+}
+export function cleanModelWithStringSchema(model) {
+    return isString(model) && !isEmpty(model) ? model : null;
+}
+export function cleanModelWithNumberSchema(model) {
+    return isNumber(model) ? model : null;
+}
+export function cleanModelWithBooleanSchema(model) {
+    return isBoolean(model) ? model : null;
+}
+export function cleanModelWithArraySchema(model, schema) {
+    if (!isArray(model)) {
+        return null;
+    }
+    if (!isListArraySchema(schema)) {
+        return null; // we don't support tuples at the moment
+    }
+    if (model.length > 0) {
+        var expectedType_1 = typeof model[0];
+        // eslint-disable-next-line valid-typeof
+        if (!model.every(function (item) { return typeof item === expectedType_1; })) {
+            return new Array(model.length).fill(null);
+        }
+    }
+    return model.map(function (childModel) { return getValidModelParts(childModel, schema.items); });
+}
+export function cleanObjectModelWithObjectSchema(model, schema) {
+    return Object.keys(schema.properties).reduce(function (cleanedModel, property) {
+        var _a;
+        // If the property exists in the model, clean it, and add it
+        if (model && !isUndefined(model[property])) {
+            var subModel = model[property];
+            var subSchema = schema.properties[property];
+            var newValue = getValidModelParts(subModel, subSchema);
+            if (!isNull(newValue)) {
+                return __assign(__assign({}, cleanedModel), (_a = {}, _a[property] = newValue, _a));
+            }
+        }
+        return cleanedModel;
+    }, {});
+}
+export function cleanObjectModelWithAllOfSchema(model, schema) {
+    return schema.allOf.reduce(function (cleanObjectModel, nestedSchema) {
+        var validSubsetOfModel = getValidObjectModelParts(model, nestedSchema);
+        if (isObjectModel(validSubsetOfModel)) {
+            // Extend model with valid subset
+            return __assign(__assign({}, cleanObjectModel), validSubsetOfModel);
+        }
+        return cleanObjectModel;
+    }, {});
+}
+export function cleanObjectModelWithOneOfSchema(model, schema) {
+    return schema.oneOf
+        .map(function (nestedSchema) { return getValidObjectModelParts(model, nestedSchema); })
+        .reduce(function (combined, current) {
+        // If we didn't find anything valid yet, and current is good, return it
+        if (isNull(combined)) {
+            return current;
+        }
+        // If we're dealing with two objects, deep merge them into one
+        if (isObjectModel(combined) && isObjectModel(current)) {
+            return deepMergeObject(combined, current);
+        }
+        // If the current one is null, return what we already had
+        if (isNull(current)) {
+            return combined;
+        }
+        return current;
+    }, null);
+}
+function deepMergeObject(object1, object2) {
+    return Object.keys(object2).reduce(function (acc, property) {
+        var _a, _b;
+        var object1Property = object1[property];
+        var object2Property = object2[property];
+        if (isObjectModel(object1Property) && isObjectModel(object2Property)) {
+            return __assign(__assign({}, acc), (_a = {}, _a[property] = deepMergeObject(object1Property, object2Property), _a));
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[property] = object2[property], _b));
+    }, __assign({}, object1));
+}

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

@@ -0,0 +1,62 @@
+import { isArrayModel, isObjectModel, isBasicSchema, isOneOfSchema, isArraySchema, isObjectSchema, isEqual, } from '../../utils';
+import { isNull, isUndefined } from '..';
+import { cleanArrayModelWithOneOfSchema, cleanBasicModelWithOneOfSchema, cleanModelWithArraySchema, cleanModelWithBooleanSchema, cleanModelWithNumberSchema, cleanModelWithStringSchema, cleanObjectModelWithAllOfSchema, cleanObjectModelWithObjectSchema, cleanObjectModelWithOneOfSchema, } from './model-utils';
+export var getValidModelParts = function (model, schema) {
+    if (isObjectModel(model)) {
+        return getValidObjectModelParts(model, schema);
+    }
+    if (isArrayModel(model)) {
+        return getValidArrayModelParts(model, schema);
+    }
+    return getValidBasicModelOrNull(model, schema);
+};
+export function getValidBasicModelOrNull(model, schema) {
+    if (isNull(model)) {
+        return null;
+    }
+    if (schema.oneOf) {
+        return cleanBasicModelWithOneOfSchema(model, schema);
+    }
+    if (!isUndefined(schema["const"]) && model === schema["const"]) {
+        return model;
+    }
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return cleanModelWithStringSchema(model);
+            case 'number':
+            case 'integer':
+                return cleanModelWithNumberSchema(model);
+            case 'boolean':
+                return cleanModelWithBooleanSchema(model);
+            default:
+                return null;
+        }
+    }
+    // Unrecognised schema
+    return null;
+}
+export function getValidObjectModelParts(model, schema) {
+    if (isBasicSchema(schema) || isArraySchema(schema) || isNull(model)) {
+        return null;
+    }
+    if (schema.allOf) {
+        return cleanObjectModelWithAllOfSchema(model, schema);
+    }
+    if (schema.oneOf) {
+        return cleanObjectModelWithOneOfSchema(model, schema);
+    }
+    if (!isUndefined(schema["const"]) && isEqual(model, schema["const"])) {
+        return model;
+    }
+    return isObjectSchema(schema) ? cleanObjectModelWithObjectSchema(model, schema) : null;
+}
+function getValidArrayModelParts(model, schema) {
+    if (isOneOfSchema(schema)) {
+        return cleanArrayModelWithOneOfSchema(model, schema);
+    }
+    if (!isArraySchema(schema)) {
+        return null;
+    }
+    return cleanModelWithArraySchema(model, schema);
+}

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

@@ -0,0 +1,101 @@
+import { isListArraySchema } from '../../utils';
+import { isObject, isArray } from '../types/type-validators';
+import { getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getBlobValidationFailures, } from '../validationFailures/validation-failures';
+function isValidStringSchema(value, schema) {
+    return !getStringValidationFailures(value, schema).length;
+}
+function isValidNumberSchema(value, schema) {
+    return !getNumberValidationFailures(value, schema).length;
+}
+function isValidIntegerSchema(value, schema) {
+    return !getIntegerValidationFailures(value, schema).length;
+}
+function isValidBooleanSchema(value, schema) {
+    return !getBooleanValidationFailures(value, schema).length;
+}
+function isValidConstSchema(value, schema) {
+    return !getConstValidationFailures(value, schema).length;
+}
+function isValidObjectSchema(value, schema) {
+    if (!isObject(value) || schema.type !== 'object' || !isObject(schema.properties)) {
+        return false;
+    }
+    return Object.keys(schema.properties)
+        .map(function (propertyName) {
+        return isObjectPropertyValid(value[propertyName], schema.properties[propertyName], schema.required && schema.required.includes(propertyName));
+    })
+        .every(function (property) { return property; });
+}
+function isObjectPropertyValid(propertyValue, propertySchema, isRequired) {
+    if (propertySchema.hidden) {
+        return true;
+    }
+    if (typeof propertyValue === 'undefined') {
+        return !isRequired;
+    }
+    return isValidSchema(propertyValue, propertySchema);
+}
+function isValidArraySchema(value, schema) {
+    if (schema.type !== 'array' || !isObject(schema.items)) {
+        return false;
+    }
+    if (getArrayValidationFailures(value, schema).length > 0) {
+        return false;
+    }
+    return (Array.isArray(value) &&
+        isListArraySchema(schema) && // TupleArraySchema not yet supported
+        value.map(function (item) { return isValidSchema(item, schema.items); }).every(function (valid) { return valid; }));
+}
+function isValidOneOfSchema(value, schema) {
+    if (!isArray(schema.oneOf)) {
+        return false;
+    }
+    return schema.oneOf.some(function (childSchema) { return isValidSchema(value, childSchema); });
+}
+function isValidAllOfSchema(value, schema) {
+    if (!isArray(schema.allOf)) {
+        return false;
+    }
+    return schema.allOf
+        .map(function (childSchema) { return isValidSchema(value, childSchema); })
+        .every(function (valid) { return valid; });
+}
+function isValidBlobSchema(value, schema) {
+    return !getBlobValidationFailures(value, schema).length;
+}
+/**
+ * Validate any value against a given schema
+ *
+ * @param value
+ * @param schema
+ */
+function isValidSchema(value, schema) {
+    if (schema.oneOf) {
+        return isValidOneOfSchema(value, schema);
+    }
+    if (schema.allOf) {
+        return isValidAllOfSchema(value, schema);
+    }
+    if (schema["const"]) {
+        return isValidConstSchema(value, schema);
+    }
+    switch (schema.type) {
+        case 'string':
+            return isValidStringSchema(value, schema);
+        case 'number':
+            return isValidNumberSchema(value, schema);
+        case 'integer':
+            return isValidIntegerSchema(value, schema);
+        case 'boolean':
+            return isValidBooleanSchema(value, schema);
+        case 'array':
+            return isValidArraySchema(value, schema);
+        case 'object':
+            return isValidObjectSchema(value, schema);
+        case 'blob':
+            return isValidBlobSchema(value, schema);
+        default:
+            return false;
+    }
+}
+export { isValidSchema };

package/build/legacy/common/validators/types/type-validators.js

@@ -0,0 +1,14 @@
+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 !isNull(value) && !isUndefined(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'; };

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

@@ -0,0 +1,139 @@
+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"]) {
+        return getConstValidationFailures(value, schema, isRequired);
+    }
+    if (isNull(value)) {
+        return isRequired ? ['required'] : [];
+    }
+    if (isStringSchema(schema)) {
+        return getStringValidationFailures(value, schema, isRequired);
+    }
+    switch (schema.type) {
+        case 'number':
+            return getNumberValidationFailures(value, schema, isRequired);
+        case 'integer':
+            return getIntegerValidationFailures(value, schema, isRequired);
+        case 'boolean':
+            return getBooleanValidationFailures(value, schema, isRequired);
+        case 'array':
+            return getArrayValidationFailures(value, schema, isRequired);
+        case 'object':
+            return getObjectValidationFailures(value, schema);
+        default:
+            return [];
+    }
+}
+function getStringValidationFailures(value, schema, isRequired) {
+    if (!isString(value) && !isNull(value)) {
+        return ['type'];
+    }
+    if (value === '' && isRequired) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!isValidMinLength(value, schema.minLength)) {
+        failures.push('minLength');
+    }
+    if (!isValidMaxLength(value, schema.maxLength)) {
+        failures.push('maxLength');
+    }
+    if (!isValidPattern(value, schema.pattern)) {
+        failures.push('pattern');
+    }
+    if (!isValidMinimum(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!isValidMaximum(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+function getNumberValidationFailures(value, schema, isRequired) {
+    if (!isNumber(value) && !isNull(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!isValidMinimum(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!isValidMaximum(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+function getIntegerValidationFailures(value, schema, isRequired) {
+    if (!isInteger(value)) {
+        return ['type'];
+    }
+    return getNumberValidationFailures(value, schema, isRequired);
+}
+function getBooleanValidationFailures(value, _schema, isRequired) {
+    if (!isBoolean(value) && !isNull(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!isValidRequired(value, isRequired)) {
+        failures.push('required');
+    }
+    return failures;
+}
+function getConstValidationFailures(value, schema, isRequired) {
+    if (!isValidRequired(value, isRequired)) {
+        return ['required'];
+    }
+    if (!isEqual(value, schema["const"])) {
+        return ['const'];
+    }
+    return [];
+}
+function getArrayValidationFailures(value, schema, isRequired) {
+    if (!isArray(value) && !isNull(value)) {
+        return ['type'];
+    }
+    if (!isValidRequiredArray(value, isRequired)) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!isValidMinItems(value, schema.minItems)) {
+        failures.push('minItems');
+    }
+    if (!isValidMaxItems(value, schema.maxItems)) {
+        failures.push('maxItems');
+    }
+    return failures;
+}
+function getBlobValidationFailures(value, _schema) {
+    if (isNull(value)) {
+        return ['type'];
+    }
+    return [];
+}
+/**
+ * When validating an object we only checking that it is an object and that it
+ * has the required properties, we do not check if the properties are valid.
+ *
+ * @param value
+ * @param schema
+ */
+function getObjectValidationFailures(value, schema) {
+    if (!isObjectModel(value)) {
+        return ['type'];
+    }
+    if (!isArray(schema.required)) {
+        return [];
+    }
+    var allPresent = schema.required
+        .map(function (property) { return typeof value[property] !== 'undefined'; })
+        .reduce(function (propertyInModel, validSoFar) { return propertyInModel && validSoFar; }, true);
+    return allPresent ? [] : ['required'];
+}
+export { getValidationFailures, getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getObjectValidationFailures, getBlobValidationFailures, };

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

@@ -0,0 +1,40 @@
+import { isArray, isNumber, isString, isUndefined } from '..';
+function isValidRequired(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || !isUndefined(value);
+}
+function isValidRequiredArray(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || isArray(value);
+}
+function isValidMinLength(value, minLength) {
+    return !isNumber(minLength) || (isString(value) && value.length >= minLength);
+}
+function isValidMaxLength(value, maxLength) {
+    return !isNumber(maxLength) || (isString(value) && value.length <= maxLength);
+}
+function isValidPattern(value, pattern) {
+    if (pattern === undefined) {
+        return true; // no pattern, therefore the value is valid
+    }
+    if (value === undefined || value === null) {
+        return false; // no value, but there's a pattern, therefore the value is NOT valid
+    }
+    var regex = new RegExp(pattern);
+    return Boolean(regex.test(value));
+}
+function isValidMaximum(value, maximum) {
+    return ((!isNumber(maximum) && !isString(maximum)) ||
+        ((isNumber(value) || isString(value)) && value <= maximum));
+}
+function isValidMinimum(value, minimum) {
+    return ((!isNumber(minimum) && !isString(minimum)) ||
+        ((isNumber(value) || isString(value)) && value >= minimum));
+}
+function isValidMinItems(value, minItems) {
+    return !isNumber(minItems) || (isArray(value) && value.length >= minItems);
+}
+function isValidMaxItems(value, maxItems) {
+    return !isNumber(maxItems) || (isArray(value) && value.length <= maxItems);
+}
+export { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, };

package/build/legacy/common/validators/values/value-validators.js

@@ -0,0 +1,6 @@
+import { isString, isObject, isArray } from '../types/type-validators';
+var isEmpty = function (value) {
+    return (isString(value) && value.length === 0) ||
+        ((isObject(value) || isArray(value)) && Object.keys(value).length === 0);
+};
+export { isEmpty };

package/build/legacy/dynamic-flow-types.js

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

package/build/legacy/dynamicFlow/BackButton.js

@@ -0,0 +1,22 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Avatar } from '@transferwise/components';
+import { ArrowLeft } from '@transferwise/icons';
+function BackButton(_a) {
+    var title = _a.title, action = _a.action, onAction = _a.onAction;
+    return (_jsxs("a", __assign({ href: "/", className: "df-back-btn", "aria-label": title, onClick: function (event) {
+            event.preventDefault();
+            onAction(__assign(__assign({}, action), { skipValidation: true }));
+        } }, { children: [_jsx("span", __assign({ className: "sr-only" }, { children: title })), _jsx(Avatar, __assign({ type: "icon" }, { children: _jsx(ArrowLeft, { size: "24" }) }))] })));
+}
+export default BackButton;

package/build/legacy/dynamicFlow/DynamicFlowStep.js

@@ -0,0 +1,37 @@
+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, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useExternal } from '../common/hooks';
+import { isCameraStep } from '../common/utils';
+import { DynamicAlert } from '../layout';
+import { CameraStep, LayoutStep, ExternalConfirmationStep } from '../step';
+import BackButton from './BackButton';
+export function DynamicFlowStep(props) {
+    var _a, _b, _c;
+    var step = props.step, globalError = props.globalError, onAction = props.onAction;
+    var externalUrl = (_a = step === null || step === void 0 ? void 0 : step.external) === null || _a === void 0 ? void 0 : _a.url;
+    var backButton = ((_b = step === null || step === void 0 ? void 0 : step.navigation) === null || _b === void 0 ? void 0 : _b.back) || ((_c = step === null || step === void 0 ? void 0 : step.navigation) === null || _c === void 0 ? void 0 : _c.backButton);
+    var _d = useExternal(externalUrl), requiresManualTrigger = _d.requiresManualTrigger, dismissConfirmation = _d.dismissConfirmation;
+    if (step === undefined) {
+        if (globalError) {
+            return (_jsx(DynamicAlert, { component: { context: 'negative', markdown: globalError, margin: 'lg' } }));
+        }
+        return null;
+    }
+    if (externalUrl && requiresManualTrigger) {
+        return _jsx(ExternalConfirmationStep, { url: externalUrl, onClose: dismissConfirmation });
+    }
+    if (isCameraStep(step)) {
+        return _jsx(CameraStep, __assign({}, props, { step: step }));
+    }
+    return (_jsxs(_Fragment, { children: [backButton && _jsx(BackButton, __assign({}, backButton, { onAction: onAction })), globalError ? (_jsx(DynamicAlert, { component: { context: 'negative', markdown: globalError, margin: 'lg' } })) : null, _jsx(LayoutStep, __assign({}, props, { stepSpecification: step }))] }));
+}