card-validator 10.0.1 → 10.0.3

package/dist/postal-code.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.postalCode = void 0;
-var DEFAULT_MIN_POSTAL_CODE_LENGTH = 3;
+var DEFAULT_MIN_POSTAL_CODE_LENGTH = 2;
 var ALPHANUM = new RegExp(/^[a-z0-9]+$/i);
 function verification(isValid, isPotentiallyValid) {
     return { isValid: isValid, isPotentiallyValid: isPotentiallyValid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "card-validator",
-  "version": "10.0.1",
+  "version": "10.0.3",
   "description": "A library for validating credit card fields",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,7 +33,7 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "credit-card-type": "^10.0.1"
+    "credit-card-type": "^10.0.2"
   },
   "jest": {
     "testEnvironment": "jsdom",

package/src/__tests__/expiration-year.ts

@@ -1,252 +1,163 @@
 import { expirationYear, ExpirationYearVerification } from "../expiration-year";
 
-const currentYear = new Date().getFullYear();
+const INVALID: ExpirationYearVerification = {
+  isValid: false,
+  isPotentiallyValid: false,
+  isCurrentYear: false,
+};
 
-function yearsFromNow(fromNow: number, digits?: number): string {
-  let result = String(currentYear + fromNow);
+const POTENTIALLY_VALID: ExpirationYearVerification = {
+  isValid: false,
+  isPotentiallyValid: true,
+  isCurrentYear: false,
+};
 
-  if (digits === 2) {
-    result = result.substr(2, 2);
-  }
+const VALID: ExpirationYearVerification = {
+  isValid: true,
+  isPotentiallyValid: true,
+  isCurrentYear: false,
+};
 
-  return result;
-}
+const CURRENT_YEAR: ExpirationYearVerification = {
+  isValid: true,
+  isPotentiallyValid: true,
+  isCurrentYear: true,
+};
 
 describe("expirationYear", () => {
-  const FALSE_VALIDATION = {
-    isValid: false,
-    isPotentiallyValid: false,
-    isCurrentYear: false,
-  };
-
-  describe.each([
-    [
-      "returns false if not a string",
-      [
-        [[], FALSE_VALIDATION],
-        [{}, FALSE_VALIDATION],
-        [null, FALSE_VALIDATION],
-        [undefined, FALSE_VALIDATION], // eslint-disable-line no-undefined
-        [Infinity, FALSE_VALIDATION],
-        [0 / 0, FALSE_VALIDATION],
-        [0, FALSE_VALIDATION],
-        [1, FALSE_VALIDATION],
-        [2, FALSE_VALIDATION],
-        [12, FALSE_VALIDATION],
-        [-1, FALSE_VALIDATION],
-        [-12, FALSE_VALIDATION],
-      ],
-    ],
-
-    [
-      "returns false for malformed strings",
-      [
-        ["foo", FALSE_VALIDATION],
-        ["1.2", FALSE_VALIDATION],
-        ["1/20", FALSE_VALIDATION],
-        ["1 2", FALSE_VALIDATION],
-        ["1 ", FALSE_VALIDATION],
-        [" 1", FALSE_VALIDATION],
-        ["20015", FALSE_VALIDATION],
-      ],
-    ],
-
-    [
-      "returns the appropriate values for incomplete strings",
-      [
-        [
-          "",
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          "2",
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          "9",
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          "200",
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          "123",
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          "20",
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-      ],
-    ],
-
-    [
-      "accepts four-digit years",
-      [
-        [
-          yearsFromNow(0),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: true },
-        ],
-        [
-          yearsFromNow(-5),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(5),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(10),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(11),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(12),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(19),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(20),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(25),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(33),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-      ],
-    ],
-
-    [
-      "accepts two-digit years",
-      [
-        [
-          yearsFromNow(0, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: true },
-        ],
-        [
-          yearsFromNow(-5, 2),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(5, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(10, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(11, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(12, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(19, 2),
-          { isValid: true, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(20, 2),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(25, 2),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(33, 2),
-          { isValid: false, isPotentiallyValid: false, isCurrentYear: false },
-        ],
-      ],
-    ],
-
-    /*
-     *  This doesn't take 20xx -> 21xx into account, but probably YAGNI
-     *  (with apologies to whoever is possibly looking at this legacy
-     *  code long after we're dead
-     *  */
-    [
-      "accepts three-digit years",
-      [
-        [
-          yearsFromNow(-3).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(-1).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(0).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(1).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(5).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(11).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(17).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-        [
-          yearsFromNow(23).slice(0, 3),
-          { isValid: false, isPotentiallyValid: true, isCurrentYear: false },
-        ],
-      ],
-    ],
-  ] as Array<[string, Array<[unknown, ExpirationYearVerification]>]>)(
-    "%s",
-    (description, tests) => {
-      it.each(tests)("parses %s to be %p", (exp, meta) => {
-        expect(expirationYear(exp)).toEqual(meta);
+  // Date picked at random from the past 5 years
+  const mockToday = new Date(2021, 5, 9);
+  jest.useFakeTimers().setSystemTime(mockToday);
+
+  describe("given a non-string value", () => {
+    test.each([
+      [[], INVALID],
+      [{}, INVALID],
+      [null, INVALID],
+      [undefined, INVALID], // eslint-disable-line no-undefined
+      [Infinity, INVALID],
+      [0 / 0, INVALID],
+      [0, INVALID],
+      [1, INVALID],
+      [2, INVALID],
+      [12, INVALID],
+      [-1, INVALID],
+      [-12, INVALID],
+    ])("%p is invalid", (value, output) => {
+      expect(expirationYear(value)).toEqual(output);
+    });
+  });
+
+  describe("given an empty string", () => {
+    it("returns as potentially valid", () => {
+      expect(expirationYear("")).toEqual(POTENTIALLY_VALID);
+    });
+  });
+
+  describe("given only whitespace", () => {
+    it("returns as potentially valid", () => {
+      expect(expirationYear("    ")).toEqual(POTENTIALLY_VALID);
+    });
+  });
+
+  describe("given a malformed string value", () => {
+    test.each([
+      ["foo", INVALID],
+      ["1.2", INVALID],
+      ["1/20", INVALID],
+      ["1 2", INVALID],
+      ["1 ", INVALID],
+      [" 1", INVALID],
+      ["20015", INVALID],
+    ])("%p is invalid", (value, output) => {
+      expect(expirationYear(value)).toEqual(output);
+    });
+  });
+
+  describe("given a 1 digit string", () => {
+    describe("that's not a number", () => {
+      test.each(["a", "#", ";", "\\", "+"])("%p is invalid", (value) => {
+        expect(expirationYear(value)).toEqual(INVALID);
       });
-    },
-  );
-
-  it("defaults maxElapsedYear is 19", () => {
-    expect(expirationYear(yearsFromNow(19))).toEqual({
-      isValid: true,
-      isPotentiallyValid: true,
-      isCurrentYear: false,
     });
-    expect(expirationYear(yearsFromNow(20))).toEqual({
-      isValid: false,
-      isPotentiallyValid: false,
-      isCurrentYear: false,
+
+    describe("that is a number", () => {
+      test.each(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"])(
+        "%p is potentially valid",
+        (value) => {
+          expect(expirationYear(value)).toEqual(POTENTIALLY_VALID);
+        },
+      );
+    });
+  });
+
+  describe("given a 2 digit string", () => {
+    test.each([
+      ["19", INVALID],
+      ["20", POTENTIALLY_VALID],
+      ["21", CURRENT_YEAR],
+      ["22", VALID],
+      ["40", VALID],
+      ["41", INVALID],
+    ])("%p gives expected output", (value, output) => {
+      expect(expirationYear(value)).toEqual(output);
+    });
+  });
+
+  describe("given a 3 digit string", () => {
+    test.each([
+      ["000", INVALID],
+      ["123", INVALID],
+      ["200", POTENTIALLY_VALID],
+      ["201", POTENTIALLY_VALID],
+      ["202", POTENTIALLY_VALID],
+      ["203", POTENTIALLY_VALID],
+      ["204", POTENTIALLY_VALID],
+      ["205", POTENTIALLY_VALID],
+      ["206", POTENTIALLY_VALID],
+      ["207", POTENTIALLY_VALID],
+      ["208", POTENTIALLY_VALID],
+      ["209", POTENTIALLY_VALID],
+      ["210", INVALID],
+      ["300", INVALID],
+      ["999", INVALID],
+    ])("%p gives expected output", (value, output) => {
+      expect(expirationYear(value)).toEqual(output);
     });
   });
 
-  it("accepts maxElapsedYear", () => {
-    expect(expirationYear(yearsFromNow(20), 20)).toEqual({
-      isValid: true,
-      isPotentiallyValid: true,
-      isCurrentYear: false,
+  describe("given a 4 digit string", () => {
+    test.each([
+      ["0000", INVALID],
+      ["1234", INVALID],
+      ["2020", INVALID],
+      ["2021", CURRENT_YEAR],
+      ["2022", VALID],
+      ["2040", VALID],
+      ["2041", INVALID],
+      ["3000", INVALID],
+      ["9999", INVALID],
+    ])("%p gives expected output", (value, output) => {
+      expect(expirationYear(value)).toEqual(output);
     });
-    expect(expirationYear(yearsFromNow(21), 20)).toEqual({
-      isValid: false,
-      isPotentiallyValid: false,
-      isCurrentYear: false,
+  });
+
+  describe("given a more than 4 digit string", () => {
+    test.each(["00000", "12345", "20021", "20202", "20211", "30000", "99999"])(
+      "%p is invalid",
+      (value) => {
+        expect(expirationYear(value)).toEqual(INVALID);
+      },
+    );
+  });
+
+  describe("given a custom max elapsed year", () => {
+    it("uses it correctly", () => {
+      expect(expirationYear("2020", 5)).toEqual(INVALID);
+      expect(expirationYear("2021", 5)).toEqual(CURRENT_YEAR);
+      expect(expirationYear("2022", 5)).toEqual(VALID);
+      expect(expirationYear("2026", 5)).toEqual(VALID);
+      expect(expirationYear("2027", 5)).toEqual(INVALID);
     });
   });
 });

package/src/__tests__/postal-code.ts

@@ -32,6 +32,8 @@ describe("postalCode", () => {
         ["557016", { isValid: true, isPotentiallyValid: true }], // Romania
         ["110001", { isValid: true, isPotentiallyValid: true }], // India
         ["SE1 2LN", { isValid: true, isPotentiallyValid: true }], // UK
+        ["S9 1DF", { isValid: true, isPotentiallyValid: true }], // UK
+        ["AA9A 9AA", { isValid: true, isPotentiallyValid: true }], // UK
         ["01234567890123456789", { isValid: true, isPotentiallyValid: true }], // some hypothetical country
       ],
     ],
@@ -52,11 +54,11 @@ describe("postalCode", () => {
     ],
 
     [
-      "returns isPotentiallyValid for shorter-than-3 strings",
+      "returns isPotentiallyValid for shorter-than-2 strings",
       [
         ["", { isValid: false, isPotentiallyValid: true }],
         ["1", { isValid: false, isPotentiallyValid: true }],
-        ["12", { isValid: false, isPotentiallyValid: true }],
+        ["12", { isValid: true, isPotentiallyValid: true }],
       ],
     ],
   ] as Array<[string, Array<[string, Verification]>]>)(
@@ -79,10 +81,18 @@ describe("postalCode", () => {
         isPotentiallyValid: true,
       });
       expect(postalCode("12")).toEqual({
-        isValid: false,
+        isValid: true,
         isPotentiallyValid: true,
       });
       expect(postalCode("12", {})).toEqual({
+        isValid: true,
+        isPotentiallyValid: true,
+      });
+      expect(postalCode("1")).toEqual({
+        isValid: false,
+        isPotentiallyValid: true,
+      });
+      expect(postalCode("1", {})).toEqual({
         isValid: false,
         isPotentiallyValid: true,
       });

package/src/postal-code.ts

@@ -4,7 +4,7 @@ type PostalCodeOptions = {
   minLength?: number;
 };
 
-const DEFAULT_MIN_POSTAL_CODE_LENGTH = 3;
+const DEFAULT_MIN_POSTAL_CODE_LENGTH = 2;
 const ALPHANUM = new RegExp(/^[a-z0-9]+$/i);
 
 function verification(