@wise/dynamic-flow-client 3.7.0 → 3.7.2-experimental-1ba6fef

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

@@ -0,0 +1,32 @@
+import { isObjectSchema, isFileUploadSchema } from './schema-utils';
+export var isCameraStep = function (step) {
+    return isFormStep(step) && hasSingleAction(step) && hasSingleFileUploadSchemaWithCameraOnly(step);
+};
+var isFormStep = function (step) { return !step.type || step.type === 'form'; };
+var hasSingleAction = function (step) { var _a; return ((_a = step === null || step === void 0 ? void 0 : step.actions) === null || _a === void 0 ? void 0 : _a.length) === 1; };
+var hasSingleFileUploadSchemaWithCameraOnly = function (step) {
+    if (!step.schemas) {
+        return false;
+    }
+    var schemas = filterHiddenSchemas(step.schemas);
+    if ((schemas === null || schemas === void 0 ? void 0 : schemas.length) !== 1) {
+        return false;
+    }
+    var firstSchema = schemas[0];
+    if (!isObjectSchema(firstSchema) || Object.values(firstSchema.properties).length !== 1) {
+        return false;
+    }
+    var childSchema = Object.values(firstSchema.properties)[0];
+    if (!isFileUploadSchema(childSchema)) {
+        return false;
+    }
+    return childSchema.source === 'camera';
+};
+export var filterHiddenSchemas = function (schemas) {
+    return schemas.filter(function (schema) {
+        if (isObjectSchema(schema)) {
+            return Object.values((schema === null || schema === void 0 ? void 0 : schema.properties) || {}).find(function (schema) { return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true; });
+        }
+        return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true;
+    });
+};

package/build/legacy/common/validators/index.js

@@ -0,0 +1,5 @@
+export { getValidModelParts, getValidObjectModelParts, getValidBasicModelOrNull, } from './models/model-validators';
+export { isValidSchema } from './schemas/schema-validators';
+export { getValidationFailures, getArrayValidationFailures, } from './validationFailures/validation-failures';
+export * from './types/type-validators';
+export * from './values/value-validators';

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-utils.spec.js

@@ -0,0 +1,45 @@
+import { cleanModelWithArraySchema } from './model-utils';
+var basicArray = {
+    type: 'array',
+    items: {
+        title: 'Email',
+        type: 'string',
+    },
+};
+var objectArray = {
+    type: 'array',
+    addItemTitle: '',
+    editItemTitle: '',
+    items: {
+        type: 'object',
+        displayOrder: ['name', 'terms'],
+        properties: {
+            name: {
+                title: 'Full name',
+                type: 'string',
+            },
+            terms: {
+                title: 'I agree to the terms and conditions',
+                type: 'boolean',
+            },
+        },
+    },
+};
+describe('cleanModelWithArraySchema', function () {
+    it('should return null if the model is not an array', function () {
+        expect(cleanModelWithArraySchema('foo', basicArray)).toBeNull();
+    });
+    it('should return an empty array if the model is an empty array', function () {
+        expect(cleanModelWithArraySchema([], basicArray)).toStrictEqual([]);
+    });
+    // This is kind of strange behaviour, but it's existing, so I don't want to change it
+    it('should return an array of nulls if the model has items with different types', function () {
+        expect(cleanModelWithArraySchema(['foo', 1], basicArray)).toStrictEqual([null, null]);
+    });
+    it('should return the model if the model is a non-empty array', function () {
+        expect(cleanModelWithArraySchema(['foo'], basicArray)).toStrictEqual(['foo']);
+    });
+    it('should return valid model parts of each item in the array', function () {
+        expect(cleanModelWithArraySchema([{ name: 'foo', terms: true }, { cat: 'chaos' }], objectArray)).toStrictEqual([{ name: 'foo', terms: true }, {}]);
+    });
+});

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);
+}