@dwp/govuk-casa 7.0.3 → 7.0.8

package/dist/lib/logger.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const casaDebugger = (0, debug_1.default)('casa');
+exports.default = (ns) => {
+    const logger = casaDebugger.extend(ns);
+    return {
+        trace: logger.extend('trace'),
+        debug: logger.extend('debug'),
+        info: logger.extend('info'),
+        warn: logger.extend('warn'),
+        error: logger.extend('error'),
+        fatal: logger.extend('fatal'),
+    };
+};

package/dist/lib/nunjucks-filters.d.ts

@@ -0,0 +1,26 @@
+export function mergeObjects(...objects: any[]): object;
+export function includes(source?: any[], search?: string): boolean;
+/**
+ * Format a given date.
+ *
+ * Requires NodeJS >= 14 to make use of bundled date locale data.
+ *
+ * `date` may be any of the following types:
+ *   object - {dd:'', mm:'', yyyy:''}
+ *
+ * @param  {object} date Date (see supported formats above)
+ * @param  {object} config Holds locale
+ * @returns {string} Formatted date
+ */
+export function formatDateObject(date: object, config?: object): string;
+/**
+ * Attribute values will be HTML/attribute escaped.
+ *
+ * Example:
+ *   Given: {class: 'basic', 'data-ga': 3}
+ *   Output: class="basic" data-ga="3"
+ *
+ * @param  {object} attrsObject Attributes object (in name:value pairs)
+ * @returns {string} Formatted
+ */
+export function renderAsAttributes(attrsObject: object): string;

package/dist/lib/nunjucks-filters.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAsAttributes = exports.formatDateObject = exports.includes = exports.mergeObjects = void 0;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const luxon_1 = require("luxon");
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const { all: deepmergeAll } = deepmerge_1.default;
+// Arrays will be merged such that elements at the same index will be merged
+// into each other
+// ref: https://www.npmjs.com/package/deepmerge
+const combineMerge = (target, source, options) => {
+    const destination = target.slice();
+    source.forEach((item, index) => {
+        if (typeof destination[index] === 'undefined') {
+            destination[index] = options.cloneUnlessOtherwiseSpecified(item, options);
+        }
+        else if (options.isMergeableObject(item)) {
+            destination[index] = (0, deepmerge_1.default)(target[index], item, options);
+        }
+        else if (target.indexOf(item) === -1) {
+            destination.push(item);
+        }
+    });
+    return destination;
+};
+function mergeObjects(...objects) {
+    return deepmergeAll([Object.create(null), ...objects], { arrayMerge: combineMerge });
+}
+exports.mergeObjects = mergeObjects;
+function includes(source = [], search = '') {
+    return source.includes(search);
+}
+exports.includes = includes;
+/**
+ * Format a given date.
+ *
+ * Requires NodeJS >= 14 to make use of bundled date locale data.
+ *
+ * `date` may be any of the following types:
+ *   object - {dd:'', mm:'', yyyy:''}
+ *
+ * @param  {object} date Date (see supported formats above)
+ * @param  {object} config Holds locale
+ * @returns {string} Formatted date
+ */
+function formatDateObject(date, config = {}) {
+    const { locale = 'en' } = config;
+    if (Object.prototype.toString.call(date) === '[object Object]'
+        && 'yyyy' in date
+        && 'mm' in date
+        && 'dd' in date) {
+        return luxon_1.DateTime.fromObject({
+            year: Math.max(0, parseInt(date.yyyy, 10)),
+            month: Math.max(0, parseInt(date.mm, 10)),
+            day: Math.max(1, parseInt(date.dd, 10)),
+        }).setLocale(locale).toFormat('d MMMM yyyy');
+    }
+    return 'INVALID DATE OBJECT';
+}
+exports.formatDateObject = formatDateObject;
+/**
+ * Attribute values will be HTML/attribute escaped.
+ *
+ * Example:
+ *   Given: {class: 'basic', 'data-ga': 3}
+ *   Output: class="basic" data-ga="3"
+ *
+ * @param  {object} attrsObject Attributes object (in name:value pairs)
+ * @returns {string} Formatted
+ */
+function renderAsAttributes(attrsObject) {
+    const attrsList = [];
+    if (typeof attrsObject === 'object') {
+        Object.keys(attrsObject).forEach((key) => {
+            const value = String(attrsObject[key]).replace(/[<>"'&]/g, (m) => ({
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                '\'': '&#039;',
+                '&': '&amp;',
+            }[m]));
+            attrsList.push(`${key}="${value}"`);
+        });
+    }
+    return new nunjucks_1.default.runtime.SafeString(attrsList.join(' '));
+}
+exports.renderAsAttributes = renderAsAttributes;

