govuk_publishing_components 16.29.0 → 17.0.0

data/node_modules/type/test/date/ensure.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var assert     = require("chai").assert
+  , ensureDate = require("../../date/ensure");
+
+describe("date/ensure", function () {
+	it("Should return input value", function () {
+		var value = new Date();
+		assert.equal(ensureDate(value), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureDate(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not a date object"));
+		}
+	});
+});

data/node_modules/type/test/date/is.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var assert = require("chai").assert
+  , isDate = require("../../date/is");
+
+describe("date/is", function () {
+	it("Should return true on date", function () { assert.equal(isDate(new Date()), true); });
+	it("Should return false on invalid date", function () {
+		assert.equal(isDate(new Date("foo")), false);
+	});
+
+	it("Should return false on native date with no common API exposed", function () {
+		var value = new Date();
+		value.getFullYear = null;
+		assert.equal(isDate(value), false);
+	});
+	it("Should return false on Date.prototype", function () {
+		assert.equal(isDate(Date.prototype), false);
+	});
+	it("Should return false on time value", function () { assert.equal(isDate(12312313), false); });
+
+	it("Should return false on plain object", function () { assert.equal(isDate({}), false); });
+	it("Should return false on function", function () {
+		assert.equal(isDate(function () { return true; }), false);
+	});
+
+	it("Should return false on array", function () { assert.equal(isDate([]), false); });
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isDate(Object.create(null)), false);
+		});
+	}
+	it("Should return false on string", function () { assert.equal(isDate("foo"), false); });
+	it("Should return false on empty string", function () { assert.equal(isDate(""), false); });
+	it("Should return false on number", function () { assert.equal(isDate(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isDate(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isDate(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isDate(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isDate(null), false); });
+	it("Should return false on undefined", function () { assert.equal(isDate(void 0), false); });
+});

data/node_modules/type/test/error/ensure.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var assert      = require("chai").assert
+  , ensureError = require("../../error/ensure");
+
+describe("error/ensure", function () {
+	it("Should return input value", function () {
+		var value = new Error();
+		assert.equal(ensureError(value), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureError(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not an error object"));
+		}
+	});
+});

data/node_modules/type/test/error/is.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var assert  = require("chai").assert
+  , isError = require("../../error/is");
+
+describe("error/is", function () {
+	it("Should return true on error", function () { assert.equal(isError(new Error()), true); });
+
+	it("Should return false on native error with no common API exposed", function () {
+		var value = new Error();
+		value.message = null;
+		assert.equal(isError(value), false);
+	});
+	it("Should return false on Error.prototype", function () {
+		assert.equal(isError(Error.prototype), false);
+	});
+
+	it("Should return false on plain object", function () { assert.equal(isError({}), false); });
+	it("Should return false on function", function () {
+		assert.equal(isError(function () { return true; }), false);
+	});
+
+	it("Should return false on array", function () { assert.equal(isError([]), false); });
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isError(Object.create(null)), false);
+		});
+	}
+	it("Should return false on string", function () { assert.equal(isError("foo"), false); });
+	it("Should return false on empty string", function () { assert.equal(isError(""), false); });
+	it("Should return false on number", function () { assert.equal(isError(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isError(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isError(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isError(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isError(null), false); });
+	it("Should return false on undefined", function () { assert.equal(isError(void 0), false); });
+});

data/node_modules/type/test/finite/coerce.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var assert         = require("chai").assert
+  , coerceToFinite = require("../../finite/coerce");
+
+describe("finite/coerce", function () {
+	it("Should return input number", function () {
+		assert.equal(coerceToFinite(123.123), 123.123);
+	});
+	it("Should coerce string", function () { assert.equal(coerceToFinite("12"), 12); });
+	it("Should coerce booleans", function () { assert.equal(coerceToFinite(true), 1); });
+	it("Should coerce number objects", function () {
+		assert.equal(coerceToFinite(new Number(343)), 343);
+	});
+	it("Should coerce objects", function () {
+		assert.equal(coerceToFinite({ valueOf: function () { return 23; } }), 23);
+	});
+
+	it("Should reject infinite number", function () {
+		assert.equal(coerceToFinite(Infinity), null);
+	});
+	it("Should reject NaN", function () { assert.equal(coerceToFinite(NaN), null); });
+
+	if (typeof Object.create === "function") {
+		it("Should not coerce objects with no number representation", function () {
+			assert.equal(coerceToFinite(Object.create(null)), null);
+		});
+	}
+
+	it("Should not coerce null", function () { assert.equal(coerceToFinite(null), null); });
+	it("Should not coerce undefined", function () {
+		assert.equal(coerceToFinite(undefined), null);
+	});
+
+	if (typeof Symbol === "function") {
+		it("Should not coerce symbols", function () {
+			assert.equal(coerceToFinite(Symbol("foo")), null);
+		});
+	}
+});

data/node_modules/type/test/finite/ensure.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var assert       = require("chai").assert
+  , ensureFinite = require("../../finite/ensure");
+
+describe("finite/ensure", function () {
+	it("Should return coerced value", function () { assert.equal(ensureFinite("12.23"), 12.23); });
+	it("Should crash on no value", function () {
+		try {
+			ensureFinite(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert.equal(error.message, "null is not a finite number");
+		}
+	});
+});

data/node_modules/type/test/function/ensure.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var assert         = require("chai").assert
+  , ensureFunction = require("../../function/ensure");
+
+describe("function/ensure", function () {
+	it("Should return input value", function () {
+		var value = function () { return true; };
+		assert.equal(ensureFunction(value), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureFunction(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not a function"));
+		}
+	});
+});

data/node_modules/type/test/function/is.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var assert                   = require("chai").assert
+  , isFunction               = require("../../function/is")
+  , arrowFunctionIfSupported = require("../_lib/arrow-function-if-supported")
+  , classIfSupported         = require("../_lib/class-if-supported");
+
+describe("function/is", function () {
+	it("Should return true on function", function () {
+		assert.equal(isFunction(function () { return true; }), true);
+	});
+	if (arrowFunctionIfSupported) {
+		it("Should return true on arrow function", function () {
+			assert.equal(isFunction(arrowFunctionIfSupported), true);
+		});
+	}
+	if (classIfSupported) {
+		it("Should return true on class", function () {
+			assert.equal(isFunction(classIfSupported), true);
+		});
+	}
+	it("Should return false on reg-exp", function () { assert.equal(isFunction(/foo/), false); });
+
+	it("Should return false on plain object", function () { assert.equal(isFunction({}), false); });
+	it("Should return false on array", function () { assert.equal(isFunction([]), false); });
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isFunction(Object.create(null)), false);
+		});
+	}
+	it("Should return false on string", function () { assert.equal(isFunction("foo"), false); });
+	it("Should return false on empty string", function () { assert.equal(isFunction(""), false); });
+	it("Should return false on number", function () { assert.equal(isFunction(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isFunction(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isFunction(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isFunction(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isFunction(null), false); });
+	it("Should return false on undefined", function () {
+		assert.equal(isFunction(void 0), false);
+	});
+});

data/node_modules/type/test/integer/coerce.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var assert          = require("chai").assert
+  , coerceToInteger = require("../../integer/coerce");
+
+describe("integer/coerce", function () {
+	it("Should coerce float to integer", function () {
+		assert.equal(coerceToInteger(123.123), 123);
+		assert.equal(coerceToInteger(123.823), 123);
+		assert.equal(coerceToInteger(-123.123), -123);
+		assert.equal(coerceToInteger(-123.823), -123);
+	});
+	it("Should coerce string", function () { assert.equal(coerceToInteger("12.123"), 12); });
+	it("Should coerce booleans", function () { assert.equal(coerceToInteger(true), 1); });
+	it("Should coerce number objects", function () {
+		assert.equal(coerceToInteger(new Number(343)), 343);
+	});
+	it("Should coerce objects", function () {
+		assert.equal(coerceToInteger({ valueOf: function () { return 23; } }), 23);
+	});
+	it("Should coerce number beyond Number.MAX_SAFE_INTEGER", function () {
+		assert.equal(coerceToInteger(9007199254740992), 9007199254740992);
+	});
+	it("Should coerce number beyond Number.MIN_SAFE_INTEGER", function () {
+		assert.equal(coerceToInteger(-9007199254740992), -9007199254740992);
+	});
+
+	it("Should reject infinite number", function () {
+		assert.equal(coerceToInteger(Infinity), null);
+	});
+	it("Should reject NaN", function () { assert.equal(coerceToInteger(NaN), null); });
+
+	if (typeof Object.create === "function") {
+		it("Should not coerce objects with no number representation", function () {
+			assert.equal(coerceToInteger(Object.create(null)), null);
+		});
+	}
+
+	it("Should not coerce null", function () { assert.equal(coerceToInteger(null), null); });
+	it("Should not coerce undefined", function () {
+		assert.equal(coerceToInteger(undefined), null);
+	});
+
+	if (typeof Symbol === "function") {
+		it("Should not coerce symbols", function () {
+			assert.equal(coerceToInteger(Symbol("foo")), null);
+		});
+	}
+});

data/node_modules/type/test/integer/ensure.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var assert        = require("chai").assert
+  , ensureInteger = require("../../integer/ensure");
+
+describe("integer/ensure", function () {
+	it("Should return coerced value", function () { assert.equal(ensureInteger("12.23"), 12); });
+	it("Should crash on no value", function () {
+		try {
+			ensureInteger(null);
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert.equal(error.message, "null is not an integer");
+		}
+	});
+});

data/node_modules/type/test/iterable/ensure.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var assert         = require("chai").assert
+  , ensureIterable = require("../../iterable/ensure");
+
+describe("iterable/ensure", function () {
+	it("Should return input value", function () {
+		var value = [];
+		assert.equal(ensureIterable(value), value);
+	});
+	it("Should allow strings with allowString option", function () {
+		var value = "foo";
+		assert.equal(ensureIterable(value, { allowString: true }), value);
+	});
+	it("Should crash on invalid value", function () {
+		try {
+			ensureIterable("foo");
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert(error.message.includes("is not an iterable value"));
+		}
+	});
+});

data/node_modules/type/test/iterable/is.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var assert     = require("chai").assert
+  , isIterable = require("../../iterable/is");
+
+describe("iterable/is", function () {
+	it("Should return true on array", function () { assert.equal(isIterable([]), true); });
+	it("Should return true on arguments", function () {
+		assert.equal(isIterable((function () { return arguments; })()), true);
+	});
+	it("Should by default return false on string", function () {
+		assert.equal(isIterable("foo"), false);
+	});
+	it("Should accept strings if specified", function () {
+		assert.equal(isIterable("foo", { allowString: true }), true);
+	});
+
+	if (typeof Set === "function") {
+		it("Should return true on set", function () { assert.equal(isIterable(new Set()), true); });
+	}
+	if (typeof Map === "function") {
+		it("Should return true on set", function () { assert.equal(isIterable(new Map()), true); });
+	}
+
+	it("Should return false on plain object", function () { assert.equal(isIterable({}), false); });
+	it("Should return false on function", function () {
+		assert.equal(isIterable(function () { return true; }), false);
+	});
+
+	if (typeof Object.create === "function") {
+		it("Should return false on object with no prototype", function () {
+			assert.equal(isIterable(Object.create(null)), false);
+		});
+	}
+	it("Should return false on string", function () { assert.equal(isIterable("foo"), false); });
+	it("Should return false on empty string", function () { assert.equal(isIterable(""), false); });
+	it("Should return false on number", function () { assert.equal(isIterable(123), false); });
+	it("Should return false on NaN", function () { assert.equal(isIterable(NaN), false); });
+	it("Should return false on boolean", function () { assert.equal(isIterable(true), false); });
+	if (typeof Symbol === "function") {
+		it("Should return false on symbol", function () {
+			assert.equal(isIterable(Symbol("foo")), false);
+		});
+	}
+
+	it("Should return false on null", function () { assert.equal(isIterable(null), false); });
+	it("Should return false on undefined", function () {
+		assert.equal(isIterable(void 0), false);
+	});
+});

data/node_modules/type/test/lib/is-to-string-tag-supported.js

@@ -0,0 +1,10 @@
+"use strict";
+
+var assert                 = require("chai").assert
+  , isToStringTagSupported = require("../../lib/is-to-string-tag-supported");
+
+describe("lib/is-to-string-tag-supported", function () {
+	it("Should return boolean", function () {
+		assert(typeof isToStringTagSupported === "boolean");
+	});
+});

data/node_modules/type/test/lib/resolve-exception.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var assert          = require("chai").assert
+  , handleException = require("../../lib/resolve-exception");
+
+describe("lib/handle-exception", function () {
+	it("Should throw TypeError", function () {
+		try {
+			handleException(12, "Invalid value");
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.name, "TypeError");
+			assert.equal(error.message, "Invalid value");
+		}
+	});
+	it("Should resolve value in default message", function () {
+		try {
+			handleException(12, "%v is invalid", {});
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.message, "12 is invalid");
+		}
+	});
+	it("Should support optional values via inputOptions.isOptional", function () {
+		assert.equal(handleException(null, "%v is invalid", { isOptional: true }, null));
+	});
+	it("Should support optional values via inputOptions.default", function () {
+		// prettier-ignore
+		assert.equal(handleException(null, "%v is invalid", { "default": "bar" }), "bar");
+	});
+	it("Should support custome error message via inputOptions.errorMessage", function () {
+		try {
+			handleException(null, "%v is invalid", { errorMessage: "%v is not supported age" });
+			throw new Error("Unexpected");
+		} catch (error) {
+			assert.equal(error.message, "null is not supported age");
+		}
+	});
+});