@dwp/govuk-casa 7.0.6 → 8.0.0-alpha1

package/dist/lib/field.js

@@ -0,0 +1,223 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _PageField_name, _PageField_processors, _PageField_validators, _PageField_conditions, _PageField_meta;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageField = void 0;
+const utils_js_1 = require("./utils.js");
+const lodash_1 = __importDefault(require("lodash"));
+const { isFunction } = lodash_1.default;
+/**
+ * @typedef {Object} Validator
+ * @property {ValidateFunction} validate Validation function
+ * @property {SanitiseFunction} sanitise Sanitise a given value to make it suitable for this validator
+ * @property {Object} config Configuration
+ * @property {string} name Validator name
+ */
+/**
+ * @callback ValidateFunction
+ * @param {any} value
+ * @param {ValidateContext} context
+ * @return {ValidationError[]}
+ */
+/**
+ * @callback SanitiseFunction
+ * @param {any} value
+ * @returns {any}
+ */
+/**
+ * @typedef {Object} ValidateContext Context passed to validate function
+ * @property {JourneyContext} journeyContext Journey context
+ * @property {string} waypoint Waypoint
+ * @property {string} fieldName Name of field being processed
+ */
+// Quick check to see if the field name corresponds to a non-primitive complex
+// type. For example, `my_field[nested]`.
+const reComplexType = /\[/;
+const reInvalidName = /[^a-z0-9_.\-\[\]]/i;
+// Factory for convenience
+function field(...args) {
+    return new PageField(...args);
+}
+exports.default = field;
+// This is never exposed via a public API, and instead users are encouraged to
+// use the `field()` factory instead
+class PageField {
+    constructor(name, { optional = false, persist = true } = Object.create(null)) {
+        /*
+         * @type {string}
+         */
+        _PageField_name.set(this, void 0);
+        /**
+         * @type {function[]}
+         */
+        _PageField_processors.set(this, void 0);
+        /**
+         * @type {Validator[]}
+         */
+        _PageField_validators.set(this, void 0);
+        /**
+         * @type {function[]}
+         */
+        _PageField_conditions.set(this, void 0);
+        /**
+         * @type {Object}
+         */
+        _PageField_meta.set(this, void 0);
+        if (!name) {
+            throw new SyntaxError('A name for this field is required, i.e. "field(\'myField\')".');
+        }
+        else if (reInvalidName.test(String(name))) {
+            throw new SyntaxError(`Field '${String(name)}' name contains invalid characters.`);
+        }
+        __classPrivateFieldSet(this, _PageField_name, String(name), "f");
+        __classPrivateFieldSet(this, _PageField_validators, [], "f");
+        __classPrivateFieldSet(this, _PageField_processors, [], "f");
+        __classPrivateFieldSet(this, _PageField_conditions, [], "f");
+        __classPrivateFieldSet(this, _PageField_meta, {
+            optional,
+            persist,
+            complex: reComplexType.test(name),
+        }, "f");
+    }
+    /**
+     * For complex fields, we need may need to drill into an object to extract the
+     * value.
+     *
+     * @param {Object} obj Object from which to extract the value
+     * @returns {any}
+     */
+    getValue(obj = Object.create(null)) {
+        if (!__classPrivateFieldGet(this, _PageField_meta, "f").complex) {
+            return obj[__classPrivateFieldGet(this, _PageField_name, "f")];
+        }
+        throw new Error('Not yet supporting complex field types');
+    }
+    putValue(obj = Object.create(null), value) {
+        if (!__classPrivateFieldGet(this, _PageField_meta, "f").complex) {
+            obj[__classPrivateFieldGet(this, _PageField_name, "f")] = value;
+            return this;
+        }
+        throw new Error('Not yet supporting complex field types');
+    }
+    /* -------------------------------------------------------------- configure */
+    get name() {
+        return __classPrivateFieldGet(this, _PageField_name, "f");
+    }
+    get meta() {
+        return __classPrivateFieldGet(this, _PageField_meta, "f");
+    }
+    // Add/get value validators
+    // Some validators might include their own processors on
+    validators(...items) {
+        // TODO: prepend any sanitisers these validators may have onto the #processors array
+        if (!items.length)
+            return __classPrivateFieldGet(this, _PageField_validators, "f");
+        __classPrivateFieldSet(this, _PageField_validators, [...__classPrivateFieldGet(this, _PageField_validators, "f"), ...(items.flat())], "f");
+        return this;
+    }
+    // Add/get value pre-processors
+    // This is most often used to sanitise values to a particular data type
+    processors(...items) {
+        if (!items.length)
+            return __classPrivateFieldGet(this, _PageField_processors, "f");
+        __classPrivateFieldSet(this, _PageField_processors, [...__classPrivateFieldGet(this, _PageField_processors, "f"), ...(items.flat())], "f");
+        return this;
+    }
+    // Add/get conditions
+    // All conditions must be met in order for this field to be considered "actionable"
+    conditions(...items) {
+        if (!items.length)
+            return __classPrivateFieldGet(this, _PageField_conditions, "f");
+        __classPrivateFieldSet(this, _PageField_conditions, [...__classPrivateFieldGet(this, _PageField_conditions, "f"), ...(items.flat())], "f");
+        return this;
+    }
+    /* ---------------------------------------------------------------- execute */
+    /**
+     * Run all validators and return array of errors, if applicable.
+     *
+     * @param {any} value Value to validate
+     * @param {ValidateContext} context Contextual information
+     * @returns {ValidationError[]} Errors, or an empty array if all valid
+     */
+    runValidators(value, context) {
+        // Skip validation if the field is empty and optional
+        if (__classPrivateFieldGet(this, _PageField_meta, "f").optional && (0, utils_js_1.isEmpty)(value)) {
+            return [];
+        }
+        let errors = [];
+        for (let i = 0, l = __classPrivateFieldGet(this, _PageField_validators, "f").length; i < l; i++) {
+            const fieldErrors = __classPrivateFieldGet(this, _PageField_validators, "f")[i].validate(value, context).map(e => e.withContext(Object.assign(Object.assign({}, context), { validator: __classPrivateFieldGet(this, _PageField_validators, "f")[i].name })));
+            errors = [
+                ...errors,
+                ...(fieldErrors !== null && fieldErrors !== void 0 ? fieldErrors : []),
+            ];
+        }
+        return errors;
+    }
+    // Apply all the processors to the given value
+    applyProcessors(value) {
+        let processedValue = value;
+        // Some of the validators may have their own "sanitise()" methods. These
+        // should be run before any other processors
+        for (let i = 0, l = __classPrivateFieldGet(this, _PageField_validators, "f").length; i < l; i++) {
+            if (isFunction(__classPrivateFieldGet(this, _PageField_validators, "f")[i].sanitise)) {
+                processedValue = __classPrivateFieldGet(this, _PageField_validators, "f")[i].sanitise(processedValue);
+            }
+        }
+        for (let i = 0, l = __classPrivateFieldGet(this, _PageField_processors, "f").length; i < l; i++) {
+            processedValue = __classPrivateFieldGet(this, _PageField_processors, "f")[i](processedValue);
+        }
+        return processedValue;
+    }
+    /**
+     * Apply all conditions to get the resulting boolean
+     *
+     * @param {Object} params Parameters
+     * @param {string} fieldValue Field value
+     * @param {string} waypoint Waypoint
+     * @param {object} journeyContext JourneyContext
+     * @returns {boolean}
+     */
+    testConditions({ fieldValue, waypoint, journeyContext }) {
+        const context = {
+            fieldName: __classPrivateFieldGet(this, _PageField_name, "f"),
+            fieldValue,
+            waypoint,
+            waypointId: waypoint,
+            journeyContext,
+        };
+        let result = true;
+        for (let i = 0, l = __classPrivateFieldGet(this, _PageField_conditions, "f").length; i < l; i++) {
+            result = result && __classPrivateFieldGet(this, _PageField_conditions, "f")[i](context);
+        }
+        return result;
+    }
+    /* ---------------------------------------------------------------- aliases */
+    validator(...args) {
+        return this.validators(...args);
+    }
+    processor(...args) {
+        return this.processors(...args);
+    }
+    condition(...args) {
+        return this.conditions(...args);
+    }
+    if(...args) {
+        return this.conditions(...args);
+    }
+}
+exports.PageField = PageField;
+_PageField_name = new WeakMap(), _PageField_processors = new WeakMap(), _PageField_validators = new WeakMap(), _PageField_conditions = new WeakMap(), _PageField_meta = new WeakMap();

package/dist/lib/logger.d.ts

@@ -0,0 +1,8 @@
+export default function _default(ns: any): {
+    trace: any;
+    debug: any;
+    info: any;
+    warn: any;
+    error: any;
+    fatal: any;
+};

package/dist/lib/logger.js

@@ -0,0 +1,19 @@
+"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');
+function default_1(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'),
+    };
+}
+exports.default = default_1;

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,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 = __importStar(require("deepmerge"));
+const luxon_1 = require("luxon");
+const nunjucks_1 = __importDefault(require("nunjucks"));
+// 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 (0, deepmerge_1.all)([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,22 @@
+/**
+ * @typedef {Object} NunjucksOptions
+ * @property {string} [mountUrl=/] Mount URL. This i made available as a `casa.mountUrl` template variable (optional, default /)
+ * @property {string[]} [views=[]] List of directories to look for template files (optional, default [])
+ */
+/**
+ * Create a Nunjucks environment.
+ *
+ * @param {NunjucksOptions} options Nunjucks options
+ * @returns {nunjucks.Environment} Nunjucks Environment instance
+ */
+export default function _default({ mountUrl, views, }: NunjucksOptions): any;
+export type NunjucksOptions = {
+    /**
+     * )
+     */
+    mountUrl?: string | undefined;
+    /**
+     * List of directories to look for template files (optional, default [])
+     */
+    views?: string[] | undefined;
+};

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. This i made available as a `casa.mountUrl` template variable (optional, default /)
+ * @property {string[]} [views=[]] List of directories to look for template files (optional, default [])
+ */
+/**
+ * Create a Nunjucks environment.
+ *
+ * @param {NunjucksOptions} options Nunjucks options
+ * @returns {nunjucks.Environment} Nunjucks Environment instance
+ */
+function default_1({ 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 = default_1;

package/dist/lib/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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;

package/dist/lib/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = exports.stringifyInput = exports.isStringable = void 0;
+/**
+ * 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;

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 ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const utils_js_1 = require("../utils.js");
+const lodash_1 = __importDefault(require("lodash"));
+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;