package/dist/lib/nunjucks.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @typedef {object} NunjucksOptions
+ * @property {string} [mountUrl=/] Mount URL (optional, default /)
+ * @property {string[]} [views=[]] Template file directories (optional, default [])
+ */
+/**
+ * Create a Nunjucks environment.
+ *
+ * @param {NunjucksOptions} options Nunjucks options
+ * @returns {Environment} Nunjucks Environment instance
+ */
+export default function nunjucksConfig({ mountUrl, views, }: NunjucksOptions): Environment;
+export type NunjucksOptions = {
+    /**
+     * )
+     */
+    mountUrl?: string | undefined;
+    /**
+     * Template file directories (optional, default [])
+     */
+    views?: string[] | undefined;
+};
+import { Environment } from "nunjucks";

package/dist/lib/nunjucks.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const nunjucks_1 = require("nunjucks");
+const dirname_cjs_1 = __importDefault(require("./dirname.cjs"));
+const CasaTemplateLoader_js_1 = __importDefault(require("./CasaTemplateLoader.js"));
+const nunjucks_filters_js_1 = require("./nunjucks-filters.js");
+/**
+ * @typedef {object} NunjucksOptions
+ * @property {string} [mountUrl=/] Mount URL (optional, default /)
+ * @property {string[]} [views=[]] Template file directories (optional, default [])
+ */
+/**
+ * Create a Nunjucks environment.
+ *
+ * @param {NunjucksOptions} options Nunjucks options
+ * @returns {Environment} Nunjucks Environment instance
+ */
+function nunjucksConfig({ mountUrl = '/', views = [], }) {
+    // Prepare a single Nunjucks environment for all responses to use. Note that
+    // we cannot prepare response-specific global functions/filters if we use a
+    // single environment, but the performance gains of doing so are significant.
+    const loader = new CasaTemplateLoader_js_1.default(views, {
+        watch: false,
+        noCache: false,
+    });
+    const env = new nunjucks_1.Environment(loader, {
+        autoescape: true,
+        throwOnUndefined: false,
+        trimBlocks: false,
+        lstripBlocks: false,
+    });
+    // Enhancement to expose loader functions
+    env.modifyBlock = loader.modifyBlock.bind(loader);
+    // Globals
+    // These can't be modified once set. But they can be overridden by res.locals.
+    env.addGlobal('assetPath', `${mountUrl}govuk/assets`); // Required by govuk-frontend layout template
+    env.addGlobal('casaVersion', JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(dirname_cjs_1.default, '../../package.json'))).version);
+    env.addGlobal('mergeObjects', nunjucks_filters_js_1.mergeObjects);
+    env.addGlobal('includes', nunjucks_filters_js_1.includes);
+    env.addGlobal('formatDateObject', nunjucks_filters_js_1.formatDateObject);
+    env.addGlobal('renderAsAttributes', nunjucks_filters_js_1.renderAsAttributes);
+    return env;
+}
+exports.default = nunjucksConfig;

package/dist/lib/utils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @typedef {import('./configuration-ingestor').GlobalHook} GlobalHook
+ */
+/**
+ * @typedef {import('./configuration-ingestor').PageHook} PageHook
+ */
+/**
+ * @typedef {GlobalHook | PageHook} Hook
+ */
+/**
+ * Test is a value can be stringifed (numbers or strings)
+ *
+ * @param {any} value Item to test
+ * @returns {boolean} Whether the value is stringable or not
+ */
+export function isStringable(value: any): boolean;
+/**
+ * Coerce an input to a string.
+ *
+ * @param {any} input Input to be stringified
+ * @param {string} fallback Fallback to use if input can't be stringified
+ * @returns {string} The stringified input
+ */
+export function stringifyInput(input: any, fallback: string, ...args: any[]): string;
+/**
+ * Determine if value is empty. Recurse over objects.
+ *
+ * @param  {any} val Value to check
+ * @returns {boolean} True if the object is empty
+ */
+export function isEmpty(val: any): boolean;
+/**
+ * Extract the middleware functions that are relevant for the given hook and
+ * path.
+ *
+ * @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
+ */
+export function resolveMiddlewareHooks(hookName: string, path: string, hooks?: Hook[]): Function[];
+export function validateWaypoint(waypoint: any): void;
+export function validateView(view: any): void;
+export function validateHookName(hookName: any): void;
+export function validateHookPath(path: any): void;
+export type GlobalHook = import('./configuration-ingestor').GlobalHook;
+export type PageHook = import('./configuration-ingestor').PageHook;
+export type Hook = GlobalHook | PageHook;

