Merge pull request #186 from sebgroup/develop

New release: Removed moment

Author: yousifalraheem

README.md

@@ -6,7 +6,7 @@
 
 # **Frontend tools**
 
-A set of frontend utilities that can be used with any javascript application. It's lightweight and intuitive. The only dependency it has is for [momentjs](https://momentjs.com) when using any utility that deals with dates.
+A set of frontend utilities that can be used with any javascript application. It's lightweight and intuitive.
 
 ## **Installation**
 

package-lock.json

@@ -10,7 +10,8 @@
         "copy": "cp package.json dist/ && cp README.md dist/",
         "lint": "tslint -p tsconfig.json",
         "build": "npm run clean && npm run lint &&  npm run test && npm run build:production",
-        "test": "npm run clean:test && jest --forceExit --detectOpenHandles",
+        "pretest": "npm run clean:test",
+        "test": "cross-env NODE_ICU_DATA=node_modules/full-icu jest --forceExit --detectOpenHandles",
         "commit": "git-cz",
         "semantic-release": "semantic-release",
         "sanitize": "package-lock-sanitizer && git add package-lock.json"
@@ -38,22 +39,23 @@
     },
     "dependencies": {
         "@openapitools/openapi-generator-cli": "^1.0.12-4.3.0",
-        "commander": "^5.0.0",
-        "moment": "^2.24.0"
+        "commander": "^5.0.0"
     },
     "devDependencies": {
-        "@commitlint/cli": "^9.0.1",
-        "@commitlint/config-conventional": "^8.3.4",
+        "@commitlint/cli": "9.1.1",
+        "@commitlint/config-conventional": "^9.1.2",
         "@semantic-release/changelog": "^5.0.1",
         "@types/jest": "^26.0.0",
         "@types/node": "^14.0.1",
         "case-sensitive-paths-webpack-plugin": "^2.3.0",
         "commitizen": "^4.0.3",
         "copy-webpack-plugin": "^6.0.1",
+        "cross-env": "^7.0.2",
         "cz-conventional-changelog": "^3.0.2",
         "dargs": "^7.0.0",
         "fibers": "^5.0.0",
-        "husky": "^4.0.10",
+        "full-icu": "^1.3.1",
+        "husky": "^4.2.5",
         "jest": "^25.2.4",
         "jsdom": "^16.0.0",
         "jsdom-global": "^3.0.2",

package.json

@@ -1,10 +1,11 @@
-import moment, { Moment } from "moment";
 import { isEmpty } from "../isEmpty/isEmpty";
 import { isPhoneNumber } from "../isPhoneNumber/isPhoneNumber";
 import { isEmail } from "../isEmail/isEmail";
 import { deepCopy } from "../deepCopy/deepCopy";
-import { clearTime } from "../clearTime/clearTime";
 import { isStrongPassword } from "../isStrongPassword/isStrongPassword";
+import { isValidDate } from "../isValidDate";
+import { isDateBefore } from "../isDateBefore";
+import { isDateAfter } from "../isDateAfter";
 
 export type ValidationSpecs = {
     minLength?: number;
@@ -198,20 +199,22 @@ export class FormValidator<T> {
     private validateField(value: any, type: ValidationType, specs: ValidationSpecs): ModelFieldError {
         let fieldError: ModelFieldError = null;
         // Don't validate an empty field if it's not required
-        if (isEmpty(value) && type !== "required") {
+        const date: Date = new Date(value)
+        const empty: boolean = isEmpty(value);
+        if (empty && type !== "required") {
             return null;
         }
+        const valid: boolean = isValidDate(date);
         switch (type) {
-            case "required": return isEmpty(value) ? { errorCode: "empty" } : null;
-            case "isDate": return value instanceof Date ? null : { errorCode: "invalidDate" };
+            case "required": return empty ? { errorCode: "empty" } : null;
+            case "isDate": return valid ? null : { errorCode: "invalidDate" };
             case "dateRange":
-                const date: Moment = moment(value);
-                if (date.isValid()) {
+                if (valid) {
                     if (specs.minDate) {
-                        fieldError = moment(clearTime(date.toDate())).isBefore(clearTime(specs.minDate)) ? { errorCode: "beforeMinDate", specs: { minDate: specs.minDate } } : null;
+                        fieldError = isDateBefore(date, specs.minDate) ? { errorCode: "beforeMinDate", specs: { minDate: specs.minDate } } : null;
                     }
                     if (!fieldError && specs.maxDate) {
-                        fieldError = moment(clearTime(date.toDate())).isAfter(clearTime(specs.maxDate)) ? { errorCode: "afterMaxDate", specs: { maxDate: specs.maxDate } } : null;
+                        fieldError = isDateAfter(date, specs.maxDate) ? { errorCode: "afterMaxDate", specs: { maxDate: specs.maxDate } } : null;
                     }
                     return fieldError;
                 } else {

src/FormValidator/FormValidator.ts

@@ -1,5 +1,4 @@
 import { clearTime } from ".";
-import moment from "moment";
 
 interface TestCase {
     statement: string;
@@ -8,7 +7,7 @@ interface TestCase {
 }
 
 const getNewDateAtMidnight = (date?: string): Date => {
-    const newDate = date ? new Date(date) : new Date();
+    const newDate: Date = date ? new Date(date) : new Date();
     newDate.setHours(0, 0, 0, 0);
     return newDate;
 };

src/clearTime/clearTime.test.ts

@@ -4,25 +4,35 @@ interface DifferenceDatesTestCase {
     statement: string;
     date1: any;
     date2: any;
-    range: any;
+    range?: any;
     result?: number;
     isThrowError?: boolean;
+    isWarn?: boolean;
 }
 
 describe("Util: dateDiff", () => {
+    let consoleWarn: jasmine.Spy;
+    beforeEach(() => {
+        consoleWarn = spyOn(global.console, "warn");
+    })
     const testCases: Array<DifferenceDatesTestCase> = [
-        { statement: "Should throw error if firstDate is invalid", date1: "abcd", date2: new Date(), range: "m", isThrowError: true},
-        { statement: "Should throw error if secondDate is invalid", date1: new Date(), date2: "new Date()", range: "m", isThrowError: true},
-        { statement: "Should return 1", date1: new Date("2019-12-11"), date2: new Date("2019-11-11"), range: "Month", result: 1}
+        { statement: "Should throw error if firstDate is invalid", date1: "abcd", date2: new Date(), isThrowError: true},
+        { statement: "Should throw error if secondDate is invalid", date1: new Date(), date2: "new Date()", isThrowError: true},
+        { statement: "Should throw warning if deprecated argument was used", date1: new Date(), date2: new Date(), range: "year", isWarn: true, result: 0 },
+        { statement: "Should return 1", date1: new Date("2020-01-01"), date2: new Date("2020-01-02"), result: 1 },
+        { statement: "Should return 1", date1: new Date("2020-01-02"), date2: new Date("2020-01-01"), result: -1 }
     ];
     testCases.map((testCase: DifferenceDatesTestCase) => {
         test(`- ${testCase.statement} | params: ${JSON.stringify({date1: testCase.date1, date2: testCase.date2, range: testCase.range})}| result: ${testCase.result}`, () => {
             if (testCase.isThrowError) {
                 expect(() => {
-                    dateDiff(testCase.date1, testCase.date2, testCase.range);
+                    dateDiff(testCase.date1, testCase.date2);
                 }).toThrow();
             } else {
                 expect(dateDiff(testCase.date1, testCase.date2, testCase.range)).toEqual(testCase.result);
+                if (testCase.isWarn) {
+                    expect(consoleWarn).toHaveBeenCalledTimes(1);
+                }
             }
         });
     });

src/dateDiff/dateDiff.test.ts

@@ -1,15 +1,18 @@
-import moment from "moment";
+import { isValidDate } from "../isValidDate";
 
 /**
  * Compare and returns the dirrence between two dates
  * @param {Date} firstDate { date} the first date
  * @param {Date} secondDate { date } second date to compare against
- * @param {moment.DurationInputArg2} range {moment.DurationInputArg2} the range example , months , seconds, h, m, y etc
- * @returns {number} The difference based on the range type
+ * @param {any} range DEPRACATED (This argument is depracated)
+ * @returns {number} The difference in days
  */
-export function dateDiff(firstDate: Date, secondDate: Date, range: moment.DurationInputArg2): number {
-    if (!moment(firstDate).isValid() || !moment(secondDate).isValid()) {
-        throw new Error("from parameter must be of date type");
+export function dateDiff(firstDate: Date, secondDate: Date, range?: any): number {
+    if (range) {
+        console.warn("The range argument has been depracated. The range \"day\" will be used instead. \nTo compare units less than day use firstDate.getTime() - secondDate.getTime() to get milliseconds");
     }
-    return moment.utc(firstDate).diff(secondDate, range);
+    if (!isValidDate(firstDate) || !isValidDate(secondDate)) {
+        throw new Error("both parameters must be of type Date");
+    }
+    return Math.ceil((secondDate.getTime() - firstDate.getTime()) / 1000 / 60 / 60 / 24);
 }

src/dateDiff/dateDiff.ts

@@ -1,59 +1,59 @@
 import { formatDate } from ".";
-import { FormatDateOptions } from "./formatDate";
 
-interface FormatDateTestCase extends FormatDateOptions {
+interface FormatDateTestCase {
     title: string;
     date: string | Date;
-    outputFormat: string;
+    format?: Intl.DateTimeFormatOptions;
+    locale?: string;
     result: string;
 }
 
+const today: Date = new Date();
+
 describe("Util: formatDate", () => {
     const testCases: Array<FormatDateTestCase> = [
         {
-            title: "Should return formatted Date",
+            title: "Should format to Swedish by default",
             date: "7-12-1987",
-            inputFormat: "D-MM-YYYY",
-            outputFormat: "MM-DD-YYYY",
-            result: "12-07-1987"
+            result: "12 juli 1987",
         },
         {
-            title: "Should return null when date is invalid",
+            title: "Should use other locale when passed (en-US)",
+            date: "7-12-1987",
+            locale: "en-US",
+            result: "July 12, 1987",
+        },
+        {
+            title:
+                "Should return a string of the input if it's an invalid date",
             date: "it's a string",
-            inputFormat: "D-MM-YYYY",
-            outputFormat: "MM-DD-YYYY",
-            result: null
+            result: "it's a string",
         },
         {
-            title: "Should return null if date is invalid and invalid output is undefined",
-            date: null,
-            inputFormat: "D-MM-YYYY",
-            outputFormat: "MM-DD-YYYY",
-            result: null
+            title:
+                "Should correctly format ISO string date without passing input or output formats",
+            date: "2000-01-23T04:56:07.000+00:00",
+            result: "23 januari 2000",
         },
         {
-            title: "Should return formatted Date based on locale",
-            date: new Date("12-7-1987"),
-            inputFormat: "D-MM-YYYY",
-            outputFormat: "YYYY MMM DD",
-            locale: "sv-SE",
-            result: "1987 dec 07"
+            title: "Should accept date object",
+            date: new Date(),
+            format: { day: "numeric", month: "numeric", year: "numeric" },
+            result: today.toLocaleDateString("sv-SE"),
         },
         {
-            title: "Should correctly format ISO string date without passing input or output formats",
-            date: "2000-01-23T04:56:07.000+00:00",
-            outputFormat: "DD-MM-YYYY",
-            result: "23-01-2000"
-        }
+            title: "Should accept custom format",
+            date: new Date(),
+            format: { day: "numeric", month: "numeric" },
+            result: `${today.getDate()}/${today.getMonth() + 1}`,
+        },
     ];
-    testCases.map((testCase: FormatDateTestCase) => {
-        it(testCase.title, () => {
-            expect(formatDate(testCase.date, testCase.outputFormat, { ...testCase })).toEqual(testCase.result);
-        });
-    });
-
-    it("Should correctly format ISO string date without passing input formats", () => {
-        const formatted: string = formatDate("2000-01-23T04:56:07.000+00:00", "DD-MM-YYYY");
-        expect(formatted).toEqual("23-01-2000");
-    });
+    testCases.map(
+        ({ title, date, format, locale, result }: FormatDateTestCase) => {
+            // prettier-ignore
+            it(`${title} (Sample: ${String(date)} - Returns: ${result})`, () => {
+                expect(formatDate(date, format, locale)).toEqual(result);
+            });
+        }
+    );
 });

src/formatDate/formatDate.test.ts

@@ -1,30 +1,22 @@
-import moment, { Moment, MomentFormatSpecification, LocaleSpecifier } from "moment";
-
-export interface FormatDateOptions {
-    inputFormat?: MomentFormatSpecification;
-    locale?: LocaleSpecifier;
-}
-
 /**
- * Reformats any date string to any desired format
- * @param date The date string
- * @param outputFormat The desired output format
- * @param options input format and locale
- * @implements momentjs - refer to momentjs documentation to see the different formats supported
- * @note
- * Having an input format is critial to insure accuracy if you are not dealing with ISO date string.
- * Passing `01-10-2019` might be interpreted as `Jan 10` or `Oct 01` based on locale
- * @returns The formatted date string
+ * Date formatter
+ * @param date The date object or date string
+ * @param format The output format
+ * @param locale The locale. Default is `sv-SE`
+ * @returns The formattted date or the input if it fails to parse it
  */
-export function formatDate(date: string | Date, outputFormat: string, options?: FormatDateOptions): string {
-    if (date) {
-        let momentDate: Moment = moment(date, options?.inputFormat || null);
-        if (momentDate.isValid()) {
-            if (options?.locale) {
-                momentDate = momentDate.locale(options.locale);
-            }
-            return momentDate.format(outputFormat).toString();
-        }
+export function formatDate(
+    date: string | Date,
+    format: Intl.DateTimeFormatOptions = {
+        day: "numeric",
+        month: "long",
+        year: "numeric",
+    },
+    locale: string = "sv-SE"
+): string {
+    const parsedDate: number = Date.parse(date as any);
+    if (isNaN(parsedDate)) {
+        return String(date);
     }
-    return null;
+    return Intl.DateTimeFormat(locale, format).format(new Date(parsedDate));
 }

src/formatDate/formatDate.ts

@@ -1,5 +1,4 @@
-import moment from "moment";
-import { clearTime } from "../clearTime/clearTime";
+import { isValidDate } from "../isValidDate";
 
 /**
  * Compare two dates and return true if the first is greater than the second ignoring the time
@@ -8,5 +7,9 @@ import { clearTime } from "../clearTime/clearTime";
  * @returns {boolean} True if date `a` comes after than date `b`
  */
 export function isDateAfter(a: Date, b: Date): boolean {
-    return moment(clearTime(a)).isAfter(moment(clearTime(b)));
+    if (!isValidDate(a) || !isValidDate(b)) {
+        return a > b;
+    } else {
+        return a.getFullYear() > b.getFullYear() || a.getMonth() > b.getMonth() || a.getDate() > b.getDate();
+    }
 }