perf(date): Use date-fns instead of moment

Author: ricardogobbosouza

README.md

@@ -116,7 +116,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [CurrencyCode](docs/currency-code.md)
 - [Currency](docs/currency.md)
 - [DataUri](docs/data-uri.md)
-- [DateTime](docs/date-time.md)
+- [DateFormat](docs/date-format.md)
 - [Decimal](docs/decimal.md)
 - [Digit](docs/digit.md)
 - [Directory](docs/directory.md)

awesome-validator.min.js

@@ -0,0 +1,25 @@
+# DateFormat
+
+Validates if input is a date.
+
+Valid values:
+
+```js
+validator.dateFormat().validate('2008');
+validator.dateFormat().validate(new Date(2008, 1, 29));
+validator.dateFormat().validate('2008-02-29');
+validator.dateFormat().validate(2008);
+validator.dateFormat().validate(moment([2008]));
+validator.dateFormat().validate([]);
+validator.dateFormat().validate({});
+validator.dateFormat('DD-MM-YYYY').validate('29-02-2008');
+validator.dateFormat('DD/MM/YYYY HH:mm:ss').validate('20/10/2008 10:30:29');
+```
+
+Invalid values:
+
+```js
+validator.dateFormat().validate('');
+validator.dateFormat().validate('2009-12-00');
+validator.dateFormat('DD/MM/YYYY').validate('2008-02-29');
+```

docs/date-format.md

@@ -60,14 +60,14 @@
     "@types/deep-equal": "^1.0.1",
     "@types/mime-types": "^2.1.0",
     "chardet": "^0.4.2",
+    "date-fns": "^2.0.0-alpha.7",
     "deep-equal": "^1.0.1",
-    "mime-types": "^2.1.17",
-    "moment": "^2.20.1"
+    "mime-types": "^2.1.17"
   },
   "devDependencies": {
     "@cknow/tslint-config": "^3.3.0",
-    "@types/chai": "^4.1.1",
-    "@types/mocha": "^2.2.46",
+    "@types/chai": "^4.1.2",
+    "@types/mocha": "^2.2.48",
     "@types/mock-fs": "^3.6.30",
     "awesome-typescript-loader": "^3.4.1",
     "chai": "^4.1.2",
@@ -83,7 +83,7 @@
     "temp-write": "^3.4.0",
     "ts-node": "^4.1.0",
     "tslint": "^5.9.1",
-    "typescript": "^2.6.2",
+    "typescript": "^2.7.1",
     "validate-commit-msg": "^2.14.0",
     "webpack": "^3.10.0"
   },

docs/date-time.md

@@ -1,53 +1,44 @@
-import * as moment from 'moment';
+import { format as formatDate, isValid, parse as parseDate, toDate } from 'date-fns';
 
 import { AbstractRule } from './abstract-rule';