package/dist/lib/utils.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * @typedef {import('./configuration-ingestor').GlobalHook} GlobalHook
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHookPath = exports.validateHookName = exports.validateView = exports.validateWaypoint = exports.resolveMiddlewareHooks = exports.isEmpty = exports.stringifyInput = exports.isStringable = void 0;
+/**
+ * @typedef {import('./configuration-ingestor').PageHook} PageHook
+ */
+/**
+ * @typedef {GlobalHook | PageHook} Hook
+ */
+/**
+ * Test is a value can be stringifed (numbers or strings)
+ *
+ * @param {any} value Item to test
+ * @returns {boolean} Whether the value is stringable or not
+ */
+function isStringable(value) {
+    return typeof value === 'string' || typeof value === 'number';
+}
+exports.isStringable = isStringable;
+/**
+ * Coerce an input to a string.
+ *
+ * @param {any} input Input to be stringified
+ * @param {string} fallback Fallback to use if input can't be stringified
+ * @returns {string} The stringified input
+ */
+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 : '';
+    return isStringable(input) ? String(input) : fb;
+}
+exports.stringifyInput = stringifyInput;
+/**
+ * Determine if value is empty. Recurse over objects.
+ *
+ * @param  {any} val Value to check
+ * @returns {boolean} True if the object is empty
+ */
+function isEmpty(val) {
+    if (val === null
+        || typeof val === 'undefined'
+        || (typeof val === 'string' && val === '')) {
+        return true;
+    }
+    if (Array.isArray(val) || typeof val === 'object') {
+        return Object.keys(val).filter((k) => !isEmpty(val[k])).length === 0;
+    }
+    return false;
+}
+exports.isEmpty = isEmpty;
+/**
+ * Extract the middleware functions that are relevant for the given hook and
+ * path.
+ *
+ * @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
+ */
+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);
+}
+exports.resolveMiddlewareHooks = resolveMiddlewareHooks;
+/* ------------------------------------------------ validation / sanitisation */
+function validateWaypoint(waypoint) {
+    if (typeof waypoint !== 'string') {
+        throw new TypeError('Waypoint must be a string');
+    }
+    if (!waypoint.length) {
+        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');
+    }
+}
+exports.validateWaypoint = validateWaypoint;
+function validateView(view) {
+    if (typeof view !== 'string') {
+        throw new TypeError('View must be a string');
+    }
+    if (!view.length) {
+        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');
+    }
+}
+exports.validateView = validateView;
+function validateHookName(hookName) {
+    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');
+    }
+    if (!hookName.match(/^([a-z]+\.|)[a-z]+$/i)) {
+        throw new SyntaxError('Hook name must match either <scope>.<hookname> or <hookname> formats');
+    }
+}
+exports.validateHookName = validateHookName;
+function validateHookPath(path) {
+    if (typeof path !== 'string' && !(path instanceof RegExp)) {
+        throw new TypeError('Hook path must be a string or RegExp');
+    }
+}
+exports.validateHookPath = validateHookPath;

package/dist/lib/validators/dateObject.d.ts

@@ -0,0 +1,4 @@
+export default class DateObject extends ValidatorFactory {
+    name: string;
+}
+import ValidatorFactory from "../ValidatorFactory.js";

