@dwp/govuk-casa 7.0.6 → 8.0.0-beta1

package/dist/lib/validators/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dateObject_js_1 = __importDefault(require("./dateObject.js"));
+const email_js_1 = __importDefault(require("./email.js"));
+const inArray_js_1 = __importDefault(require("./inArray.js"));
+const nino_js_1 = __importDefault(require("./nino.js"));
+const postalAddressObject_js_1 = __importDefault(require("./postalAddressObject.js"));
+const regex_js_1 = __importDefault(require("./regex.js"));
+const required_js_1 = __importDefault(require("./required.js"));
+const strlen_js_1 = __importDefault(require("./strlen.js"));
+const wordCount_js_1 = __importDefault(require("./wordCount.js"));
+exports.default = {
+    dateObject: dateObject_js_1.default,
+    email: email_js_1.default,
+    inArray: inArray_js_1.default,
+    nino: nino_js_1.default,
+    postalAddressObject: postalAddressObject_js_1.default,
+    regex: regex_js_1.default,
+    required: required_js_1.default,
+    strlen: strlen_js_1.default,
+    wordCount: wordCount_js_1.default,
+};
+// const dateObject = require('./dateObject.js');
+// const email = require('./email.js');
+// const inArray = require('./inArray.js');
+// const nino = require('./nino.js');
+// const optional = require('./optional.js');
+// const postalAddressObject = require('./postalAddressObject.js');
+// const regex = require('./regex.js');
+// const required = require('./required.js');
+// const strlen = require('./strlen.js');
+// const wordCount = require('./wordCount.js');
+// module.exports = {
+//   dateObject,
+//   email,
+//   inArray,
+//   nino,
+//   optional,
+//   postalAddressObject,
+//   regex,
+//   required,
+//   strlen,
+//   wordCount,
+// };

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

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

package/dist/lib/validators/nino.js

