@dwp/govuk-casa 7.0.6 → 8.0.0-alpha1

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

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 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; // 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 utils_js_1 = require("../utils.js");
+const ValidatorFactory_js_1 = __importDefault(require("../ValidatorFactory.js"));
+const ValidationError_js_1 = __importDefault(require("../ValidationError.js"));
+const lodash_1 = __importDefault(require("lodash"));
+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,17 @@
+/**
+ *
+ * @param {Object} obj
+ * @param {string} obj.waypoint
+ * @param {string} obj.mountUrl
+ * @param {JourneyContext} obj.journeyContext JourneyContext
+ * @param {boolean} obj.edit
+ * @param {string} obj.editOrigin
+ * @returns
+ */
+export default function waypointUrl({ waypoint, mountUrl, journeyContext, edit, editOrigin, skipTo, routeName, }?: {
+    waypoint: string;
+    mountUrl: string;
+    journeyContext: any;
+    edit: boolean;
+    editOrigin: string;
+}): string;

package/dist/lib/waypoint-url.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reUrlProtocolExtract = /^url:\/\/(.+)$/i;
+const sanitiseWaypoint = (w) => w.replace(/[^\/a-z0-9_-]/ig, '').replace(/\/+/g, '/');
+/**
+ *
+ * @param {Object} obj
+ * @param {string} obj.waypoint
+ * @param {string} obj.mountUrl
+ * @param {JourneyContext} obj.journeyContext JourneyContext
+ * @param {boolean} obj.edit
+ * @param {string} obj.editOrigin
+ * @returns
+ */
+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;