-import { BooleanType } from './boolean-type';
-import { NumberVal } from './number-val';
-import { StringType } from './string-type';
 
 export abstract class AbstractDate extends AbstractRule {
 
     /**
      * Parse.
      */
-    public static parse(input: any, format?: moment.MomentFormatSpecification): moment.Moment {
-        if (new NumberVal().validate(input)) {
-            if (moment([input]).isValid()) {
-                return moment([input]);
-            }
-
-            return moment.unix(Number(input));
+    public static parse(input: any, format?: string): Date | null {
+        if (typeof input !== 'string' || !format) {
+            return isValid(input) ? toDate(input) : null;
         }
 
-        if (new StringType().validate(input)) {
-            return moment(input, format, !!format);
-        }
+        const parsed: Date = parseDate(String(input), format, new Date());
 
-        if (new BooleanType().validate(input)) {
-            return moment();
+        if (!isValid(parsed) || formatDate(parsed, format) !== input) {
+            return null;
         }
 
-        return moment(input);
+        return parsed;
     }
 
     /**
      * AbstractDate.
      */
-    public constructor(public readonly format?: moment.MomentFormatSpecification) {
+    public constructor(public readonly format?: string) {
         super();
     }
 
     /**
      * Validate.
      */
     public validate(input: any): boolean {
-        const date: moment.Moment = AbstractDate.parse(input, this.format);
+        const date: Date | null = AbstractDate.parse(input, this.format);
 
-        return date.isValid() && this.validateDate(date);
+        return !!date && this.validateDate(date);
     }
 
     /**
      * Validate Date.
      */
-    protected abstract validateDate(date: moment.Moment): boolean;
+    protected abstract validateDate(date: Date): boolean;
 }

package-lock.json

@@ -1,6 +1,6 @@
 import { AbstractRule } from './abstract-rule';
 import { ArrayType } from './array-type';
-import { DateTime } from './date-time';
+import { DateFormat } from './date-format';
 import { NotOptional } from './not-optional';
 import { NumberVal } from './number-val';
 import { ObjectTypeStrict } from './object-type-strict';
@@ -43,8 +43,9 @@ export abstract class AbstractInterval extends AbstractRule {
             return input.size;
         }
 
-        if (new DateTime().validate(input)) {
-            return DateTime.parse(input).unix();
+        const date: Date | null = DateFormat.parse(input);
+        if (date) {
+            return date.getTime();
         }
 
         return String(input).length;

package.json

@@ -1,18 +1,18 @@
-import * as moment from 'moment';
+import { subYears } from 'date-fns';
 
 import { AbstractRule } from './abstract-rule';
 import { Between } from './between';
-import { DateTime } from './date-time';
+import { DateFormat } from './date-format';
 
 export class Age extends AbstractRule {
 
     /**
      * Age.
      */
     public constructor(
-        public readonly min: moment.DurationInputArg1 = 18,
-        public readonly max?: moment.DurationInputArg1,
-        public readonly format?: moment.MomentFormatSpecification
+        public readonly min: number = 18,
+        public readonly max?: number,
+        public readonly format?: string
     ) {
         super();
     }
@@ -21,11 +21,11 @@ export class Age extends AbstractRule {
      * Validate.
      */
     public validate(input: any): boolean {
-        const date: moment.Moment = DateTime.parse(input, this.format);
+        const date: Date | null = DateFormat.parse(input, this.format);
 
-        return date.isValid() && new Between(
-            this.max ? moment().subtract(this.max, 'years').hour(0).minute(0).second(0) : null,
-            this.min ? moment().subtract(this.min, 'years').hour(23).minute(59).second(59) : null
+        return !!date && new Between(
+            this.max ? subYears(new Date(), this.max).setHours(0, 0, 0) : null,
+            this.min ? subYears(new Date(), this.min).setHours(23, 59, 59) : null
         ).validate(date);
     }
 }

src/rules/abstract-date.ts

@@ -0,0 +1,13 @@
+import { AbstractDate } from './abstract-date';
+
+export class DateFormat extends AbstractDate {
+
+    /**
+     * Validate Date.
+     */
+    protected validateDate(date: Date): boolean {
+        return true;
+    }
+}
+
+export default DateFormat;

src/rules/abstract-interval.ts

@@ -34,7 +34,7 @@ export * from './credit-card';
 export * from './currency-code';
 export * from './currency';
 export * from './data-uri';
-export * from './date-time';
+export * from './date-format';
 export * from './decimal';
 export * from './digit';
 export * from './directory';

src/rules/age.ts

@@ -1,14 +1,12 @@
-import * as moment from 'moment';
-
 import { AbstractDate } from './abstract-date';
 
 export class LeapDate extends AbstractDate {
 
     /**
      * Validate Date.
      */
-    protected validateDate(date: moment.Moment): boolean {
-        return date.format('DD-MM') === '29-02';
+    protected validateDate(date: Date): boolean {
+        return date.getDate() === 29 && date.getMonth() === 1;
     }
 }
 

src/rules/date-format.ts

@@ -1,4 +1,4 @@
-import * as moment from 'moment';
+import { isLeapYear } from 'date-fns';
 
 import { AbstractDate } from './abstract-date';
 
@@ -7,8 +7,8 @@ export class LeapYear extends AbstractDate {
     /**
      * Validate Date.
      */
-    protected validateDate(date: moment.Moment): boolean {
-        return date.isLeapYear();
+    protected validateDate(date: Date): boolean {
+        return isLeapYear(date);
     }
 }
 

src/rules/date-time.ts

@@ -1,6 +1,5 @@
-import * as moment from 'moment';
-
 import { assert } from 'chai';
+import { format, subYears } from 'date-fns';
 
 import { AbstractRule } from '../../src/rules/abstract-rule';
 import { Age } from '../../src/rules/age';
@@ -13,23 +12,23 @@ describe('Age', () => {
 
     it('values is valid', () => {
         assert.isTrue(new Age().validate('1969-07-20'));
-        assert.isTrue(new Age(0).validate(moment()));
-        assert.isTrue(new Age(0, 0).validate(moment()));
+        assert.isTrue(new Age(0).validate(new Date()));
+        assert.isTrue(new Age(0, 0).validate(new Date()));
         assert.isTrue(new Age(18).validate('1969-07-20'));
-        assert.isTrue(new Age(undefined, 50).validate(moment().subtract(20, 'years')));
+        assert.isTrue(new Age(undefined, 50).validate(subYears(new Date(), 20)));
         assert.isTrue(new Age(undefined, undefined, 'DD/MM/YYYY').validate('20/07/1969'));
-        assert.isTrue(new Age(10, 50).validate(moment().subtract(20, 'years')));
-        assert.isTrue(new Age(10, 50, 'DD/MM/YYYY').validate(moment().subtract(20, 'years').format('DD/MM/YYYY')));
+        assert.isTrue(new Age(10, 50).validate(subYears(new Date(), 20)));
+        assert.isTrue(new Age(10, 50, 'DD/MM/YYYY').validate(format(subYears(new Date(), 20), 'DD/MM/YYYY')));
     });
 
     it('values is not valid', () => {
-        assert.isFalse(new Age().validate(moment()));
-        assert.isFalse(new Age(undefined, 0).validate(moment()));
-        assert.isFalse(new Age(10).validate(moment().subtract(5, 'years')));
-        assert.isFalse(new Age(undefined, 10).validate(moment().subtract(20, 'years')));
+        assert.isFalse(new Age().validate(new Date()));
+        assert.isFalse(new Age(undefined, 0).validate(new Date()));
+        assert.isFalse(new Age(10).validate(subYears(new Date(), 5)));
+        assert.isFalse(new Age(undefined, 10).validate(subYears(new Date(), 20)));
         assert.isFalse(new Age(undefined, undefined, 'DD/MM/YYYY').validate('1969-07-20'));
-        assert.isFalse(new Age(10, 50).validate(moment().subtract(5, 'years')));
-        assert.isFalse(new Age(30, 50, 'DD/MM/YYYY').validate(moment().subtract(20, 'years').format('DD/MM/YYYY')));
+        assert.isFalse(new Age(10, 50).validate(subYears(new Date(), 5)));
+        assert.isFalse(new Age(30, 50, 'DD/MM/YYYY').validate(format(subYears(new Date(), 20), 'DD/MM/YYYY')));
     });
 
 });