@dwp/govuk-casa 9.0.0 → 9.1.0

package/src/lib/validators/nino.js

@@ -1,24 +1,24 @@
 /* eslint-disable class-methods-use-this */
-import ValidationError from '../ValidationError.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import { stringifyInput } from '../utils.js';
+import ValidationError from "../ValidationError.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import { stringifyInput } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} NinoConfigOptions
  * @property {ErrorMessageConfig} errorMsg Error message config
- * @property {boolean} allowWhitespace Will permit input values that contain spaces.
+ * @property {boolean} allowWhitespace Will permit input values that contain
+ *   spaces.
  */
 
 /**
  * UK National Insurance number.
  *
- * Ref:
- * https://en.wikipedia.org/wiki/National_Insurance_number#Format
+ * Ref: https://en.wikipedia.org/wiki/National_Insurance_number#Format
  * https://design-system.service.gov.uk/patterns/national-insurance-numbers/
  *
  * See {@link NinoConfigOptions} for `make()` options.
@@ -27,23 +27,37 @@ import { stringifyInput } from '../utils.js';
  * @augments ValidatorFactory
  */
 export default class Nino extends ValidatorFactory {
-  name = 'nino';
+  name = "nino";
 
   validate(value, dataContext = {}) {
     const {
       allowWhitespace,
       errorMsg = {
-        inline: 'validation:rule.nino.inline',
-        summary: 'validation:rule.nino.summary',
+        inline: "validation:rule.nino.inline",
+        summary: "validation:rule.nino.summary",
       },
     } = this.config;
 
-    if (typeof allowWhitespace !== 'undefined' && typeof allowWhitespace !== 'boolean') {
-      throw new TypeError(`NINO validation rule option "allowWhitespace" must been a boolean. received ${typeof allowWhitespace}`);
+    if (
+      typeof allowWhitespace !== "undefined" &&
+      typeof allowWhitespace !== "boolean"
+    ) {
+      throw new TypeError(
+        `NINO validation rule option "allowWhitespace" must been a boolean. received ${typeof allowWhitespace}`,
+      );
     }
-    const valid = typeof value === 'string'
-      && value.replace((typeof allowWhitespace !== 'undefined' && allowWhitespace) ? /\u0020/g : '', '')
-        .match(/^(?!BG|GB|NK|KN|TN|NT|ZZ)[ABCEGHJ-PRSTW-Z][ABCEGHJ-NPRSTW-Z]\d{6}[A-D]$/i);
+    const valid =
+      typeof value === "string" &&
+      value
+        .replace(
+          typeof allowWhitespace !== "undefined" && allowWhitespace
+            ? /\u0020/g
+            : "",
+          "",
+        )
+        .match(
+          /^(?!BG|GB|NK|KN|TN|NT|ZZ)[ABCEGHJ-PRSTW-Z][ABCEGHJ-NPRSTW-Z]\d{6}[A-D]$/i,
+        );
 
     return valid ? [] : [ValidationError.make({ errorMsg, dataContext })];
   }

package/src/lib/validators/postalAddressObject.js

@@ -1,32 +1,38 @@
 /* eslint-disable class-methods-use-this */
-import lodash from 'lodash';
-import ValidationError from '../ValidationError.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import { stringifyInput } from '../utils.js';
+import lodash from "lodash";
+import ValidationError from "../ValidationError.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import { stringifyInput } from "../utils.js";
 
 const { isPlainObject } = lodash; // CommonjS
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} PostalAddressObjectConfigOptions
- * @property {ErrorMessageConfig} [errorMsg] General error message for the entire address block
- * @property {string|object} [errorMsgAddress1] Error message for address1 part
- * @property {string|object} [errorMsgAddress2] Error message for address2 part
- * @property {string|object} [errorMsgAddress3] Error message for address3 part
- * @property {string|object} [errorMsgAddress4] Error message for address4 part
- * @property {string|object} [errorMsgPostcode] Error message for postcode part
- * @property {number} [strlenmax] Max. String length for each of the inputs address[1-4]
- * @property {string[]} [requiredFields] Field parts required (others become optional). One of
- * 'address1'|'address2'|'address3'|'address4'|'postcode'
+ * @property {ErrorMessageConfig} [errorMsg] General error message for the
+ *   entire address block
+ * @property {string | object} [errorMsgAddress1] Error message for address1
+ *   part
+ * @property {string | object} [errorMsgAddress2] Error message for address2
+ *   part
+ * @property {string | object} [errorMsgAddress3] Error message for address3
+ *   part
+ * @property {string | object} [errorMsgAddress4] Error message for address4
+ *   part
+ * @property {string | object} [errorMsgPostcode] Error message for postcode
+ *   part
+ * @property {number} [strlenmax] Max. String length for each of the inputs
+ *   address[1-4]
+ * @property {string[]} [requiredFields] Field parts required (others become
+ *   optional). One of 'address1'|'address2'|'address3'|'address4'|'postcode'
  */
 
 /**
- * Works hand in hand with the core CASA `postalAddressObject` form
- * macro.
+ * Works hand in hand with the core CASA `postalAddressObject` form macro.
  *
  * The errors sent back from this validator are specific to each subfield. For
  * example, if the field name being tested is "address", any errors related to
@@ -38,73 +44,84 @@ const { isPlainObject } = lodash; // CommonjS
  * @augments ValidatorFactory
  */
 export default class PostalAddressObject extends ValidatorFactory {
-  name = 'postalAddressObject';
+  name = "postalAddressObject";
 
   validate(value, dataContext = {}) {
     const cfg = {
-      requiredFields: ['address1', 'address3', 'postcode'],
+      requiredFields: ["address1", "address3", "postcode"],
       strlenmax: undefined,
       errorMsgAddress1: {
-        inline: 'validation:rule.postalAddressObject.address1.inline',
-        summary: 'validation:rule.postalAddressObject.address1.summary',
-        focusSuffix: '[address1]',
+        inline: "validation:rule.postalAddressObject.address1.inline",
+        summary: "validation:rule.postalAddressObject.address1.summary",
+        focusSuffix: "[address1]",
       },
       errorMsgAddress2: {
-        inline: 'validation:rule.postalAddressObject.address2.inline',
-        summary: 'validation:rule.postalAddressObject.address2.summary',
-        focusSuffix: '[address2]',
+        inline: "validation:rule.postalAddressObject.address2.inline",
+        summary: "validation:rule.postalAddressObject.address2.summary",
+        focusSuffix: "[address2]",
       },
       errorMsgAddress3: {
-        inline: 'validation:rule.postalAddressObject.address3.inline',
-        summary: 'validation:rule.postalAddressObject.address3.summary',
-        focusSuffix: '[address3]',
+        inline: "validation:rule.postalAddressObject.address3.inline",
+        summary: "validation:rule.postalAddressObject.address3.summary",
+        focusSuffix: "[address3]",
       },
       errorMsgAddress4: {
-        inline: 'validation:rule.postalAddressObject.address4.inline',
-        summary: 'validation:rule.postalAddressObject.address4.summary',
-        focusSuffix: '[address4]',
+        inline: "validation:rule.postalAddressObject.address4.inline",
+        summary: "validation:rule.postalAddressObject.address4.summary",
+        focusSuffix: "[address4]",
       },
       errorMsgPostcode: {
-        inline: 'validation:rule.postalAddressObject.postcode.inline',
-        summary: 'validation:rule.postalAddressObject.postcode.summary',
-        focusSuffix: '[postcode]',
+        inline: "validation:rule.postalAddressObject.postcode.inline",
+        summary: "validation:rule.postalAddressObject.postcode.summary",
+        focusSuffix: "[postcode]",
       },
       errorMsg: {
-        inline: 'validation:rule.postalAddressObject.group.inline',
-        summary: 'validation:rule.postalAddressObject.group.summary',
-        focusSuffix: '[address1]',
+        inline: "validation:rule.postalAddressObject.group.inline",
+        summary: "validation:rule.postalAddressObject.group.summary",
+        focusSuffix: "[address1]",
       },
       ...this.config,
     };
 
     /* eslint-disable-next-line require-jsdoc */
-    const objectifyError = (err) => (typeof err === 'string' ? {
-      inline: err,
-      summary: err,
-    } : err);
+    const objectifyError = (err) =>
+      typeof err === "string"
+        ? {
+            inline: err,
+            summary: err,
+          }
+        : err;
 
     // Work out required/optional parts based on config
     const reqF = Object.create(null);
     const reqC = cfg.requiredFields;
-    ['address1', 'address2', 'address3', 'address4', 'postcode'].forEach((k) => {
-      // ESLint disabled as `k` is a known value from a constant list
-      /* eslint-disable-next-line security/detect-object-injection */
-      reqF[k] = reqC.indexOf(k) > -1;
-    });
+    ["address1", "address2", "address3", "address4", "postcode"].forEach(
+      (k) => {
+        // ESLint disabled as `k` is a known value from a constant list
+        /* eslint-disable-next-line security/detect-object-injection */
+        reqF[k] = reqC.indexOf(k) > -1;
+      },
+    );
 
     let valid = true;
     const errorMsgs = [];
 
-    if (typeof value === 'object') {
+    if (typeof value === "object") {
       const reAddr = /^[^\s]+[a-z0-9\-,.&#()/\\:;'" ]+$/i;
       const reAddrLine1 = /^\d+|[^\s]+[a-z0-9\-,.&#()/\\:;'" ]+$/i;
       // UK Postcode regex taken from the dwp java pc checker
       // https://github.com/dwp/postcode-format-validation
-      const rePostcode = /^(?![QVX])[A-Z]((?![IJZ])[A-Z][0-9](([0-9]?)|([ABEHMNPRVWXY]?))|([0-9]([0-9]?|[ABCDEFGHJKPSTUW]?))) ?[0-9]((?![CIKMOV])[A-Z]){2}$|^(BFPO)[ ]?[0-9]{1,4}$/i;
+      const rePostcode =
+        /^(?![QVX])[A-Z]((?![IJZ])[A-Z][0-9](([0-9]?)|([ABEHMNPRVWXY]?))|([0-9]([0-9]?|[ABCDEFGHJKPSTUW]?))) ?[0-9]((?![CIKMOV])[A-Z]){2}$|^(BFPO)[ ]?[0-9]{1,4}$/i;
 
       // [required, regex, strlenmax, error message]
       const attributes = {
-        address1: [reqF.address1, reAddrLine1, cfg.strlenmax, cfg.errorMsgAddress1],
+        address1: [
+          reqF.address1,
+          reAddrLine1,
+          cfg.strlenmax,
+          cfg.errorMsgAddress1,
+        ],
         address2: [reqF.address2, reAddr, cfg.strlenmax, cfg.errorMsgAddress2],
         address3: [reqF.address3, reAddr, cfg.strlenmax, cfg.errorMsgAddress3],
         address4: [reqF.address4, reAddr, cfg.strlenmax, cfg.errorMsgAddress4],
@@ -117,16 +134,18 @@ export default class PostalAddressObject extends ValidatorFactory {
         const hasProperty = Object.prototype.hasOwnProperty.call(value, k);
         const hasContent = hasProperty && value[k].length > 0;
 
-        const condMissingOrRegexMismatch = (attr[0] || hasContent)
-          && (!hasProperty || !value[k].match(attr[1]));
-        const condExceedStrlen = attr[2] > 0 && hasContent
-          && String(value[k]).length > attr[2];
+        const condMissingOrRegexMismatch =
+          (attr[0] || hasContent) && (!hasProperty || !value[k].match(attr[1]));
+        const condExceedStrlen =
+          attr[2] > 0 && hasContent && String(value[k]).length > attr[2];
 
         if (condMissingOrRegexMismatch || condExceedStrlen) {
           valid = false;
-          errorMsgs.push(Object.assign(Object.create(null), objectifyError(attr[3]), {
-            fieldKeySuffix: `[${k}]`,
-          }));
+          errorMsgs.push(
+            Object.assign(Object.create(null), objectifyError(attr[3]), {
+              fieldKeySuffix: `[${k}]`,
+            }),
+          );
         }
       });
       /* eslint-enable security/detect-object-injection */
@@ -136,8 +155,9 @@ export default class PostalAddressObject extends ValidatorFactory {
     }
 
     // Build ValidationErrorGroup
-    const errorGroup = errorMsgs.map((err) => (
-      ValidationError.make({ errorMsg: err, dataContext })));
+    const errorGroup = errorMsgs.map((err) =>
+      ValidationError.make({ errorMsg: err, dataContext }),
+    );
 
     return valid ? [] : [...errorGroup];
   }
@@ -149,13 +169,17 @@ export default class PostalAddressObject extends ValidatorFactory {
     }
 
     // Prune unrecognised attributes, and coerce to Strings
-    const validKeys = ['address1', 'address2', 'address3', 'address4', 'postcode'];
+    const validKeys = [
+      "address1",
+      "address2",
+      "address3",
+      "address4",
+      "postcode",
+    ];
     const pruned = Object.fromEntries(
-      Object.entries(value).filter(
-        ([k]) => (validKeys.includes(k)),
-      ).map(
-        ([k, v]) => ([k, stringifyInput(v)]),
-      ),
+      Object.entries(value)
+        .filter(([k]) => validKeys.includes(k))
+        .map(([k, v]) => [k, stringifyInput(v)]),
     );
     return Object.assign(Object.create(null), pruned);
   }

package/src/lib/validators/range.js

@@ -1,18 +1,20 @@
 /* eslint-disable class-methods-use-this */
 
-import ValidatorFactory from '../ValidatorFactory.js';
-import ValidationError from '../ValidationError.js';
-import { coerceInputToInteger } from '../utils.js';
+import ValidatorFactory from "../ValidatorFactory.js";
+import ValidationError from "../ValidationError.js";
+import { coerceInputToInteger } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} RangeConfigOptions
- * @property {ErrorMessageConfig} errorMsgMax Error message to use on max failure
- * @property {ErrorMessageConfig} errorMsgMin Error message to use on min failure
+ * @property {ErrorMessageConfig} errorMsgMax Error message to use on max
+ *   failure
+ * @property {ErrorMessageConfig} errorMsgMin Error message to use on min
+ *   failure
  * @property {number} max Maximum integer value
  * @property {number} min Minimum integer value
  */
@@ -26,17 +28,17 @@ import { coerceInputToInteger } from '../utils.js';
  * @augments ValidatorFactory
  */
 export default class Range extends ValidatorFactory {
-  name = 'range';
+  name = "range";
 
   validate(inputValue, dataContext = {}) {
     const {
       errorMsgMax = {
-        inline: 'validation:rule.range.max.inline',
-        summary: 'validation:rule.range.max.summary',
+        inline: "validation:rule.range.max.inline",
+        summary: "validation:rule.range.max.summary",
       },
       errorMsgMin = {
-        inline: 'validation:rule.range.min.inline',
-        summary: 'validation:rule.range.min.summary',
+        inline: "validation:rule.range.min.inline",
+        summary: "validation:rule.range.min.summary",
       },
       min = Number.MIN_VALUE,
       max = Number.MAX_VALUE,
@@ -61,7 +63,7 @@ export default class Range extends ValidatorFactory {
   sanitise(value) {
     // treat an empty string as undefined
     // when user submits empty form, it stores an empty string
-    if (value !== '' && value !== undefined) {
+    if (value !== "" && value !== undefined) {
       // add to custom validator docs to ensure not to return a falsy value as
       // it doesn't show on screen
       return coerceInputToInteger(value)?.toString();

package/src/lib/validators/regex.js

@@ -1,11 +1,11 @@
 /* eslint-disable class-methods-use-this */
-import ValidatorFactory from '../ValidatorFactory.js';
-import ValidationError from '../ValidationError.js';
-import { stringifyInput } from '../utils.js';
+import ValidatorFactory from "../ValidatorFactory.js";
+import ValidationError from "../ValidationError.js";
+import { stringifyInput } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
@@ -24,16 +24,16 @@ import { stringifyInput } from '../utils.js';
  * @augments ValidatorFactory
  */
 export default class Regex extends ValidatorFactory {
-  name = 'regex';
+  name = "regex";
 
-  validate(value = '', dataContext = {}) {
+  validate(value = "", dataContext = {}) {
     const invert = this.config.invert || false;
     const match = value.match(this.config.pattern || /.*/);
     const valid = invert ? !match : match;
 
     const errorMsg = this.config.errorMsg || {
-      inline: 'validation:rule.regex.inline',
-      summary: 'validation:rule.regex.summary',
+      inline: "validation:rule.regex.inline",
+      summary: "validation:rule.regex.summary",
     };
 
     return valid ? [] : [ValidationError.make({ errorMsg, dataContext })];

package/src/lib/validators/required.js

@@ -1,14 +1,14 @@
 /* eslint-disable class-methods-use-this */
-import lodash from 'lodash';
-import { isEmpty, isStringable, stringifyInput } from '../utils.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import ValidationError from '../ValidationError.js';
+import lodash from "lodash";
+import { isEmpty, isStringable, stringifyInput } from "../utils.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import ValidationError from "../ValidationError.js";
 
 const { isPlainObject } = lodash; // CommonJS
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
@@ -19,8 +19,8 @@ const { isPlainObject } = lodash; // CommonJS
 /**
  * Test if value is present.
  *
- * Value is required. The following values will fail this rule:
- *  (all values that satisfy `isEmpty()`) plus '\s'
+ * Value is required. The following values will fail this rule: (all values that
+ * satisfy `isEmpty()`) plus '\s'
  *
  * See {@link RequiredConfigOptions} for `make()` options.
  *
@@ -28,29 +28,27 @@ const { isPlainObject } = lodash; // CommonJS
  * @augments ValidatorFactory
  */
 export default class Required extends ValidatorFactory {
-  name = 'required';
+  name = "required";
 
   validate(value, dataContext = {}) {
     const {
       errorMsg = {
-        inline: 'validation:rule.required.inline',
-        summary: 'validation:rule.required.summary',
+        inline: "validation:rule.required.inline",
+        summary: "validation:rule.required.summary",
       },
     } = this.config;
 
     if (!isEmpty(value)) {
-      return []
+      return [];
     }
 
-    return [
-      ValidationError.make({ errorMsg, dataContext }),
-    ];
+    return [ValidationError.make({ errorMsg, dataContext })];
   }
 
   sanitise(value) {
     const coerce = (val) => {
       const s = stringifyInput(val, undefined);
-      return s === undefined ? undefined : s.replace(/^\s+$/, '');
+      return s === undefined ? undefined : s.replace(/^\s+$/, "");
     };
 
     if (isStringable(value)) {
@@ -66,7 +64,9 @@ export default class Required extends ValidatorFactory {
     // Coerce all elements to Strings.
     // This only supports a one dimensional object, with stringable elements.
     if (isPlainObject(value)) {
-      return Object.fromEntries(Object.entries(value).map(([k, v]) => ([k, coerce(v)])));
+      return Object.fromEntries(
+        Object.entries(value).map(([k, v]) => [k, coerce(v)]),
+      );
     }
 
     return undefined;

package/src/lib/validators/strlen.js

@@ -1,17 +1,19 @@
 /* eslint-disable class-methods-use-this */
-import ValidatorFactory from '../ValidatorFactory.js';
-import ValidationError from '../ValidationError.js';
-import { stringifyInput } from '../utils.js';
+import ValidatorFactory from "../ValidatorFactory.js";
+import ValidationError from "../ValidationError.js";
+import { stringifyInput } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} StrlenConfigOptions
- * @property {ErrorMessageConfig} errorMsgMax Error message to use on max length failure
- * @property {ErrorMessageConfig} errorMsgMin Error message to use on min length failure
+ * @property {ErrorMessageConfig} errorMsgMax Error message to use on max length
+ *   failure
+ * @property {ErrorMessageConfig} errorMsgMin Error message to use on min length
+ *   failure
  * @property {number} max Maximum string length allowed
  * @property {number} min Minimum string length required
  */
@@ -25,17 +27,17 @@ import { stringifyInput } from '../utils.js';
  * @augments ValidatorFactory
  */
 export default class Strlen extends ValidatorFactory {
-  name = 'strlen';
+  name = "strlen";
 
-  validate(inputValue = '', dataContext = {}) {
+  validate(inputValue = "", dataContext = {}) {
     const {
       errorMsgMax = {
-        inline: 'validation:rule.strlen.max.inline',
-        summary: 'validation:rule.strlen.max.summary',
+        inline: "validation:rule.strlen.max.inline",
+        summary: "validation:rule.strlen.max.summary",
       },
       errorMsgMin = {
-        inline: 'validation:rule.strlen.min.inline',
-        summary: 'validation:rule.strlen.min.summary',
+        inline: "validation:rule.strlen.min.inline",
+        summary: "validation:rule.strlen.min.summary",
       },
       min,
       max,
@@ -44,12 +46,12 @@ export default class Strlen extends ValidatorFactory {
     let errorMsg;
     let valid = true;
 
-    if (typeof max !== 'undefined' && inputValue.length > max) {
+    if (typeof max !== "undefined" && inputValue.length > max) {
       valid = false;
       errorMsg = errorMsgMax;
     }
 
-    if (typeof min !== 'undefined' && inputValue.length < min) {
+    if (typeof min !== "undefined" && inputValue.length < min) {
       valid = false;
       errorMsg = errorMsgMin;
     }

package/src/lib/validators/wordCount.js

@@ -1,17 +1,19 @@
 /* eslint-disable class-methods-use-this */
-import ValidatorFactory from '../ValidatorFactory.js';
-import ValidationError from '../ValidationError.js';
-import { stringifyInput } from '../utils.js';
+import ValidatorFactory from "../ValidatorFactory.js";
+import ValidationError from "../ValidationError.js";
+import { stringifyInput } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} WordcountConfigOptions
- * @property {ErrorMessageConfig} errorMsgMax Error message to use on max length failure
- * @property {ErrorMessageConfig} errorMsgMin Error message to use on min length failure
+ * @property {ErrorMessageConfig} errorMsgMax Error message to use on max length
+ *   failure
+ * @property {ErrorMessageConfig} errorMsgMin Error message to use on min length
+ *   failure
  * @property {number} max Maximum string length allowed
  * @property {number} min Minimum string length required
  */
@@ -25,21 +27,21 @@ import { stringifyInput } from '../utils.js';
  * @augments ValidatorFactory
  */
 export default class WordCount extends ValidatorFactory {
-  name = 'wordCount';
+  name = "wordCount";
 
   count(input) {
     return (input.match(/\S+/g) || []).length;
   }
 
-  validate(inputValue = '', dataContext = {}) {
+  validate(inputValue = "", dataContext = {}) {
     const {
       errorMsgMax = {
-        inline: 'validation:rule.wordCount.max.inline',
-        summary: 'validation:rule.wordCount.max.summary',
+        inline: "validation:rule.wordCount.max.inline",
+        summary: "validation:rule.wordCount.max.summary",
       },
       errorMsgMin = {
-        inline: 'validation:rule.wordCount.min.inline',
-        summary: 'validation:rule.wordCount.min.summary',
+        inline: "validation:rule.wordCount.min.inline",
+        summary: "validation:rule.wordCount.min.summary",
       },
       min,
       max,
@@ -48,12 +50,18 @@ export default class WordCount extends ValidatorFactory {
     let errorMsg;
     let valid = true;
 
-    if (typeof max !== 'undefined' && (inputValue.match(/\S+/g) || []).length > max) {
+    if (
+      typeof max !== "undefined" &&
+      (inputValue.match(/\S+/g) || []).length > max
+    ) {
       valid = false;
       errorMsg = errorMsgMax;
     }
 
-    if (typeof min !== 'undefined' && (inputValue.match(/\S+/g) || []).length < min) {
+    if (
+      typeof min !== "undefined" &&
+      (inputValue.match(/\S+/g) || []).length < min
+    ) {
       valid = false;
       errorMsg = errorMsgMin;
     }