package/dist/lib/validators/dateObject.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable class-methods-use-this */
+/**
+ * Date object format:
+ *  {
+ *    dd: <string>,
+ *    mm: <string>,
+ *    yyyy: <string>
+ *  }.
+ *
+ * Note that the time part of any injected "DateTime" objects will be zero'ed, as
+ * we are only interested in the date component (minimum day resolution).
+ *
+ * Config options:
+ *   string|object errorMsg = Error message to use on validation failure
+ *   object|luxon.Duration afterOffsetFromNow = Date must be after offset from now
+ *   string|object errorMsgAfterOffset = Error for afterOffsetFromNow failure
+ *   object|luxon.Duration beforeOffsetFromNow = Date must be before offset from now
+ *   string|object errorMsgBeforeOffset = Error for beforeOffsetFromNow failure
+ *   bool allowMonthNames = Allow "Jan", "January", etc (default = false)
+ *   bool allowSingleDigitDay = Allow "1" rather than "01" (default = false)
+ *   bool allowSingleDigitMonth = Allow "1" rather than "01" (default = false)
+ *   luxon.DateTime now = Override the notion of "now" (useful for testing)
+ */
+const luxon_1 = require("luxon");
+const lodash_1 = __importDefault(require("lodash"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const utils_js_1 = require("../utils.js");
+const { isPlainObject } = lodash_1.default;
+class DateObject extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'dateObject';
+    }
+    validate(value, dataContext = {}) {
+        const config = Object.assign({ errorMsg: {
+                inline: 'validation:rule.dateObject.inline',
+                summary: 'validation:rule.dateObject.summary',
+            }, errorMsgAfterOffset: {
+                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',
+            }, now: luxon_1.DateTime.local(), allowSingleDigitDay: false, allowSingleDigitMonth: false, allowMonthNames: false, afterOffsetFromNow: undefined, beforeOffsetFromNow: undefined }, this.config);
+        let valid = false;
+        let { errorMsg } = config;
+        let luxonDate;
+        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'],
+            }];
+        formatTests.forEach((test) => {
+            if (test.flags.every((v) => v === true)) {
+                formats = [...formats, ...test.formats];
+            }
+        });
+        if (typeof value === 'object') {
+            formats.find((format) => {
+                luxonDate = luxon_1.DateTime.fromFormat([value.dd, value.mm, value.yyyy].join('-'), format).startOf('day');
+                valid = luxonDate.isValid;
+                return valid;
+            });
+            if (luxonDate) {
+                // 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');
+                    if (luxonDate <= offsetDate) {
+                        valid = false;
+                        errorMsg = config.errorMsgAfterOffset;
+                    }
+                }
+                // 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');
+                    if (luxonDate >= offsetDate) {
+                        valid = false;
+                        errorMsg = config.errorMsgBeforeOffset;
+                    }
+                }
+            }
+            // 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, 'mm') || !value.mm) {
+                errorMsg.focusSuffix.push('[mm]');
+            }
+            if (!Object.prototype.hasOwnProperty.call(value, 'yyyy') || !value.yyyy) {
+                errorMsg.focusSuffix.push('[yyyy]');
+            }
+            // If the date is invalid, but not specific parts have been highighted in
+            // error, then highlight all inputs, focusing on the [dd] first
+            if (!valid && !errorMsg.focusSuffix.length) {
+                errorMsg.focusSuffix = ['[dd]', '[mm]', '[yyyy]'];
+            }
+        }
+        return valid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return isPlainObject(value) ? {
+                dd: (0, utils_js_1.stringifyInput)(value.dd),
+                mm: (0, utils_js_1.stringifyInput)(value.mm),
+                yyyy: (0, utils_js_1.stringifyInput)(value.yyyy),
+            } : Object.create(null);
+        }
+        return undefined;
+    }
+}
+exports.default = DateObject;

package/dist/lib/validators/email.d.ts

@@ -0,0 +1,4 @@
+export default class Email extends ValidatorFactory {
+    name: string;
+}
+import ValidatorFactory from "../ValidatorFactory.js";

package/dist/lib/validators/email.js

@@ -0,0 +1,46 @@
+"use strict";
+/* eslint-disable class-methods-use-this */
+/**
+ * Email address.
+ *
+ * This is not an exhaustive validation, and is permissive.
+ *
+ * Config options:
+ *   string|object errorMsg = Error message to use on validation failure
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = __importDefault(require("validator"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const utils_js_1 = require("../utils.js");
+const { isEmail } = validator_1.default; // CommonJS
+class Email extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'email';
+    }
+    validate(value, dataContext = {}) {
+        let isValid;
+        try {
+            isValid = isEmail(value);
+        }
+        catch (e) {
+            isValid = false;
+        }
+        const errorMsg = this.config.errorMsg || {
+            summary: 'validation:rule.email.summary',
+            inline: 'validation:rule.email.inline',
+        };
+        return isValid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        return undefined;
+    }
+}
+exports.default = Email;

package/dist/lib/validators/inArray.d.ts

@@ -0,0 +1,4 @@
+export default class InArray extends ValidatorFactory {
+    name: string;
+}
+import ValidatorFactory from "../ValidatorFactory.js";

package/dist/lib/validators/inArray.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable class-methods-use-this */
+/**
+ * Test if a value is present in an array.
+ *
+ * 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.
+ */
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const utils_js_1 = require("../utils.js");
+class InArray extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.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',
+        };
+        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[i]) > -1) {
+                    valid = true;
+                }
+                else {
+                    valid = false;
+                    break;
+                }
+            }
+        }
+        return valid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        const coerce = (val) => ((0, utils_js_1.stringifyInput)(val, undefined));
+        // Basic stringable
+        if ((0, utils_js_1.isStringable)(value)) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        // Coerce all elements to Strings.
+        // This only supports one dimensional array, with stringable element.
+        if (Array.isArray(value)) {
+            return value.map(coerce);
+        }
+        // Unsupported value
+        return undefined;
+    }
+}
+exports.default = InArray;

package/dist/lib/validators/index.d.ts

@@ -0,0 +1,21 @@
+declare namespace _default {
+    export { dateObject };
+    export { email };
+    export { inArray };
+    export { nino };
+    export { postalAddressObject };
+    export { regex };
+    export { required };
+    export { strlen };
+    export { wordCount };
+}
+export default _default;
+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 wordCount from "./wordCount.js";