@@ -0,0 +1,46 @@
+"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 */
+/**
+ * UK National Insurance number.
+ *
+ * Config options:
+ *   string|object errorMsg = Error message to use on validation failure
+ *   boolean allowWhitespace = will permit input values that contain spaces.
+ *
+ * Ref:
+ * https://en.wikipedia.org/wiki/National_Insurance_number#Format
+ * https://design-system.service.gov.uk/patterns/national-insurance-numbers/
+ */
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const utils_js_1 = require("../utils.js");
+class Nino extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'nino';
+    }
+    validate(value, dataContext = {}) {
+        const { allowWhitespace, errorMsg = {
+            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}`);
+        }
+        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_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        return undefined;
+    }
+}
+exports.default = Nino;

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

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

package/dist/lib/validators/postalAddressObject.js

@@ -0,0 +1,123 @@
+"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 */
+/**
+ * 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
+ * the "postcode" component would be associated with "address[postcode]".
+ *
+ * Config options:
+ *   string|object errorMsg = General error message for the entire address block
+ *   string|object errorMsgAddress1 = Error message for address1 part
+ *   string|object errorMsgAddress2 = Error message for address2 part
+ *   string|object errorMsgAddress3 = Error message for address3 part
+ *   string|object errorMsgAddress4 = Error message for address4 part
+ *   string|object errorMsgPostcode = Error message for postcode part
+ *   int strlenmax = Max. String length for each of the inputs appress[1-4]
+ *   array requiredFields = Field parts required (others become optional)
+ */
+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; // CommonjS
+class PostalAddressObject extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'postalAddressObject';
+    }
+    validate(value, dataContext = {}) {
+        const cfg = Object.assign({ requiredFields: ['address1', 'address3', 'postcode'], strlenmax: undefined, errorMsgAddress1: {
+                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]',
+            }, errorMsgAddress3: {
+                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]',
+            }, errorMsgPostcode: {
+                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]',
+            } }, this.config);
+        /* eslint-disable-next-line require-jsdoc */
+        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) => {
+            reqF[k] = reqC.indexOf(k) > -1;
+        });
+        let valid = true;
+        const errorMsgs = [];
+        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 pc = /^(?![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 = new RegExp(pc, 'i');
+            // [required, regex, strlenmax, error message]
+            const attributes = {
+                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],
+                postcode: [reqF.postcode, rePostcode, null, cfg.errorMsgPostcode],
+            };
+            Object.keys(attributes).forEach((k) => {
+                const attr = attributes[k];
+                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];
+                if (condMissingOrRegexMismatch || condExceedStrlen) {
+                    valid = false;
+                    errorMsgs.push(Object.assign(Object.create(null), objectifyError(attr[3]), {
+                        fieldKeySuffix: `[${k}]`,
+                    }));
+                }
+            });
+        }
+        else {
+            valid = false;
+            errorMsgs.push(cfg.errorMsg);
+        }
+        // Build ValidationErrorGroup
+        const errorGroup = errorMsgs.map((err) => (ValidationError_js_1.default.make({ errorMsg: err, dataContext })));
+        return valid ? [] : [...errorGroup];
+    }
+    sanitise(value) {
+        // Only objects are supported
+        if (!isPlainObject(value)) {
+            return Object.create(null);
+        }
+        // Prune unrecognised attributes, and coerce to Strings
+        const validKeys = ['address1', 'address2', 'address3', 'address4', 'postcode'];
+        const pruned = Object.fromEntries(Object.entries(value).filter(([k]) => (validKeys.includes(k))).map(([k, v]) => ([k, (0, utils_js_1.stringifyInput)(v)])));
+        return Object.assign(Object.create(null), pruned);
+    }
+}
+exports.default = PostalAddressObject;

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

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

package/dist/lib/validators/regex.js

@@ -0,0 +1,40 @@
+"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 */
+/**
+ * Match a string pattern.
+ *
+ * Config options:
+ *   string|object errorMsg = Error message to use on validation failure
+ *   RegExp pattern = Regular expression to test against
+ *   boolean invert = return reject on positive regex match
+ */
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const utils_js_1 = require("../utils.js");
+class Regex extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'regex';
+    }
+    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',
+        };
+        return valid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        return undefined;
+    }
+}
+exports.default = Regex;

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

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

package/dist/lib/validators/required.js

@@ -0,0 +1,56 @@
+"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 is value is present.
+ *
+ * Value is required. The following values will fail this rule:
+ *  (all values that satisify `isEmpty()`) plus '\s'
+ */
+const lodash_1 = __importDefault(require("lodash"));
+const utils_js_1 = require("../utils.js");
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const { isPlainObject } = lodash_1.default; // CommonJS
+class Required extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'required';
+    }
+    validate(value, dataContext = {}) {
+        const { errorMsg = {
+            inline: 'validation:rule.required.inline',
+            summary: 'validation:rule.required.summary',
+        }, } = this.config;
+        if (!(0, utils_js_1.isEmpty)(value)) {
+            return [];
+        }
+        return [
+            ValidationError_js_1.default.make({ errorMsg, dataContext }),
+        ];
+    }
+    sanitise(value) {
+        const coerce = (val) => {
+            const s = (0, utils_js_1.stringifyInput)(val, undefined);
+            return s === undefined ? undefined : s.replace(/^\s+$/, '');
+        };
+        if ((0, utils_js_1.isStringable)(value)) {
+            return coerce(value);
+        }
+        // Coerce all elements to Strings.
+        // This only supports one dimensional array, with stringable element.
+        if (Array.isArray(value)) {
+            return value.map(coerce);
+        }
+        // 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 undefined;
+    }
+}
+exports.default = Required;

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

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

package/dist/lib/validators/strlen.js

@@ -0,0 +1,51 @@
+"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 the length of a string.
+ *
+ * Config options:
+ *   string|object errorMsgMax = Error message to use on max length failure
+ *   string|object errorMsgMin = Error message to use on min length failure
+ *   int max = Maximum string length allowed
+ *   int min = Minimum string length required
+ */
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const utils_js_1 = require("../utils.js");
+class Strlen extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'strlen';
+    }
+    validate(inputValue = '', dataContext = {}) {
+        const { errorMsgMax = {
+            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',
+        }, min, max, } = this.config;
+        let errorMsg;
+        let valid = true;
+        if (typeof max !== 'undefined' && inputValue.length > max) {
+            valid = false;
+            errorMsg = errorMsgMax;
+        }
+        if (typeof min !== 'undefined' && inputValue.length < min) {
+            valid = false;
+            errorMsg = errorMsgMin;
+        }
+        return valid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        return undefined;
+    }
+}
+exports.default = Strlen;

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

@@ -0,0 +1,5 @@
+export default class WordCount extends ValidatorFactory {
+    name: string;
+    count(input: any): any;
+}
+import ValidatorFactory from "../ValidatorFactory.js";

package/dist/lib/validators/wordCount.js

@@ -0,0 +1,54 @@
+"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 the number of words in a string.
+ *
+ * Config options:
+ *   string|object errorMsgMax = Error message to use on max length failure
+ *   string|object errorMsgMin = Error message to use on min length failure
+ *   int max = Maximum word count allowed
+ *   int min = Minimum word count required
+ */
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const utils_js_1 = require("../utils.js");
+class WordCount extends ValidatorFactory_js_1.default {
+    constructor() {
+        super(...arguments);
+        this.name = 'wordCount';
+    }
+    count(input) {
+        return (input.match(/\S+/g) || []).length;
+    }
+    validate(inputValue = '', dataContext = {}) {
+        const { errorMsgMax = {
+            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',
+        }, min, max, } = this.config;
+        let errorMsg;
+        let valid = true;
+        if (typeof max !== 'undefined' && (inputValue.match(/\S+/g) || []).length > max) {
+            valid = false;
+            errorMsg = errorMsgMax;
+        }
+        if (typeof min !== 'undefined' && (inputValue.match(/\S+/g) || []).length < min) {
+            valid = false;
+            errorMsg = errorMsgMin;
+        }
+        return valid ? [] : [ValidationError_js_1.default.make({ errorMsg, dataContext })];
+    }
+    sanitise(value) {
+        if (value !== undefined) {
+            return (0, utils_js_1.stringifyInput)(value);
+        }
+        return undefined;
+    }
+}
+exports.default = WordCount;

package/dist/lib/waypoint-url.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generate a URL pointing at a particular waypoint.
+ *
+ * @param {object} obj Options
+ * @param {string} obj.waypoint Waypoint
+ * @param {string} obj.mountUrl Mount URL
+ * @param {JourneyContext} obj.journeyContext JourneyContext
+ * @param {boolean} obj.edit Turn edit mode on or off
+ * @param {string} obj.editOrigin Edit mode original URL
+ * @param {boolean} obj.skipTo Skip to this waypoint from the current one
+ * @param {string} obj.routeName Plan route name; next | prev
+ * @returns {string} URL
+ */
+export default function waypointUrl({ waypoint, mountUrl, journeyContext, edit, editOrigin, skipTo, routeName, }?: {
+    waypoint: string;
+    mountUrl: string;
+    journeyContext: JourneyContext;
+    edit: boolean;
+    editOrigin: string;
+    skipTo: boolean;
+    routeName: string;
+}): string;
+export type JourneyContext = import('./index').JourneyContext;

package/dist/lib/waypoint-url.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * @typedef {import('./index').JourneyContext} JourneyContext
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const reUrlProtocolExtract = /^url:\/\/(.+)$/i;
+const sanitiseWaypoint = (w) => w.replace(/[^/a-z0-9_-]/ig, '').replace(/\/+/g, '/');
+/**
+ * Generate a URL pointing at a particular waypoint.
+ *
+ * @param {object} obj Options
+ * @param {string} obj.waypoint Waypoint
+ * @param {string} obj.mountUrl Mount URL
+ * @param {JourneyContext} obj.journeyContext JourneyContext
+ * @param {boolean} obj.edit Turn edit mode on or off
+ * @param {string} obj.editOrigin Edit mode original URL
+ * @param {boolean} obj.skipTo Skip to this waypoint from the current one
+ * @param {string} obj.routeName Plan route name; next | prev
+ * @returns {string} URL
+ */
+function waypointUrl({ waypoint = '', mountUrl = '/', journeyContext, edit = false, editOrigin, skipTo, routeName = 'next', } = Object.create(null)) {
+    const url = new URL('https://placeholder.test');
+    // Handle url:// protocol
+    // - This will generate a link to the root handler "_" for the given mount path
+    if (String(waypoint).substr(0, 7) === 'url:///') {
+        const m = waypoint.match(reUrlProtocolExtract);
+        const u = new URL(m[1], 'https://placeholder.test/');
+        url.pathname = `${sanitiseWaypoint(u.pathname)}/_/`;
+        url.searchParams.append('refmount', `url://${mountUrl}`);
+        url.searchParams.append('route', routeName);
+    }
+    else {
+        url.pathname = `${mountUrl}${waypoint}`;
+    }
+    // Attach context id for non-default contexts
+    if (journeyContext && !journeyContext.isDefault() && journeyContext.identity.id) {
+        url.searchParams.append('contextid', journeyContext.identity.id);
+    }
+    // Attach edit mode flag
+    if (edit === true) {
+        url.searchParams.append('edit', 'true');
+    }
+    if (edit && editOrigin) {
+        url.searchParams.append('editorigin', sanitiseWaypoint(editOrigin));
+    }
+    // Skipto
+    if (skipTo) {
+        url.searchParams.append('skipto', sanitiseWaypoint(skipTo));
+    }
+    return `${sanitiseWaypoint(url.pathname)}${url.search}`;
+}
+exports.default = waypointUrl;

