@wise/dynamic-flow-client 0.4.0 → 0.4.2

package/build/common/utils/index.js

@@ -13,7 +13,7 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-utils"), exports);
 __exportStar(require("./date-utils"), exports);
 __exportStar(require("./debounce"), exports);

package/build/common/utils/is-equal.js

@@ -1,12 +1,12 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEqual = void 0;
-var isEqual = function (a, b) {
+const isEqual = (a, b) => {
     if (a === b) {
         return true;
     }
     if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every(function (item, index) { return (0, exports.isEqual)(item, b[index]); });
+        return a.length === b.length && a.every((item, index) => (0, exports.isEqual)(item, b[index]));
     }
     if (isNonNullObject(a) && isNonNullObject(b) && isObjectEquals(a, b)) {
         return true;
@@ -14,12 +14,12 @@ var isEqual = function (a, b) {
     return false;
 };
 exports.isEqual = isEqual;
-var isObjectEquals = function (a, b) {
-    var keysA = Object.keys(a);
-    var keysB = Object.keys(b);
+const isObjectEquals = (a, b) => {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
     return (keysA.length === keysB.length &&
-        keysA.every(function (key) { return Object.prototype.hasOwnProperty.call(b, key) && (0, exports.isEqual)(a[key], b[key]); }));
+        keysA.every((key) => Object.prototype.hasOwnProperty.call(b, key) && (0, exports.isEqual)(a[key], b[key])));
 };
-var isNonNullObject = function (a) {
+const isNonNullObject = (a) => {
     return typeof a === 'object' && a !== null;
 };

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

@@ -1,11 +1,11 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldDebounceSchema = exports.getSchemaType = exports.isAllOfSchema = exports.isOneOfSchema = exports.isPromotedOneOfSchema = exports.isReadOnlySchema = void 0;
-var types_1 = require("../../types");
-var constants_1 = require("../constants");
-var isReadOnlySchema = function (schema) { return !!schema.readOnly && (0, types_1.isBasicSchema)(schema); };
+const types_1 = require("../../types");
+const constants_1 = require("../constants");
+const isReadOnlySchema = (schema) => !!schema.readOnly && (0, types_1.isBasicSchema)(schema);
 exports.isReadOnlySchema = isReadOnlySchema;
-var isPromotedOneOfSchema = function (schema) { return !!schema.oneOf && !!schema.promotion; };
+const isPromotedOneOfSchema = (schema) => !!schema.oneOf && !!schema.promotion;
 exports.isPromotedOneOfSchema = isPromotedOneOfSchema;
 /**
  * @deprecated Please use isOneOfSchema type guard function from "dynamic-flow-types"
@@ -15,7 +15,7 @@ exports.isOneOfSchema = types_1.isOneOfSchema;
  * @deprecated Please use isAllOfSchema type guard function from "dynamic-flow-types"
  */
 exports.isAllOfSchema = types_1.isAllOfSchema;
-var getSchemaType = function (schema) {
+const getSchemaType = (schema) => {
     // Order of application is important here
     if ((0, exports.isReadOnlySchema)(schema)) {
         return constants_1.SchemaType.READ_ONLY;

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

@@ -1,44 +1,44 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStepType = exports.filterHiddenSchemas = exports.stepType = void 0;
-var types_1 = require("../../types");
+const types_1 = require("../../types");
 exports.stepType = {
     LAYOUT: 'layout',
-    CAMERA: 'camera'
+    CAMERA: 'camera',
 };
-var isCameraStep = function (step) {
+const isCameraStep = (step) => {
     return isFormStep(step) && hasSingleAction(step) && hasSingleFileUploadSchemaWithCameraOnly(step);
 };
-var isFormStep = function (step) { return (step === null || step === void 0 ? void 0 : 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) {
+const isFormStep = (step) => (step === null || step === void 0 ? void 0 : step.type) === 'form';
+const hasSingleAction = (step) => { var _a; return ((_a = step === null || step === void 0 ? void 0 : step.actions) === null || _a === void 0 ? void 0 : _a.length) === 1; };
+const hasSingleFileUploadSchemaWithCameraOnly = (step) => {
     if (!step.schemas) {
         return false;
     }
-    var schemas = (0, exports.filterHiddenSchemas)(step.schemas);
+    const schemas = (0, exports.filterHiddenSchemas)(step.schemas);
     if ((schemas === null || schemas === void 0 ? void 0 : schemas.length) !== 1) {
         return false;
     }
-    var firstSchema = schemas[0];
+    const firstSchema = schemas[0];
     if (!(0, types_1.isObjectSchema)(firstSchema) || Object.values(firstSchema.properties).length !== 1) {
         return false;
     }
-    var childSchema = Object.values(firstSchema.properties)[0];
+    const childSchema = Object.values(firstSchema.properties)[0];
     if (!(0, types_1.isFileUploadSchema)(childSchema)) {
         return false;
     }
     return childSchema.source === 'camera';
 };
-var filterHiddenSchemas = function (schemas) {
-    return schemas.filter(function (schema) {
+const filterHiddenSchemas = (schemas) => {
+    return schemas.filter((schema) => {
         if ((0, types_1.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 Object.values((schema === null || schema === void 0 ? void 0 : schema.properties) || {}).find((schema) => (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true);
         }
         return (schema === null || schema === void 0 ? void 0 : schema.hidden) !== true;
     });
 };
 exports.filterHiddenSchemas = filterHiddenSchemas;
-var getStepType = function (step) {
+const getStepType = (step) => {
     if (isCameraStep(step)) {
         return exports.stepType.CAMERA;
     }

package/build/common/validators/index.js

@@ -13,16 +13,16 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getArrayValidationFailures = exports.getValidationFailures = exports.isValidSchema = exports.getValidBasicModelOrNull = exports.getValidObjectModelParts = exports.getValidModelParts = void 0;
 var model_validators_1 = require("./models/model-validators");
-__createBinding(exports, model_validators_1, "getValidModelParts");
-__createBinding(exports, model_validators_1, "getValidObjectModelParts");
-__createBinding(exports, model_validators_1, "getValidBasicModelOrNull");
+Object.defineProperty(exports, "getValidModelParts", { enumerable: true, get: function () { return model_validators_1.getValidModelParts; } });
+Object.defineProperty(exports, "getValidObjectModelParts", { enumerable: true, get: function () { return model_validators_1.getValidObjectModelParts; } });
+Object.defineProperty(exports, "getValidBasicModelOrNull", { enumerable: true, get: function () { return model_validators_1.getValidBasicModelOrNull; } });
 var schema_validators_1 = require("./schemas/schema-validators");
-__createBinding(exports, schema_validators_1, "isValidSchema");
+Object.defineProperty(exports, "isValidSchema", { enumerable: true, get: function () { return schema_validators_1.isValidSchema; } });
 var validation_failures_1 = require("./validationFailures/validation-failures");
-__createBinding(exports, validation_failures_1, "getValidationFailures");
-__createBinding(exports, validation_failures_1, "getArrayValidationFailures");
+Object.defineProperty(exports, "getValidationFailures", { enumerable: true, get: function () { return validation_failures_1.getValidationFailures; } });
+Object.defineProperty(exports, "getArrayValidationFailures", { enumerable: true, get: function () { return validation_failures_1.getArrayValidationFailures; } });
 __exportStar(require("./types/type-validators"), exports);
 __exportStar(require("./values/value-validators"), exports);

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

@@ -1,11 +1,11 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getValidObjectModelParts = exports.getValidBasicModelOrNull = exports.getValidModelParts = void 0;
-var types_1 = require("../../../types");
-var types_2 = require("../../../types");
-var validators_1 = require("../../validators");
-var models_utils_1 = require("./models.utils");
-var getValidModelParts = function (model, schema) {
+const types_1 = require("../../../types");
+const types_2 = require("../../../types");
+const validators_1 = require("../../validators");
+const models_utils_1 = require("./models.utils");
+const getValidModelParts = (model, schema) => {
     if ((0, types_1.isObjectModel)(model)) {
         return getValidObjectModelParts(model, schema);
     }
@@ -22,7 +22,7 @@ function getValidBasicModelOrNull(model, schema) {
     if (schema.oneOf) {
         return (0, models_utils_1.cleanBasicModelWithOneOfSchema)(model, schema);
     }
-    if (!(0, validators_1.isUndefined)(schema["const"]) && model === schema["const"]) {
+    if (!(0, validators_1.isUndefined)(schema.const) && model === schema.const) {
         return model;
     }
     if (schema.type) {
@@ -52,7 +52,7 @@ function getValidObjectModelParts(model, schema) {
     if (schema.oneOf) {
         return (0, models_utils_1.cleanObjectModelWithOneOfSchema)(model, schema);
     }
-    if (!(0, validators_1.isUndefined)(schema["const"]) && model === schema["const"]) {
+    if (!(0, validators_1.isUndefined)(schema.const) && model === schema.const) {
         return model;
     }
     return (0, types_1.isObjectSchema)(schema) ? (0, models_utils_1.cleanObjectModelWithObjectSchema)(model, schema) : null;

package/build/common/validators/models/models.utils.js

@@ -1,36 +1,25 @@
 "use strict";
-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);
-};
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.cleanObjectModelWithOneOfSchema = exports.cleanObjectModelWithAllOfSchema = exports.cleanObjectModelWithObjectSchema = exports.cleanModelWithArraySchema = exports.cleanModelWithBooleanSchema = exports.cleanModelWithNumberSchema = exports.cleanModelWithStringSchema = exports.cleanArrayModelWithOneOfSchema = exports.cleanBasicModelWithOneOfSchema = void 0;
-var types_1 = require("../../../types");
-var type_validators_1 = require("../types/type-validators");
-var value_validators_1 = require("../values/value-validators");
-var model_validators_1 = require("./model-validators");
+const types_1 = require("../../../types");
+const type_validators_1 = require("../types/type-validators");
+const value_validators_1 = require("../values/value-validators");
+const model_validators_1 = require("./model-validators");
 function cleanBasicModelWithOneOfSchema(model, schema) {
-    return schema.oneOf.some(function (nestedSchema) { return (0, model_validators_1.getValidBasicModelOrNull)(model, nestedSchema) === model; })
+    return schema.oneOf.some((nestedSchema) => (0, model_validators_1.getValidBasicModelOrNull)(model, nestedSchema) === model)
         ? model
         : null;
 }
 exports.cleanBasicModelWithOneOfSchema = cleanBasicModelWithOneOfSchema;
 function cleanArrayModelWithOneOfSchema(model, schema) {
     var _a;
-    var validModels = schema.oneOf
-        .map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); })
-        .filter(function (item) { return item !== null; });
+    const validModels = schema.oneOf
+        .map((nestedSchema) => getValidArrayModelOrNull(model, nestedSchema))
+        .filter((item) => 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];
+    return (_a = validModels.find((model) => model.some((item) => item !== null))) !== null && _a !== void 0 ? _a : validModels[0];
 }
 exports.cleanArrayModelWithOneOfSchema = cleanArrayModelWithOneOfSchema;
 function getValidArrayModelOrNull(model, schema) {
@@ -62,24 +51,23 @@ function cleanModelWithArraySchema(model, schema) {
         return null; // we don't support tuples at the moment
     }
     if (model.length > 0) {
-        var expectedType_1 = typeof model[0];
-        if (!model.every(function (item) { return typeof item === expectedType_1; })) {
+        const expectedType = typeof model[0];
+        if (!model.every((item) => typeof item === expectedType)) {
             return new Array(model.length).fill(null);
         }
     }
-    return model.map(function (childModel) { return (0, model_validators_1.getValidBasicModelOrNull)(childModel, schema.items); });
+    return model.map((childModel) => (0, model_validators_1.getValidBasicModelOrNull)(childModel, schema.items));
 }
 exports.cleanModelWithArraySchema = cleanModelWithArraySchema;
 function cleanObjectModelWithObjectSchema(model, schema) {
-    return Object.keys(schema.properties).reduce(function (cleanedModel, property) {
-        var _a;
+    return Object.keys(schema.properties).reduce((cleanedModel, property) => {
         // If the property exists in the model, clean it, and add it
         if (model && !(0, type_validators_1.isUndefined)(model[property])) {
-            var subModel = model[property];
-            var subSchema = schema.properties[property];
-            var newValue = (0, model_validators_1.getValidModelParts)(subModel, subSchema);
+            const subModel = model[property];
+            const subSchema = schema.properties[property];
+            const newValue = (0, model_validators_1.getValidModelParts)(subModel, subSchema);
             if (!(0, type_validators_1.isNull)(newValue)) {
-                return __assign(__assign({}, cleanedModel), (_a = {}, _a[property] = newValue, _a));
+                return Object.assign(Object.assign({}, cleanedModel), { [property]: newValue });
             }
         }
         return cleanedModel;
@@ -87,11 +75,11 @@ function cleanObjectModelWithObjectSchema(model, schema) {
 }
 exports.cleanObjectModelWithObjectSchema = cleanObjectModelWithObjectSchema;
 function cleanObjectModelWithAllOfSchema(model, schema) {
-    return schema.allOf.reduce(function (cleanObjectModel, nestedSchema) {
-        var validSubsetOfModel = (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema);
+    return schema.allOf.reduce((cleanObjectModel, nestedSchema) => {
+        const validSubsetOfModel = (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema);
         if ((0, types_1.isObjectModel)(validSubsetOfModel)) {
             // Extend model with valid subset
-            return __assign(__assign({}, cleanObjectModel), validSubsetOfModel);
+            return Object.assign(Object.assign({}, cleanObjectModel), validSubsetOfModel);
         }
         return cleanObjectModel;
     }, {});
@@ -99,8 +87,8 @@ function cleanObjectModelWithAllOfSchema(model, schema) {
 exports.cleanObjectModelWithAllOfSchema = cleanObjectModelWithAllOfSchema;
 function cleanObjectModelWithOneOfSchema(model, schema) {
     return schema.oneOf
-        .map(function (nestedSchema) { return (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema); })
-        .reduce(function (combined, current) {
+        .map((nestedSchema) => (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema))
+        .reduce((combined, current) => {
         // If we didn't find anything valid yet, and current is good, return it
         if ((0, type_validators_1.isNull)(combined)) {
             return current;
@@ -118,13 +106,12 @@ function cleanObjectModelWithOneOfSchema(model, schema) {
 }
 exports.cleanObjectModelWithOneOfSchema = cleanObjectModelWithOneOfSchema;
 function deepMergeObject(object1, object2) {
-    return Object.keys(object2).reduce(function (acc, property) {
-        var _a, _b;
-        var object1Property = object1[property];
-        var object2Property = object2[property];
+    return Object.keys(object2).reduce((acc, property) => {
+        const object1Property = object1[property];
+        const object2Property = object2[property];
         if ((0, types_1.isObjectModel)(object1Property) && (0, types_1.isObjectModel)(object2Property)) {
-            return __assign(__assign({}, acc), (_a = {}, _a[property] = deepMergeObject(object1Property, object2Property), _a));
+            return Object.assign(Object.assign({}, acc), { [property]: deepMergeObject(object1Property, object2Property) });
         }
-        return __assign(__assign({}, acc), (_b = {}, _b[property] = object2[property], _b));
-    }, __assign({}, object1));
+        return Object.assign(Object.assign({}, acc), { [property]: object2[property] });
+    }, Object.assign({}, object1));
 }

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

@@ -1,9 +1,9 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidSchema = void 0;
-var types_1 = require("../../../types");
-var type_validators_1 = require("../types/type-validators");
-var validation_failures_1 = require("../validationFailures/validation-failures");
+const types_1 = require("../../../types");
+const type_validators_1 = require("../types/type-validators");
+const validation_failures_1 = require("../validationFailures/validation-failures");
 function isValidStringSchema(value, schema) {
     return !(0, validation_failures_1.getStringValidationFailures)(value, schema).length;
 }
@@ -24,10 +24,8 @@ function isValidObjectSchema(value, schema) {
         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; });
+        .map((propertyName) => isObjectPropertyValid(value[propertyName], schema.properties[propertyName], schema.required && schema.required.includes(propertyName)))
+        .every((property) => property);
 }
 function isObjectPropertyValid(propertyValue, propertySchema, isRequired) {
     if (typeof propertyValue === 'undefined') {
@@ -44,21 +42,21 @@ function isValidArraySchema(value, schema) {
     }
     return (Array.isArray(value) &&
         (0, types_1.isListArraySchema)(schema) && // TupleArraySchema not yet supported
-        value.map(function (item) { return isValidSchema(item, schema.items); }).every(function (valid) { return valid; }));
+        value.map((item) => isValidSchema(item, schema.items)).every((valid) => valid));
 }
 function isValidOneOfSchema(value, schema) {
     if (!(0, type_validators_1.isArray)(schema.oneOf)) {
         return false;
     }
-    return schema.oneOf.some(function (childSchema) { return isValidSchema(value, childSchema); });
+    return schema.oneOf.some((childSchema) => isValidSchema(value, childSchema));
 }
 function isValidAllOfSchema(value, schema) {
     if (!(0, type_validators_1.isArray)(schema.allOf)) {
         return false;
     }
     return schema.allOf
-        .map(function (childSchema) { return isValidSchema(value, childSchema); })
-        .every(function (valid) { return valid; });
+        .map((childSchema) => isValidSchema(value, childSchema))
+        .every((valid) => valid);
 }
 function isValidBlobSchema(value, schema) {
     return !(0, validation_failures_1.getBlobValidationFailures)(value, schema).length;
@@ -76,7 +74,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/common/validators/types/type-validators.js

@@ -1,25 +1,21 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUndefined = exports.isNull = exports.isArray = exports.isObject = exports.isBoolean = exports.isInteger = exports.isNumber = exports.isString = void 0;
-var isString = function (value) { return typeof value === 'string'; };
+const isString = (value) => typeof value === 'string';
 exports.isString = isString;
-var isNumber = function (value) {
-    return typeof value === 'number' && !Number.isNaN(value);
-};
+const isNumber = (value) => typeof value === 'number' && !Number.isNaN(value);
 exports.isNumber = isNumber;
-var isInteger = function (value) {
+const isInteger = (value) => {
     return (0, exports.isNumber)(value) && Math.floor(value) === value;
 };
 exports.isInteger = isInteger;
-var isBoolean = function (value) { return typeof value === 'boolean'; };
+const isBoolean = (value) => typeof value === 'boolean';
 exports.isBoolean = isBoolean;
-var isObject = function (value) {
-    return !(0, exports.isNull)(value) && !(0, exports.isUndefined)(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
-};
+const isObject = (value) => !(0, exports.isNull)(value) && !(0, exports.isUndefined)(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
 exports.isObject = isObject;
-var isArray = function (value) { return Array.isArray(value); };
+const isArray = (value) => Array.isArray(value);
 exports.isArray = isArray;
-var isNull = function (value) { return value === null; };
+const isNull = (value) => value === null;
 exports.isNull = isNull;
-var isUndefined = function (value) { return typeof value === 'undefined'; };
+const isUndefined = (value) => typeof value === 'undefined';
 exports.isUndefined = isUndefined;

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

@@ -1,12 +1,12 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlobValidationFailures = exports.getObjectValidationFailures = exports.getArrayValidationFailures = exports.getConstValidationFailures = exports.getBooleanValidationFailures = exports.getIntegerValidationFailures = exports.getNumberValidationFailures = exports.getStringValidationFailures = exports.getValidationFailures = void 0;
-var types_1 = require("../../../types");
-var Schema_1 = require("../../../types/specification/Schema");
-var type_validators_1 = require("../types/type-validators");
-var validation_failures_utils_1 = require("./validation-failures.utils");
+const types_1 = require("../../../types");
+const Schema_1 = require("../../../types/specification/Schema");
+const type_validators_1 = require("../types/type-validators");
+const validation_failures_utils_1 = require("./validation-failures.utils");
 function getValidationFailures(value, schema, isRequired) {
-    if (schema["const"]) {
+    if (schema.const) {
         return getConstValidationFailures(value, schema, isRequired);
     }
     if ((0, type_validators_1.isNull)(value)) {
@@ -38,7 +38,7 @@ function getStringValidationFailures(value, schema, isRequired) {
     if (value === '' && isRequired) {
         return ['required'];
     }
-    var failures = [];
+    const failures = [];
     if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
         failures.push('required');
     }
@@ -64,7 +64,7 @@ function getNumberValidationFailures(value, schema, isRequired) {
     if (!(0, type_validators_1.isNumber)(value) && !(0, type_validators_1.isNull)(value)) {
         return ['type'];
     }
-    var failures = [];
+    const failures = [];
     if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
         failures.push('required');
     }
@@ -88,7 +88,7 @@ function getBooleanValidationFailures(value, _schema, isRequired) {
     if (!(0, type_validators_1.isBoolean)(value) && !(0, type_validators_1.isNull)(value)) {
         return ['type'];
     }
-    var failures = [];
+    const failures = [];
     if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
         failures.push('required');
     }
@@ -99,7 +99,7 @@ function getConstValidationFailures(value, schema, isRequired) {
     if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
         return ['required'];
     }
-    if (value !== schema["const"]) {
+    if (value !== schema.const) {
         return ['const'];
     }
     return [];
@@ -112,7 +112,7 @@ function getArrayValidationFailures(value, schema, isRequired) {
     if (!(0, validation_failures_utils_1.isValidRequiredArray)(value, isRequired)) {
         return ['required'];
     }
-    var failures = [];
+    const failures = [];
     if (!(0, validation_failures_utils_1.isValidMinItems)(value, schema.minItems)) {
         failures.push('minItems');
     }
@@ -143,9 +143,9 @@ function getObjectValidationFailures(value, schema) {
     if (!(0, type_validators_1.isArray)(schema.required)) {
         return [];
     }
-    var allPresent = schema.required
-        .map(function (property) { return typeof value[property] !== 'undefined'; })
-        .reduce(function (propertyInModel, validSoFar) { return propertyInModel && validSoFar; }, true);
+    const allPresent = schema.required
+        .map((property) => typeof value[property] !== 'undefined')
+        .reduce((propertyInModel, validSoFar) => propertyInModel && validSoFar, true);
     return allPresent ? [] : ['required'];
 }
 exports.getObjectValidationFailures = getObjectValidationFailures;

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

@@ -1,14 +1,12 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidRequiredArray = exports.isValidMaxItems = exports.isValidMinItems = exports.isValidMinimum = exports.isValidMaximum = exports.isValidPattern = exports.isValidMaxLength = exports.isValidMinLength = exports.isValidRequired = void 0;
-var validators_1 = require("../../validators");
-function isValidRequired(value, isRequired) {
-    if (isRequired === void 0) { isRequired = false; }
+const validators_1 = require("../../validators");
+function isValidRequired(value, isRequired = false) {
     return !isRequired || !(0, validators_1.isUndefined)(value);
 }
 exports.isValidRequired = isValidRequired;
-function isValidRequiredArray(value, isRequired) {
-    if (isRequired === void 0) { isRequired = false; }
+function isValidRequiredArray(value, isRequired = false) {
     return !isRequired || (0, validators_1.isArray)(value);
 }
 exports.isValidRequiredArray = isValidRequiredArray;
@@ -27,7 +25,7 @@ function isValidPattern(value, pattern) {
     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);
+    const regex = new RegExp(pattern);
     return !!regex.test(value);
 }
 exports.isValidPattern = isValidPattern;

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

@@ -1,9 +1,7 @@
 "use strict";
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEmpty = void 0;
-var type_validators_1 = require("../types/type-validators");
-var isEmpty = function (value) {
-    return ((0, type_validators_1.isString)(value) && value.length === 0) ||
-        (((0, type_validators_1.isObject)(value) || (0, type_validators_1.isArray)(value)) && Object.keys(value).length === 0);
-};
+const type_validators_1 = require("../types/type-validators");
+const isEmpty = (value) => ((0, type_validators_1.isString)(value) && value.length === 0) ||
+    (((0, type_validators_1.isObject)(value) || (0, type_validators_1.isArray)(value)) && Object.keys(value).length === 0);
 exports.isEmpty = isEmpty;