@dwp/govuk-casa 9.0.0 → 9.1.0

package/src/lib/utils.js

@@ -1,24 +1,24 @@
 /**
+ * @typedef {import("../casa").GlobalHook | import("../casa").PageHook} Hook
  * @access private
- * @typedef {import('../casa').GlobalHook | import('../casa').PageHook} Hook
  */
 
 /**
  * Determine if value is empty. Recurse over objects.
  *
- * @access private
- * @param  {any} val Value to check
+ * @param {any} val Value to check
  * @returns {boolean} True if the object is empty
+ * @access private
  */
 export function isEmpty(val) {
   if (
-    val === null
-    || typeof val === 'undefined'
-    || (typeof val === 'string' && val === '')
+    val === null ||
+    typeof val === "undefined" ||
+    (typeof val === "string" && val === "")
   ) {
     return true;
   }
-  if (Array.isArray(val) || typeof val === 'object') {
+  if (Array.isArray(val) || typeof val === "object") {
     // ESLint disabled as `k` is an "own property" (thanks to `Object.keys()`)
     /* eslint-disable-next-line security/detect-object-injection */
     return Object.keys(val).filter((k) => !isEmpty(val[k])).length === 0;
@@ -29,41 +29,50 @@ export function isEmpty(val) {
 /**
  * Test is a value can be stringified (numbers or strings)
  *
- * @access private
  * @param {any} value Item to test
  * @returns {boolean} Whether the value is stringable or not
+ * @access private
  */
 export function isStringable(value) {
-  return typeof value === 'string' || typeof value === 'number';
+  return typeof value === "string" || typeof value === "number";
 }
 
 /**
  * Extract the middleware functions that are relevant for the given hook and
  * path.
  *
- * @access private
  * @param {string} hookName Hook name (including scope prefix)
  * @param {string} path URL path to match (relative to mountUrl)
  * @param {Hook[]} hooks Hooks to be applied at the page level
  * @returns {Function[]} An array of middleware that should be applied
+ * @access private
  */
 export function resolveMiddlewareHooks(hookName, path, hooks = []) {
   /* eslint-disable-next-line max-len */
-  const pathMatch = (h) => h.path === undefined || (h.path instanceof RegExp && h.path.test(path)) || h.path === path;
-  return hooks.filter((h) => h.hook === hookName).filter(pathMatch).map((h) => h.middleware);
+  const pathMatch = (h) =>
+    h.path === undefined ||
+    (h.path instanceof RegExp && h.path.test(path)) ||
+    h.path === path;
+  return hooks
+    .filter((h) => h.hook === hookName)
+    .filter(pathMatch)
+    .map((h) => h.middleware);
 }
 
 /**
  * Coerce an input to a string.
  *
- * @access private
  * @param {any} input Input to be stringified
  * @param {string} fallback Fallback to use if input can't be stringified
  * @returns {string} The stringified input
+ * @access private
  */
 export function stringifyInput(input, fallback) {
   // Not using param defaults here as the fallback may be explicitly "undefined"
-  const fb = arguments.length === 2 && (isStringable(fallback) || fallback === undefined) ? fallback : '';
+  const fb =
+    arguments.length === 2 && (isStringable(fallback) || fallback === undefined)
+      ? fallback
+      : "";
   return isStringable(input) ? String(input) : fb;
 }
 
@@ -71,7 +80,7 @@ export function stringifyInput(input, fallback) {
  * Coerce an input to an integer.
  *
  * @param {any} input Input to be coerced.
- * @returns {number|undefined} The number as an integer or `undefined`.
+ * @returns {number | undefined} The number as an integer or `undefined`.
  */
 export function coerceInputToInteger(input) {
   return Number.isNaN(Number(input)) ? undefined : Math.floor(Number(input));
@@ -80,34 +89,34 @@ export function coerceInputToInteger(input) {
 /**
  * Strip whitespace from a string.
  *
- * @access private
- * @param {string} value value to be stripped of whitespace
- * @param {object} options overrides for the default whitespace replacements
- * @returns {string} value stripped of white space
+ * @param {string} value Value to be stripped of whitespace
+ * @param {object} options Overrides for the default whitespace replacements
+ * @returns {string} Value stripped of white space
  * @throws {TypeError}
+ * @access private
  */
 export function stripWhitespace(value, options) {
   const opts = {
-    leading: '',
-    trailing: '',
-    nested: ' ',
+    leading: "",
+    trailing: "",
+    nested: " ",
     ...options,
   };
 
-  if (typeof value !== 'string') {
-    throw new TypeError('value must be a string');
+  if (typeof value !== "string") {
+    throw new TypeError("value must be a string");
   }
 
-  if (typeof opts.leading !== 'string') {
-    throw new TypeError('leading must be a string');
+  if (typeof opts.leading !== "string") {
+    throw new TypeError("leading must be a string");
   }
 
-  if (typeof opts.trailing !== 'string') {
-    throw new TypeError('trailing must be a string');
+  if (typeof opts.trailing !== "string") {
+    throw new TypeError("trailing must be a string");
   }
 
-  if (typeof opts.nested !== 'string') {
-    throw new TypeError('nested must be a string');
+  if (typeof opts.nested !== "string") {
+    throw new TypeError("nested must be a string");
   }
 
   return value
@@ -121,14 +130,18 @@ export function stripWhitespace(value, options) {
 /**
  * Checks if the given string can be used as an object key.
  *
- * @access private
  * @param {string} key Proposed Object key
  * @returns {string} Same key if it's valid
- * @throws {Error} if proposed key is an invalid keyword
+ * @throws {Error} If proposed key is an invalid keyword
+ * @access private
  */
 export function notProto(key) {
-  if (['__proto__', 'constructor', 'prototype'].includes(String(key).toLowerCase())) {
-    throw new Error('Attempt to use prototype key disallowed');
+  if (
+    ["__proto__", "constructor", "prototype"].includes(
+      String(key).toLowerCase(),
+    )
+  ) {
+    throw new Error("Attempt to use prototype key disallowed");
   }
   return key;
 }
@@ -136,60 +149,64 @@ export function notProto(key) {
 /**
  * Validate a hook name.
  *
- * @access private
  * @param {string} hookName Hook name
  * @returns {void}
  * @throws {TypeError}
  * @throws {SyntaxError}
+ * @access private
  */
 export function validateHookName(hookName) {
-  if (typeof hookName !== 'string') {
-    throw new TypeError('Hook name must be a string');
+  if (typeof hookName !== "string") {
+    throw new TypeError("Hook name must be a string");
   }
 
   if (!hookName.length) {
-    throw new SyntaxError('Hook name must not be empty');
+    throw new SyntaxError("Hook name must not be empty");
   }
 
   if (!hookName.match(/^([a-z_]+\.|)[a-z_]+$/i)) {
-    throw new SyntaxError('Hook name must match either <scope>.<hookname> or <hookname> formats');
+    throw new SyntaxError(
+      "Hook name must match either <scope>.<hookname> or <hookname> formats",
+    );
   }
 }
 
 /**
  * Validate a hook path.
  *
- * @access private
  * @param {string} path URL path
  * @returns {void}
  * @throws {TypeError}
+ * @access private
  */
 export function validateHookPath(path) {
-  if (typeof path !== 'string' && !(path instanceof RegExp)) {
-    throw new TypeError('Hook path must be a string or RegExp');
+  if (typeof path !== "string" && !(path instanceof RegExp)) {
+    throw new TypeError("Hook path must be a string or RegExp");
   }
 }
 
 /**
  * Validate a URL path.
  *
- * @access private
  * @param {string} path URL path
  * @returns {string} Same string, if valid
  * @throws {TypeError}
  * @throws {SyntaxError}
+ * @access private
  */
 export function validateUrlPath(path) {
-  if (typeof path !== 'string') {
-    throw new TypeError('URL path must be a string');
+  if (typeof path !== "string") {
+    throw new TypeError("URL path must be a string");
   }
 
   if (path.match(/[^/a-z0-9_-]/)) {
-    throw new SyntaxError('URL path must contain only a-z, 0-9, -, _ and / characters');
+    throw new SyntaxError(
+      "URL path must contain only a-z, 0-9, -, _ and / characters",
+    );
   }
 
   if (path.match(/\/{2,}/)) {
-    throw new SyntaxError('URL path must not contain consecutive /');
+    throw new SyntaxError("URL path must not contain consecutive /");
   }
 
   return path;
@@ -198,45 +215,49 @@ export function validateUrlPath(path) {
 /**
  * Validate a template name.
  *
- * @access private
  * @param {string} view Template name
  * @returns {void}
  * @throws {TypeError}
  * @throws {SyntaxError}
+ * @access private
  */
 export function validateView(view) {
-  if (typeof view !== 'string') {
-    throw new TypeError('View must be a string');
+  if (typeof view !== "string") {
+    throw new TypeError("View must be a string");
   }
 
   if (!view.length) {
-    throw new SyntaxError('View must not be empty');
+    throw new SyntaxError("View must not be empty");
   }
 
   if (!view.match(/^[a-z0-9/_-]+\.njk$/i)) {
-    throw new SyntaxError('View must contain only a-z, 0-9, -, _ and / characters, and end in .njk');
+    throw new SyntaxError(
+      "View must contain only a-z, 0-9, -, _ and / characters, and end in .njk",
+    );
   }
 }
 
 /**
  * Validate a waypoint.
  *
- * @access private
  * @param {string} waypoint Waypoint
  * @returns {void}
  * @throws {TypeError}
  * @throws {SyntaxError}
+ * @access private
  */
 export function validateWaypoint(waypoint) {
-  if (typeof waypoint !== 'string') {
-    throw new TypeError('Waypoint must be a string');
+  if (typeof waypoint !== "string") {
+    throw new TypeError("Waypoint must be a string");
   }
 
   if (!waypoint.length) {
-    throw new SyntaxError('Waypoint must not be empty');
+    throw new SyntaxError("Waypoint must not be empty");
   }
 
   if (waypoint.match(/[^/a-z0-9_-]/)) {
-    throw new SyntaxError('Waypoint must contain only a-z, 0-9, -, _ and / characters');
+    throw new SyntaxError(
+      "Waypoint must contain only a-z, 0-9, -, _ and / characters",
+    );
   }
 }

package/src/lib/validators/dateObject.js

@@ -1,37 +1,38 @@
 /* eslint-disable class-methods-use-this */
-import { DateTime } from 'luxon';
-import lodash from 'lodash';
-import ValidationError from '../ValidationError.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import { stringifyInput, stripWhitespace } from '../utils.js';
+import { DateTime } from "luxon";
+import lodash from "lodash";
+import ValidationError from "../ValidationError.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import { stringifyInput, stripWhitespace } from "../utils.js";
 
 const { isPlainObject } = lodash;
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
  * @typedef {object} DateObjectConfigOptions
  * @property {ErrorMessageConfig} errorMsg Error message config
  * @property {object} [afterOffsetFromNow] Offset from now
- * @property {ErrorMessageConfig} [errorMsgAfterOffset] Error if date is after this offset
+ * @property {ErrorMessageConfig} [errorMsgAfterOffset] Error if date is after
+ *   this offset
  * @property {object} [beforeOffsetFromNow] Offset from now
- * @property {ErrorMessageConfig} [errorMsgBeforeOffset] Error if date is before this offset
- * @property {boolean} [allowMonthNames=false] Allow "Jan", "January", etc
- * @property {boolean} [allowSingleDigitDay=false] Allow "1" rather than "01"
- * @property {boolean} [allowSingleDigitMonth=false] Allow "1" rather than "01"
- * @property {DateTime} [now=false] Override the notion of "now" (useful for testing)
+ * @property {ErrorMessageConfig} [errorMsgBeforeOffset] Error if date is before
+ *   this offset
+ * @property {boolean} [allowMonthNames=false] Allow "Jan", "January", etc.
+ *   Default is `false`
+ * @property {boolean} [allowSingleDigitDay=false] Allow "1" rather than "01".
+ *   Default is `false`
+ * @property {boolean} [allowSingleDigitMonth=false] Allow "1" rather than "01".
+ *   Default is `false`
+ * @property {DateTime} [now=false] Override the notion of "now" (useful for
+ *   testing). Default is `false`
  */
 
 /**
- * Date object format:
- *  {
- *    dd: <string>,
- *    mm: <string>,
- *    yyyy: <string>
- *  }.
+ * Date object format: { dd: <string>, mm: <string>, yyyy: <string> }.
  *
  * Note that the time part will be zero'ed, as we are only interested in the
  * date component (minimum day resolution).
@@ -43,21 +44,21 @@ const { isPlainObject } = lodash;
  */
 export default class DateObject extends ValidatorFactory {
   /** @property {string} name Validator name ("dateObject") */
-  name = 'dateObject';
+  name = "dateObject";
 
   validate(value, dataContext = {}) {
     const config = {
       errorMsg: {
-        inline: 'validation:rule.dateObject.inline',
-        summary: 'validation:rule.dateObject.summary',
+        inline: "validation:rule.dateObject.inline",
+        summary: "validation:rule.dateObject.summary",
       },
       errorMsgAfterOffset: {
-        inline: 'validation:rule.dateObject.afterOffset.inline',
-        summary: 'validation:rule.dateObject.afterOffset.summary',
+        inline: "validation:rule.dateObject.afterOffset.inline",
+        summary: "validation:rule.dateObject.afterOffset.summary",
       },
       errorMsgBeforeOffset: {
-        inline: 'validation:rule.dateObject.beforeOffset.inline',
-        summary: 'validation:rule.dateObject.beforeOffset.summary',
+        inline: "validation:rule.dateObject.beforeOffset.inline",
+        summary: "validation:rule.dateObject.beforeOffset.summary",
       },
       now: DateTime.local(),
       allowSingleDigitDay: false,
@@ -71,38 +72,44 @@ export default class DateObject extends ValidatorFactory {
     let valid = false;
     let { errorMsg } = config;
     let luxonDate;
-    const NOW = config.now.startOf('day');
+    const NOW = config.now.startOf("day");
 
     // Accepted formats
-    let formats = ['dd-MM-yyyy'];
-    const formatTests = [{
-      flags: [config.allowSingleDigitDay],
-      formats: ['d-MM-yyyy'],
-    }, {
-      flags: [config.allowSingleDigitDay, config.allowSingleDigitMonth],
-      formats: ['d-M-yyyy'],
-    }, {
-      flags: [config.allowSingleDigitDay, config.allowMonthNames],
-      formats: ['d-MMM-yyyy', 'd-MMMM-yyyy'],
-    }, {
-      flags: [config.allowSingleDigitMonth],
-      formats: ['dd-M-yyyy'],
-    }, {
-      flags: [config.allowMonthNames],
-      formats: ['dd-MMM-yyyy', 'dd-MMMM-yyyy'],
-    }];
+    let formats = ["dd-MM-yyyy"];
+    const formatTests = [
+      {
+        flags: [config.allowSingleDigitDay],
+        formats: ["d-MM-yyyy"],
+      },
+      {
+        flags: [config.allowSingleDigitDay, config.allowSingleDigitMonth],
+        formats: ["d-M-yyyy"],
+      },
+      {
+        flags: [config.allowSingleDigitDay, config.allowMonthNames],
+        formats: ["d-MMM-yyyy", "d-MMMM-yyyy"],
+      },
+      {
+        flags: [config.allowSingleDigitMonth],
+        formats: ["dd-M-yyyy"],
+      },
+      {
+        flags: [config.allowMonthNames],
+        formats: ["dd-MMM-yyyy", "dd-MMMM-yyyy"],
+      },
+    ];
     formatTests.forEach((test) => {
       if (test.flags.every((v) => v === true)) {
         formats = [...formats, ...test.formats];
       }
     });
 
-    if (typeof value === 'object') {
+    if (typeof value === "object") {
       formats.find((format) => {
         luxonDate = DateTime.fromFormat(
-          [value.dd, value.mm, value.yyyy].join('-'),
+          [value.dd, value.mm, value.yyyy].join("-"),
           format,
-        ).startOf('day');
+        ).startOf("day");
 
         valid = luxonDate.isValid;
 
@@ -113,7 +120,7 @@ export default class DateObject extends ValidatorFactory {
         // Check date is after the specified duration from now.
         // Need to use UTC() otherwise DST shifts can affect the calculated offset
         if (config.afterOffsetFromNow) {
-          const offsetDate = NOW.plus(config.afterOffsetFromNow).startOf('day');
+          const offsetDate = NOW.plus(config.afterOffsetFromNow).startOf("day");
 
           if (luxonDate <= offsetDate) {
             valid = false;
@@ -124,7 +131,9 @@ export default class DateObject extends ValidatorFactory {
         // Check date is before the specified duration from now
         // Need to use UTC() otherwise DST shifts can affect the calculated offset
         if (config.beforeOffsetFromNow) {
-          const offsetDate = NOW.plus(config.beforeOffsetFromNow).startOf('day');
+          const offsetDate = NOW.plus(config.beforeOffsetFromNow).startOf(
+            "day",
+          );
 
           if (luxonDate >= offsetDate) {
             valid = false;
@@ -136,20 +145,20 @@ export default class DateObject extends ValidatorFactory {
       // Check presence of each object component (dd, mm, yyyy) in order to log
       // which specific parts are in error
       errorMsg.focusSuffix = [];
-      if (!Object.prototype.hasOwnProperty.call(value, 'dd') || !value.dd) {
-        errorMsg.focusSuffix.push('[dd]');
+      if (!Object.prototype.hasOwnProperty.call(value, "dd") || !value.dd) {
+        errorMsg.focusSuffix.push("[dd]");
       }
-      if (!Object.prototype.hasOwnProperty.call(value, 'mm') || !value.mm) {
-        errorMsg.focusSuffix.push('[mm]');
+      if (!Object.prototype.hasOwnProperty.call(value, "mm") || !value.mm) {
+        errorMsg.focusSuffix.push("[mm]");
       }
-      if (!Object.prototype.hasOwnProperty.call(value, 'yyyy') || !value.yyyy) {
-        errorMsg.focusSuffix.push('[yyyy]');
+      if (!Object.prototype.hasOwnProperty.call(value, "yyyy") || !value.yyyy) {
+        errorMsg.focusSuffix.push("[yyyy]");
       }
 
       // If the date is invalid, but not specific parts have been highlighted in
       // error, then highlight all inputs, focusing on the [dd] first
       if (!valid && !errorMsg.focusSuffix.length) {
-        errorMsg.focusSuffix = ['[dd]', '[mm]', '[yyyy]'];
+        errorMsg.focusSuffix = ["[dd]", "[mm]", "[yyyy]"];
       }
     }
 
@@ -158,11 +167,13 @@ export default class DateObject extends ValidatorFactory {
 
   sanitise(value) {
     if (value !== undefined) {
-      return isPlainObject(value) ? {
-        dd: stripWhitespace(stringifyInput(value.dd)),
-        mm: stripWhitespace(stringifyInput(value.mm)),
-        yyyy: stripWhitespace(stringifyInput(value.yyyy)),
-      } : Object.create(null);
+      return isPlainObject(value)
+        ? {
+            dd: stripWhitespace(stringifyInput(value.dd)),
+            mm: stripWhitespace(stringifyInput(value.mm)),
+            yyyy: stripWhitespace(stringifyInput(value.yyyy)),
+          }
+        : Object.create(null);
     }
     return undefined;
   }

package/src/lib/validators/email.js

@@ -1,14 +1,14 @@
 /* eslint-disable class-methods-use-this */
-import validatorPkg from 'validator';
-import ValidationError from '../ValidationError.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import { stringifyInput } from '../utils.js';
+import validatorPkg from "validator";
+import ValidationError from "../ValidationError.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import { stringifyInput } from "../utils.js";
 
 const { isEmail } = validatorPkg; // CommonJS
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
@@ -28,7 +28,7 @@ const { isEmail } = validatorPkg; // CommonJS
  */
 export default class Email extends ValidatorFactory {
   /** @property {string} name Validator name ("email") */
-  name = 'email';
+  name = "email";
 
   validate(value, dataContext = {}) {
     let isValid;
@@ -39,8 +39,8 @@ export default class Email extends ValidatorFactory {
     }
 
     const errorMsg = this.config.errorMsg || {
-      summary: 'validation:rule.email.summary',
-      inline: 'validation:rule.email.inline',
+      summary: "validation:rule.email.summary",
+      inline: "validation:rule.email.inline",
     };
 
     return isValid ? [] : [ValidationError.make({ errorMsg, dataContext })];

package/src/lib/validators/inArray.js

@@ -2,19 +2,18 @@
 /**
  * Test if a value is present in an array.
  *
- * Config options:
- *   Array source = Array of values to test against
+ * Config options: Array source = Array of values to test against
  *
  * If the value itself is an array, all values within that array must be present
  * in the `source` array in order to pass validation.
  */
-import ValidationError from '../ValidationError.js';
-import ValidatorFactory from '../ValidatorFactory.js';
-import { stringifyInput, isStringable } from '../utils.js';
+import ValidationError from "../ValidationError.js";
+import ValidatorFactory from "../ValidatorFactory.js";
+import { stringifyInput, isStringable } from "../utils.js";
 
 /**
+ * @typedef {import("../../casa").ErrorMessageConfig} ErrorMessageConfig
  * @access private
- * @typedef {import('../../casa').ErrorMessageConfig} ErrorMessageConfig
  */
 
 /**
@@ -36,17 +35,17 @@ import { stringifyInput, isStringable } from '../utils.js';
  */
 export default class InArray extends ValidatorFactory {
   /** @property {string} name Validator name ("inArray") */
-  name = 'inArray';
+  name = "inArray";
 
   validate(value, dataContext = {}) {
     let valid = false;
     const source = this.config.source || [];
     const errorMsg = this.config.errorMsg || {
-      inline: 'validation:rule.inArray.inline',
-      summary: 'validation:rule.inArray.summary',
+      inline: "validation:rule.inArray.inline",
+      summary: "validation:rule.inArray.summary",
     };
 
-    if (value !== null && typeof value !== 'undefined') {
+    if (value !== null && typeof value !== "undefined") {
       const search = Array.isArray(value) ? value : [value];
       for (let i = 0, l = search.length; i < l; i += 1) {
         if (source.indexOf(search[parseInt(i, 10)]) > -1) {
@@ -62,7 +61,7 @@ export default class InArray extends ValidatorFactory {
   }
 
   sanitise(value) {
-    const coerce = (val) => (stringifyInput(val, undefined));
+    const coerce = (val) => stringifyInput(val, undefined);
 
     // Basic stringable
     if (isStringable(value)) {

package/src/lib/validators/index.js

@@ -1,17 +1,15 @@
-import dateObject from './dateObject.js';
-import email from './email.js';
-import inArray from './inArray.js';
-import nino from './nino.js';
-import postalAddressObject from './postalAddressObject.js';
-import regex from './regex.js';
-import required from './required.js';
-import strlen from './strlen.js';
-import range from './range.js';
-import wordCount from './wordCount.js';
+import dateObject from "./dateObject.js";
+import email from "./email.js";
+import inArray from "./inArray.js";
+import nino from "./nino.js";
+import postalAddressObject from "./postalAddressObject.js";
+import regex from "./regex.js";
+import required from "./required.js";
+import strlen from "./strlen.js";
+import range from "./range.js";
+import wordCount from "./wordCount.js";
 
-/**
- * @namespace Validators
- */
+/** @namespace Validators */
 export default {
   dateObject,
   email,
@@ -23,4 +21,4 @@ export default {
   strlen,
   range,
   wordCount,
-}
+};