package/dist/middleware/body-parser.d.ts

@@ -0,0 +1 @@
+export default function bodyParserMiddleware(): import("connect").NextHandleFunction[];

package/dist/middleware/body-parser.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+function bodyParserMiddleware() {
+    const rProto = /__proto__/i;
+    const rPrototype = /prototype[='"[\]]/i;
+    const rConstructor = /constructor[='"[\]]/i;
+    return [
+        (0, express_1.urlencoded)({
+            extended: true,
+            type: 'application/x-www-form-urlencoded',
+            inflate: true,
+            parameterLimit: 25,
+            limit: 1024 * 50,
+            verify: (req, res, buf, encoding) => {
+                const body = decodeURI(buf.toString(encoding));
+                if (rProto.test(body) || rPrototype.test(body) || rConstructor.test(body)) {
+                    throw new Error('Request body verification failed');
+                }
+            },
+        }),
+    ];
+}
+exports.default = bodyParserMiddleware;

package/dist/middleware/csrf.d.ts

@@ -0,0 +1 @@
+export default function csrfMiddleware(): any[];

package/dist/middleware/csrf.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const csurf_1 = __importDefault(require("csurf"));
+// 2 middleware: one to generate the csrf token and check its validity (POST
+// only), and one to provide that token to templates via the `casa.csrfToken`
+// variable.
+function csrfMiddleware() {
+    return [
+        (0, csurf_1.default)({
+            cookie: false,
+            sessionKey: 'session',
+            // value: (req) => {
+            //   // Here we clear the token after extracting to maintain cleaner data. It
+            //   // is only used for this CSRF purpose.
+            //   const token = String(req.body._csrf);
+            //   delete req.body._csrf;
+            //   return token;
+            //   /* eslint-enable no-underscore-dangle */
+            // },
+        }),
+        (req, res, next) => {
+            var _a;
+            res.locals.casa = Object.assign(Object.assign({}, (_a = res.locals) === null || _a === void 0 ? void 0 : _a.casa), { csrfToken: req.csrfToken() });
+            next();
+        },
+    ];
+}
+exports.default = csrfMiddleware;

package/dist/middleware/data.d.ts

@@ -0,0 +1,5 @@
+export default function dataMiddleware({ plan, mountUrl, events, }: {
+    plan: any;
+    mountUrl: any;
+    events: any;
+}): ((req: any, res: any, next: any) => void)[];

package/dist/middleware/data.js

@@ -0,0 +1,53 @@
+"use strict";
+// Decorates the request with some contextual data about the user's journey
+// through the application. This is used by downstream middleware and templates.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const JourneyContext_js_1 = __importDefault(require("../lib/JourneyContext.js"));
+const waypoint_url_js_1 = __importDefault(require("../lib/waypoint-url.js"));
+const { has } = lodash_1.default;
+const editOrigin = (req) => {
+    if (has(req.query, 'editorigin')) {
+        return (0, waypoint_url_js_1.default)({ waypoint: req.query.editorigin });
+    }
+    if (has(req === null || req === void 0 ? void 0 : req.body, 'editorigin')) {
+        return (0, waypoint_url_js_1.default)({ waypoint: req.body.editorigin });
+    }
+    return '';
+};
+function dataMiddleware({ plan, mountUrl, events, }) {
+    return [
+        (req, res, next) => {
+            /* ------------------------------------------------ Request decorations */
+            // CASA
+            req.casa = Object.assign(Object.assign({}, req === null || req === void 0 ? void 0 : req.casa), { 
+                // The plan
+                plan, 
+                // Current journey context, loaded from session, specified by
+                // `contextid` request parameter
+                journeyContext: JourneyContext_js_1.default.extractContextFromRequest(req).addEventListeners(events), 
+                // Edit mode
+                editMode: (has(req === null || req === void 0 ? void 0 : req.query, 'edit') && has(req === null || req === void 0 ? void 0 : req.query, 'editorigin')) || (has(req === null || req === void 0 ? void 0 : req.body, 'edit') && has(req === null || req === void 0 ? void 0 : req.body, 'editorigin')), editOrigin: editOrigin(req) });
+            // Grab chosen language from session
+            req.casa.journeyContext.nav.language = req.session.language;
+            /* ------------------------------------------------- Template variables */
+            // CASA and userland templates
+            res.locals.casa = {
+                mountUrl,
+            };
+            res.locals.locale = req.language;
+            // Used by govuk-frontend template
+            // - req.language is provided by i18n-http-middleware
+            res.locals.htmlLang = req.language;
+            // Function for building URLs. This will be curried with the `mountUrl`
+            // and `journeyContext` for convenience
+            res.locals.waypointUrl = (args) => (0, waypoint_url_js_1.default)(Object.assign({ mountUrl, journeyContext: req.casa.journeyContext }, args));
+            // req.editSearchParams
+            next();
+        },
+    ];
+}
+exports.default = dataMiddleware;