rokot-validate - npm Package Compare versions

Comparing version 0.4.1 to 0.5.0

lib/errors.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 var Errors;
@@ -3,0 +4,0 @@ (function (Errors) {

lib/index.d.ts

@@ -1,5 +0,5 @@
-export { IValidator, IValidatorsSpec, IValidatorSpec, IValidatorSpecWithContext, Constraints, MustConstraint, FormatConstraint, Constraint, ConstraintSpec, ConstraintFactory, ConstraintOrFactory, NumericalityConstraint, InclusionExclusionConstraint, UrlConstraint, DateConstraint, LengthConstraint, DateTimeConstraint, EqualityConstraint, TokenizerResult } from "./validate.js";
+export { IValidator, IValidatorsSpec, IValidatorSpec, IValidatorSpecWithContext, Constraints, MustConstraint, FormatConstraint, Constraint, ConstraintSpec, ClientConstraints, ClientConstraintSpec, ConstraintFactory, ConstraintOrFactory, NumericalityConstraint, InclusionExclusionConstraint, UrlConstraint, DateConstraint, LengthConstraint, DateTimeConstraint, EqualityConstraint, TokenizerResult } from "./validate.js";
 export { IValidationError, IValidationErrors, Errors, isValidationError, isNoValidationInputError } from "./errors";
-export { Validator, ValidatorWithContext, createValidator } from "./validator";
+export { Validator, ValidatorWithContext, createValidator, createClientConstraintSpec } from "./validator";
 export { Validation } from "./validation";
 export { validate } from "./validateJsWithCustomValidators";

lib/index.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 var errors_1 = require("./errors");
@@ -10,2 +11,3 @@ exports.Errors = errors_1.Errors;
 exports.createValidator = validator_1.createValidator;
+exports.createClientConstraintSpec = validator_1.createClientConstraintSpec;
 var validation_1 = require("./validation");
@@ -12,0 +14,0 @@ exports.Validation = validation_1.Validation;

lib/validate.js.d.ts

@@ -13,10 +13,19 @@ export interface IValidator<T> {
 }
+export interface ClientConstraints {
+    string?: Constraint | boolean;
+    boolean?: Constraint | boolean;
+    array?: ArrayConstraint | boolean;
+    absence?: Constraint | boolean;
+    defined?: Constraint | boolean;
+    spec?: ClientConstraintSpec<any>;
+}
 export interface Constraints {
-    string?: ConstraintOrFactory<Constraint> | Boolean;
-    boolean?: ConstraintOrFactory<Constraint> | Boolean;
-    array?: ConstraintOrFactory<ArrayConstraint> | Boolean;
-    absence?: ConstraintOrFactory<Constraint> | Boolean;
-    defined?: ConstraintOrFactory<Constraint> | Boolean;
+    string?: ConstraintOrFactory<Constraint> | boolean;
+    boolean?: ConstraintOrFactory<Constraint> | boolean;
+    array?: ConstraintOrFactory<ArrayConstraint> | boolean;
+    absence?: ConstraintOrFactory<Constraint> | boolean;
+    defined?: ConstraintOrFactory<Constraint> | boolean;
     must?: MustConstraint<any> | MustConstraint<any>[];
     validator?: IValidatorSpec<any>;
+    spec?: ConstraintSpec<any>;
 }
@@ -33,15 +42,29 @@ export declare type MustConstraintFunctionReturnType = Promise<boolean | string | string[]> | boolean | string | string[];
 }
+export declare type ClientConstraintSpec<T> = Record<keyof T, ClientConstraints>;
+export interface ClientConstraints {
+    date?: DateConstraint | boolean;
+    datetime?: DateTimeConstraint | boolean;
+    email?: Constraint | boolean;
+    equality?: EqualityConstraint | string;
+    exclusion?: InclusionExclusionConstraint | any[];
+    format?: FormatConstraint | string;
+    inclusion?: InclusionExclusionConstraint | any[];
+    length?: LengthConstraint;
+    numericality?: NumericalityConstraint | boolean;
+    presence?: Constraint | boolean;
+    url?: UrlConstraint | boolean;
+}
 export declare type ConstraintSpec<T> = Record<keyof T, Constraints>;
 export interface Constraints {
-    date?: ConstraintOrFactory<DateConstraint> | Boolean;
-    datetime?: ConstraintOrFactory<DateTimeConstraint> | Boolean;
-    email?: ConstraintOrFactory<Constraint> | Boolean;
-    equality?: ConstraintOrFactory<EqualityConstraint> | String;
+    date?: ConstraintOrFactory<DateConstraint> | boolean;
+    datetime?: ConstraintOrFactory<DateTimeConstraint> | boolean;
+    email?: ConstraintOrFactory<Constraint> | boolean;
+    equality?: ConstraintOrFactory<EqualityConstraint> | string;
     exclusion?: ConstraintOrFactory<InclusionExclusionConstraint> | any[];
-    format?: ConstraintOrFactory<FormatConstraint> | String;
+    format?: ConstraintOrFactory<FormatConstraint> | string;
     inclusion?: ConstraintOrFactory<InclusionExclusionConstraint> | any[];
     length?: ConstraintOrFactory<LengthConstraint>;
-    numericality?: ConstraintOrFactory<NumericalityConstraint> | Boolean;
-    presence?: ConstraintOrFactory<Constraint> | Boolean;
-    url?: ConstraintOrFactory<UrlConstraint> | Boolean;
+    numericality?: ConstraintOrFactory<NumericalityConstraint> | boolean;
+    presence?: ConstraintOrFactory<Constraint> | boolean;
+    url?: ConstraintOrFactory<UrlConstraint> | boolean;
 }
@@ -51,3 +74,3 @@ export interface ConstraintFactory<T extends Constraint> {
 }
-export declare type ConstraintOrFactory<T> = T | ConstraintFactory<T>;
+export declare type ConstraintOrFactory<T extends Constraint> = T | ConstraintFactory<T>;
 export interface Constraint {
@@ -108,3 +131,3 @@ message?: string;
     validators: any;
-    extend(validator: any, ...extensions: any[]): any;
+    extend<T>(validator: T, ...extensions: T[]): T;
     Promise: any;
@@ -115,5 +138,5 @@ capitalize(value: string): string;
     getDeepObjectValue(object: any, keypath: string): any;
-    isInteger(value: any): boolean;
-    isString(value: any): boolean;
-    isArray(value: any): boolean;
+    isInteger(value: any): value is number;
+    isString(value: any): value is string;
+    isArray(value: any): value is any[];
     isDefined(value: any): boolean;
@@ -124,3 +147,3 @@ isFunction(value: any): boolean;
     isEmpty(value: any): boolean;
-    isNumber(value: any): boolean;
+    isNumber(value: any): value is number;
     isObject(value: any): boolean;
@@ -127,0 +150,0 @@ isPromise(value: any): boolean;

lib/validate.js.js

 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

lib/validateJsWithCustomValidators.d.ts

 import { ValidateJsValidator } from "./validate.js";
 declare const validate: ValidateJsValidator;
 import "validate.js";
-export declare function isString(value: any): value is string;
-export declare function isArray(value: any): value is any[];
 export declare function isPromise<T>(parameter: T | Promise<T>): parameter is Promise<T>;
 export { validate };

lib/validateJsWithCustomValidators.js

@@ -10,2 +10,3 @@ "use strict";
 };
+Object.defineProperty(exports, "__esModule", { value: true });
 const moment = require("moment");
@@ -16,10 +17,2 @@ const validate = require("validate.js");
 validate.Promise = Promise;
-function isString(value) {
-    return validate.isString(value);
-}
-exports.isString = isString;
-function isArray(value) {
-    return validate.isArray(value);
-}
-exports.isArray = isArray;
 validate.error = () => { };
@@ -71,11 +64,10 @@ validate.validators.string = (value, options, key, attributes) => {
     if (!spec || !spec.constraints || !validate.isFunction(spec.constraints)) {
-        throw new Error("'validator' validator must be set to a Validator instance");
+        throw new Error("'validator' validator should be set to a Validator instance");
     }
 };
-validate.validators.must = (value, options, key, attributes) => __awaiter(this, void 0, void 0, function* () {
-    const validator = options;
+validate.validators.must = (value, validator, key, attributes) => __awaiter(this, void 0, void 0, function* () {
     if (!validator) {
-        throw new Error("validator must be provided for 'must' validator");
+        throw new Error("validator should be provided for 'must' validator");
     }
-    if (isArray(validator)) {
+    if (validate.isArray(validator)) {
         for (let i = 0; i < validator.length; i++) {
@@ -96,3 +88,3 @@ let result = yield tryValidate(validator[i], value, attributes);
         const valid = isPromise(aa) ? yield aa : aa;
-        if (isString(valid) || isArray(valid)) {
+        if (validate.isString(valid) || validate.isArray(valid)) {
             return valid;
@@ -99,0 +91,0 @@ }

lib/validation.d.ts

@@ -1,7 +0,8 @@
-import { IValidatorSpec } from "./validate.js";
+import { IValidatorSpec, ClientConstraintSpec } from "./validate.js";
 export declare class Validation {
+    static executeClient<T>(instance: any, spec: ClientConstraintSpec<T>): Promise<T>;
     static execute<T>(instance: any, validation: IValidatorSpec<T>): Promise<T>;
     private static getValidationContext<T>(spec, instance, key, parentKey);
     private static makeValidationContext<T>(spec, instance, key, parentKey, ctx?);
-    private static gatherValidators(constraints);
+    private static gatherValidators<T>(constraints);
     private static hasContext(spec);
@@ -8,0 +9,0 @@ private static recursivelyValidate(visitData, instance, spec, key?, parentKey?);

lib/validation.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 const validateJsWithCustomValidators_1 = require("./validateJsWithCustomValidators");
@@ -92,8 +101,19 @@ const errors_1 = require("./errors");
 }
+function createClientValidatorSpec(constraintSpec) {
+    return {
+        constraints() {
+            return constraintSpec;
+        }
+    };
+}
 class Validation {
+    static executeClient(instance, spec) {
+        return Validation.execute(instance, createClientValidatorSpec(spec));
+    }
     static execute(instance, validation) {
-        if (!instance) {
-            throw new errors_1.Errors.NoValidationInputError();
-        }
-        return this.recursivelyValidate(new VisitData(), instance, validation).then(result => {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!instance) {
+                throw new errors_1.Errors.NoValidationInputError();
+            }
+            const result = yield this.recursivelyValidate(new VisitData(), instance, validation);
             const errors = ValidationResultHelper.collectErrors(result, []);
@@ -108,8 +128,9 @@ if (errors.length) {
     static getValidationContext(spec, instance, key, parentKey) {
-        if (this.hasContext(spec)) {
-            return spec.getContext(instance, !key).then(ctx => {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasContext(spec)) {
+                const ctx = yield spec.getContext(instance, !key);
                 return this.makeValidationContext(spec, instance, key, parentKey, ctx);
-            });
-        }
-        return Promise.resolve(this.makeValidationContext(spec, instance, key, parentKey));
+            }
+            return this.makeValidationContext(spec, instance, key, parentKey);
+        });
     }
@@ -129,4 +150,4 @@ static makeValidationContext(spec, instance, key, parentKey, ctx) {
         let found = false;
-        Object.keys(constraints).forEach(k => {
-            var con = constraints[k];
+        Object.keys(constraints).forEach((k) => {
+            const con = constraints[k];
             if (con.validator) {
@@ -136,4 +157,8 @@ spec[k] = con.validator;
             }
+            else if (con.spec) {
+                spec[k] = createClientValidatorSpec(con.spec);
+                found = true;
+            }
         });
-        return found ? spec : null;
+        return found ? spec : undefined;
     }
@@ -144,17 +169,18 @@ static hasContext(spec) {
     static recursivelyValidate(visitData, instance, spec, key, parentKey) {
-        let id = visitData.getNextId();
-        if (validateJsWithCustomValidators_1.validate.isDefined(instance)) {
-            const stored = visitData.findStored(instance);
-            if (stored) {
-                return Promise.resolve(ValidationResultHelper.makeRef(key, parentKey, stored));
+        return __awaiter(this, void 0, void 0, function* () {
+            let id = visitData.getNextId();
+            if (validateJsWithCustomValidators_1.validate.isDefined(instance)) {
+                const stored = visitData.findStored(instance);
+                if (stored) {
+                    return ValidationResultHelper.makeRef(key, parentKey, stored);
+                }
+                visitData.store(instance, id);
             }
-            visitData.store(instance, id);
-        }
-        return this.getValidationContext(spec, instance, key, parentKey)
-            .then(context => {
-            return this.validateContext(visitData, id, context);
+            const context = yield this.getValidationContext(spec, instance, key, parentKey);
+            return yield this.validateContext(visitData, id, context);
         });
     }
     static validateContext(visitData, id, validationContext) {
-        return this.getValidationErrors(validationContext).then(errors => {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = yield this.getValidationErrors(validationContext);
             const validationResult = { id, errors: errors || [], context: validationContext };
@@ -164,27 +190,36 @@ if (!validationContext.validators || !validationContext.instance) {
             }
-            return Promise.all(this.getChildValidationResults(visitData, validationContext)).then(results => {
-                validationResult.children = results;
-                return validationResult;
-            });
+            const results = yield Validation.getChildValidationResults(visitData, validationContext);
+            validationResult.children = results;
+            return validationResult;
         });
     }
     static getChildValidationResults(visitData, validationContext) {
-        const results = [];
-        Object.keys(validationContext.validators).forEach(k => {
-            const value = validationContext.instance[k];
-            const spec = validationContext.validators[k];
-            if (!validateJsWithCustomValidators_1.validate.isDefined(value)) {
-                return;
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            const keys = Object.keys(validationContext.validators);
+            for (let i = 0; i < keys.length; i++) {
+                let key = keys[i];
+                let value = validationContext.instance[key];
+                if (!validateJsWithCustomValidators_1.validate.isDefined(value)) {
+                    continue;
+                }
+                let spec = validationContext.validators[key];
+                if (validateJsWithCustomValidators_1.validate.isArray(value)) {
+                    for (let idx = 0; idx < value.length; idx++) {
+                        let arrayKey = `${key}.${idx}`;
+                        let ve = yield this.recursivelyValidate(visitData, value[idx], spec, arrayKey, this.makeKey(arrayKey, validationContext.parentKey));
+                        if (ve) {
+                            results.push(ve);
+                        }
+                    }
+                    ;
+                    continue;
+                }
+                let ve = yield this.recursivelyValidate(visitData, value, spec, key, this.makeKey(key, validationContext.parentKey));
+                if (ve) {
+                    results.push(ve);
+                }
             }
-            if (validateJsWithCustomValidators_1.validate.isArray(value)) {
-                var res = value.map((v, idx) => {
-                    const key = `${k}.${idx}`;
-                    return this.recursivelyValidate(visitData, v, spec, key, this.makeKey(key, validationContext.parentKey));
-                });
-                results.push(...res);
-                return;
-            }
-            results.push(this.recursivelyValidate(visitData, value, spec, k, this.makeKey(k, validationContext.parentKey)));
+            return results;
         });
-        return results;
     }
@@ -195,14 +230,18 @@ static makeKey(key, parentKey) {
     static getValidationErrors(validationContext) {
-        return validateJsWithCustomValidators_1.validate.async(validationContext.instance, validationContext.constraints, { format: "detailed" })
-            .catch(errors => {
-            if (!validateJsWithCustomValidators_1.validate.isArray(errors)) {
-                throw errors;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield validateJsWithCustomValidators_1.validate.async(validationContext.instance, validationContext.constraints, { format: "detailed" });
             }
-            return errors.map(d => {
-                return {
-                    message: d.error,
-                    value: d.value,
-                    attribute: validationContext.parentKey ? `${validationContext.parentKey}.${d.attribute}` : d.attribute
-                };
-            });
+            catch (errors) {
+                if (!validateJsWithCustomValidators_1.validate.isArray(errors)) {
+                    throw errors;
+                }
+                return errors.map(d => {
+                    return {
+                        message: d.error,
+                        value: d.value,
+                        attribute: validationContext.parentKey ? `${validationContext.parentKey}.${d.attribute}` : d.attribute
+                    };
+                });
+            }
         });
@@ -209,0 +248,0 @@ }

lib/validator.d.ts

@@ -1,12 +0,3 @@
-import { IValidator, IValidatorSpec, IValidatorSpecWithContext, ConstraintSpec, NumericalityConstraint, Constraints, MustConstraintFunctionReturnType, MustConstraintFunction } from "./validate.js";
-export declare class ConstraintBuilder {
-    numericalityStrictInteger(extend?: NumericalityConstraint): NumericalityConstraint;
-    integerStrict(extend?: NumericalityConstraint): NumericalityConstraint;
-    mandatoryIntegerStrict(extend?: NumericalityConstraint): NumericalityConstraint;
-    string(extend?: Constraints): Constraints;
-    mandatoryString(extend?: Constraints): Constraints;
-    mandatoryBoolean(extend?: Constraints): Constraints;
-    boolean(extend?: Constraints): Constraints;
-    mustValidator<T>(validator: (value: T) => MustConstraintFunctionReturnType): MustConstraintFunction<T>;
-}
+import { IValidator, IValidatorSpec, IValidatorSpecWithContext, ConstraintSpec, ClientConstraintSpec } from "./validate.js";
+import { ConstraintBuilder, ClientConstraintBuilder } from "./constraintBuilder";
 export declare abstract class ValidatorBase<T> extends ConstraintBuilder implements IValidator<T>, IValidatorSpec<T> {
@@ -19,3 +10,4 @@ validate(instance: any): Promise<T>;
 }
-export declare function createValidator<T>(constraintSpec: (builder: ConstraintBuilder) => ConstraintSpec<T>): IValidator<T>;
+export declare function createValidator<T>(constraintSpecBuilder: (builder: ConstraintBuilder) => ConstraintSpec<T>): IValidator<T>;
+export declare function createClientConstraintSpec<T>(constraintSpecBuilder: (builder: ClientConstraintBuilder) => ClientConstraintSpec<T>): ClientConstraintSpec<T>;
 export declare abstract class ValidatorWithContext<T, TContext> extends ValidatorBase<T> implements IValidatorSpecWithContext<T, TContext> {
@@ -22,0 +14,0 @@ abstract getContext(instance: any, isRootValidator?: boolean): Promise<TContext>;

lib/validator.js

 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const validateJsWithCustomValidators_1 = require("./validateJsWithCustomValidators");
+Object.defineProperty(exports, "__esModule", { value: true });
 const validation_1 = require("./validation");
-class ConstraintBuilder {
-    numericalityStrictInteger(extend) {
-        console.warn("deprecated: use integerStrict instead (simple rename)");
-        return validateJsWithCustomValidators_1.validate.extend({
-            onlyInteger: true,
-            noStrings: true
-        }, extend);
-    }
-    integerStrict(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            onlyInteger: true,
-            noStrings: true
-        }, extend);
-    }
-    mandatoryIntegerStrict(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            presence: true,
-            onlyInteger: true,
-            noStrings: true
-        }, extend);
-    }
-    string(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            string: true
-        }, extend);
-    }
-    mandatoryString(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            presence: true,
-            string: true
-        }, extend);
-    }
-    mandatoryBoolean(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            presence: true,
-            boolean: true
-        }, extend);
-    }
-    boolean(extend) {
-        return validateJsWithCustomValidators_1.validate.extend({
-            boolean: true
-        }, extend);
-    }
-    mustValidator(validator) {
-        return (value) => __awaiter(this, void 0, void 0, function* () {
-            if (validateJsWithCustomValidators_1.validate.isEmpty(value)) {
-                return true;
-            }
-            if (!validateJsWithCustomValidators_1.isArray(value)) {
-                return validator(value);
-            }
-            for (let i = 0; i < value.length; i++) {
-                let validated = validator(value[i]);
-                let result = validateJsWithCustomValidators_1.isPromise(validated) ? yield validated : validated;
-                if (result === false || validateJsWithCustomValidators_1.isString(result) || validateJsWithCustomValidators_1.isArray(result)) {
-                    return result;
-                }
-            }
-        });
-    }
-}
-exports.ConstraintBuilder = ConstraintBuilder;
-class ValidatorBase extends ConstraintBuilder {
+const constraintBuilder_1 = require("./constraintBuilder");
+class ValidatorBase extends constraintBuilder_1.ConstraintBuilder {
     validate(instance) {
@@ -83,6 +14,6 @@ return validation_1.Validation.execute(instance, this);
 exports.Validator = Validator;
-function createValidator(constraintSpec) {
+function createValidator(constraintSpecBuilder) {
     class V extends Validator {
         constraints() {
-            return constraintSpec(this);
+            return constraintSpecBuilder(this);
         }
@@ -93,4 +24,9 @@ }
 exports.createValidator = createValidator;
+const clientConstraintBuilder = new constraintBuilder_1.ClientConstraintBuilder();
+function createClientConstraintSpec(constraintSpecBuilder) {
+    return constraintSpecBuilder(clientConstraintBuilder);
+}
+exports.createClientConstraintSpec = createClientConstraintSpec;
 class ValidatorWithContext extends ValidatorBase {
 }
 exports.ValidatorWithContext = ValidatorWithContext;

package.json

 {
   "name": "rokot-validate",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Rocketmakers Rokot Platform - Validation",
@@ -8,6 +8,7 @@ "main": "./lib/index.js",
   "scripts": {
+    "format": "tsfmt -r source/**/*.ts",
     "build": "tsc -p source/tsconfig.json -d",
     "prepublish": "npm run build",
-    "debugtest": "npm run build && mocha --debug-brk",
-    "test": "npm run build && mocha"
+    "debugtest": "npm run build && ./node_modules/mocha/bin/mocha --debug-brk",
+    "test": "npm run build && ./node_modules/mocha/bin/mocha"
   },
@@ -23,3 +24,3 @@ "keywords": [
     "moment": "^2.15.1",
-    "validate.js": "^0.10.0"
+    "validate.js": "^0.11.1"
   },
@@ -29,3 +30,4 @@ "devDependencies": {
     "rokot-test": "^0.2.5",
-    "typescript": "^2.0.3"
+    "typescript": "~2.2.0",
+    "typescript-formatter": "4.1.2"
   },
@@ -32,0 +34,0 @@ "homepage": "https://github.com/Rocketmakers/rokot-validate",

readme.md

@@ -66,3 +66,3 @@ # rokot-validate
         array: {
-          numericality: this.numericalityStrictInteger({greaterThan:0})
+          numericality: this.integerStrict({greaterThan:0})
         }
@@ -69,0 +69,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

61615

increased by2.68%

Number of package files

21

increased by10.53%

Worsened metrics

Dev dependency count

4

increased by33.33%

Lines of code

891

decreased by-3.15%

Dependency changes

• + Addedvalidate.js@0.11.1(transitive)

• - Removedvalidate.js@0.10.0(transitive)

• Updatedvalidate.js@^0.11.1