hein 1.4.2 → 2.0.0-alpha.0

package/dist/index.js

@@ -1,29 +1,575 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+import { any, assert_exports, createEvaluation, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws } from "./assert-kFXp7i_B.js";
+import { AssertionError, AssertionError as AssertionError$1, format } from "hein-assertion-utils";
+import isPlainObject from "lodash/isPlainObject.js";
+import omit from "lodash/omit.js";
+import mapValues from "lodash/mapValues.js";
+
+//#region src/mixins.ts
+const mixins = {};
+const use = (plugins) => {
+	Object.assign(mixins, plugins);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fail = exports.AssertionError = exports.use = exports.any = exports.createEvaluation = exports.assert = void 0;
-__exportStar(require("./expect"), exports);
-exports.assert = require("./assert");
-var match_1 = require("./utils/match");
-Object.defineProperty(exports, "createEvaluation", { enumerable: true, get: function () { return match_1.createEvaluation; } });
-Object.defineProperty(exports, "any", { enumerable: true, get: function () { return match_1.any; } });
-var mixins_1 = require("./mixins");
-Object.defineProperty(exports, "use", { enumerable: true, get: function () { return mixins_1.use; } });
-var hein_assertion_utils_1 = require("hein-assertion-utils");
-Object.defineProperty(exports, "AssertionError", { enumerable: true, get: function () { return hein_assertion_utils_1.AssertionError; } });
-var fail_1 = require("./utils/fail");
-Object.defineProperty(exports, "fail", { enumerable: true, get: function () { return fail_1.fail; } });
+
+//#endregion
+//#region src/utils/chain.ts
+const registerProperty = (object, name, value) => {
+	Object.defineProperty(object, name, {
+		enumerable: true,
+		get() {
+			return value();
+		}
+	});
+	return object;
+};
+const registerMethod = (object, name, value) => {
+	Object.defineProperty(object, name, { value });
+	return object;
+};
+
+//#endregion
+//#region src/utils/get-size.ts
+const getSize = (value) => {
+	if (Array.isArray(value)) return value.length;
+	if (isPlainObject(value)) return Object.keys(value).length;
+	if (value instanceof Map) return value.size;
+	if (value instanceof Set) return value.size;
+	if (typeof value === "string") return value.length;
+	return 0;
+};
+
+//#endregion
+//#region src/expect/after.ts
+use({ after: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) notAfter(value, date);
+		else isAfter(value, date);
+	}
+} });
+
+//#endregion
+//#region src/expect/ballpark.ts
+use({ ballpark: {
+	type: "method",
+	value: ({ value, inverted }) => (ballpark, multiplier = .1) => {
+		if (inverted) notInBallpark(value, ballpark, multiplier);
+		else inBallpark(value, ballpark, multiplier);
+	}
+} });
+
+//#endregion
+//#region src/expect/before.ts
+use({ before: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) notBefore(value, date);
+		else isBefore(value, date);
+	}
+} });
+
+//#endregion
+//#region src/expect/between.ts
+use({ between: {
+	type: "method",
+	value: ({ value, inverted }) => (start, end, inclusive = true) => {
+		if (inverted) notBetween(value, start, end, { inclusive });
+		else isBetween(value, start, end, { inclusive });
+	}
+} });
+
+//#endregion
+//#region src/expect/empty.ts
+use({ empty: {
+	type: "method",
+	value: ({ value, inverted }) => (message) => {
+		if (inverted) notIsEmpty(value, message);
+		else isEmpty(value, message);
+	}
+} });
+
+//#endregion
+//#region src/expect/end-with.ts
+use({ endWith: {
+	type: "method",
+	value: ({ value, inverted }) => (end) => {
+		if (inverted) notEndsWith(value, end);
+		else endsWith(value, end);
+	}
+} });
+
+//#endregion
+//#region src/expect/eql.ts
+use({
+	partially: {
+		type: "property",
+		value: () => ({ partial: true })
+	},
+	eql: {
+		type: "method",
+		value: ({ value, inverted, partial }) => (other, message) => {
+			if (inverted) notDeepEqual(value, other, partial, message);
+			else deepEqual(value, other, partial, message);
+		}
+	}
+});
+
+//#endregion
+//#region src/expect/equal-shorthand.ts
+use(Object.fromEntries(Object.entries({
+	false: false,
+	true: true
+}).map(([key, expectValue]) => {
+	return [key, {
+		type: "method",
+		value: ({ inverted, value }) => () => {
+			if (inverted) {
+				const message = format("Expected {{= it.value }} to not be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				notEqual(value, expectValue, message);
+			} else {
+				const message = format("Expected {{= it.value }} to be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				equal(value, expectValue, message);
+			}
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/equal.ts
+use({
+	equal: {
+		type: "method",
+		value: ({ value, inverted, deep }) => (other, message) => {
+			if (deep) {
+				if (inverted) notDeepEqual(value, other, message);
+				else deepEqual(value, other, message);
+				return;
+			}
+			if (inverted) notEqual(value, other, message);
+			else equal(value, other, message);
+		}
+	},
+	eq: {
+		type: "alias",
+		value: "equal"
+	}
+});
+
+//#endregion
+//#region src/expect/excluding.ts
+use({ excluding: {
+	type: "method",
+	value: (state) => (...keys) => {
+		return expectChain({
+			...state,
+			value: omit(state.value, keys)
+		});
+	}
+} });
+
+//#endregion
+//#region src/expect/greater-than-equal.ts
+use({
+	greaterThanOrEqual: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) notGreaterThanEqual(value, other);
+			else greaterThanEqual(value, other);
+		}
+	},
+	gte: {
+		type: "alias",
+		value: "greaterThanOrEqual"
+	},
+	atLeast: {
+		type: "alias",
+		value: "greaterThanOrEqual"
+	}
+});
+
+//#endregion
+//#region src/expect/greater-than.ts
+use({
+	greaterThan: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) notGreaterThan(value, other);
+			else greaterThan(value, other);
+		}
+	},
+	gt: {
+		type: "alias",
+		value: "greaterThan"
+	},
+	above: {
+		type: "alias",
+		value: "greaterThan"
+	}
+});
+
+//#endregion
+//#region src/expect/has-property.ts
+use({ property: {
+	type: "method",
+	value: ({ value, inverted, deep }) => (...args) => {
+		if (deep) {
+			if (inverted) return deepNotHasProperty(value, ...args);
+			return deepHasProperty(value, ...args);
+		}
+		if (inverted) return notHasProperty(value, ...args);
+		return hasProperty(value, ...args);
+	}
+} });
+
+//#endregion
+//#region src/expect/include.ts
+use({
+	include: {
+		type: "method",
+		value: ({ value, inverted }) => (...elements) => {
+			if (inverted) notIncludes(value, ...elements);
+			else includes(value, ...elements);
+		}
+	},
+	contain: {
+		type: "alias",
+		value: "include"
+	}
+});
+
+//#endregion
+//#region src/expect/instance-of-shorthand.ts
+const constructors = [
+	Date,
+	Map,
+	Set,
+	WeakMap,
+	WeakSet
+];
+use(Object.fromEntries(constructors.map((constructor) => {
+	return [constructor.name, {
+		type: "method",
+		value: ({ inverted, value }) => () => {
+			if (inverted) notInstanceOf(value, constructor);
+			else instanceOf(value, constructor);
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/instance-of.ts
+use({ instanceOf: {
+	type: "method",
+	value: ({ value, inverted }) => (constructor) => {
+		if (inverted) notInstanceOf(value, constructor);
+		else instanceOf(value, constructor);
+	}
+} });
+
+//#endregion
+//#region src/expect/keys.ts
+use({ keys: {
+	type: "method",
+	value: ({ value, inverted }) => (keys) => {
+		if (inverted) notHasKeys(value, keys);
+		else hasKeys(value, keys);
+	}
+} });
+
+//#endregion
+//#region src/expect/length.ts
+use({
+	sizeOf: {
+		type: "alias",
+		value: "lengthOf"
+	},
+	lengthOf: {
+		type: "method",
+		value: ({ value, inverted }) => (length, message) => {
+			if (inverted) notHasSize(value, length, message);
+			else hasSize(value, length, message);
+		}
+	}
+});
+
+//#endregion
+//#region src/expect/less-than-equal.ts
+use({
+	lessThanOrEqual: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) notLessThanEqual(value, other);
+			else lessThanEqual(value, other);
+		}
+	},
+	lte: {
+		type: "alias",
+		value: "lessThanOrEqual"
+	},
+	atMost: {
+		type: "alias",
+		value: "lessThanOrEqual"
+	}
+});
+
+//#endregion
+//#region src/expect/less-than.ts
+use({
+	lessThan: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) notLessThan(value, other);
+			else lessThan(value, other);
+		}
+	},
+	lt: {
+		type: "alias",
+		value: "lessThan"
+	},
+	below: {
+		type: "alias",
+		value: "lessThan"
+	}
+});
+
+//#endregion
+//#region src/expect/match.ts
+use({ match: {
+	type: "method",
+	value: ({ value, inverted }) => (regex) => {
+		if (inverted) notMatch(value, regex);
+		else match(value, regex);
+	}
+} });
+
+//#endregion
+//#region src/expect/members.ts
+use({
+	members: {
+		type: "method",
+		value: ({ value, inverted, same, deep, ordered, partial }) => (other, message) => {
+			if (inverted) notHasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+			else hasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+		}
+	},
+	same: {
+		type: "property",
+		value: (state) => {
+			state.same = true;
+			return state;
+		}
+	},
+	ordered: {
+		type: "property",
+		value: (state) => {
+			state.ordered = true;
+			return state;
+		}
+	}
+});
+
+//#endregion
+//#region src/expect/reject.ts
+use({ reject: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? notRejects(value, ...args) : rejects(value, ...args);
+	}
+} });
+
+//#endregion
+//#region src/expect/round-to.ts
+use({ roundTo: {
+	type: "method",
+	value: ({ value, inverted }) => (target, decimal = 0) => {
+		if (inverted) notRoundTo(value, target, decimal);
+		else roundTo(value, target, decimal);
+	}
+} });
+
+//#endregion
+//#region src/expect/start-with.ts
+use({ startWith: {
+	type: "method",
+	value: ({ value, inverted }) => (start) => {
+		if (inverted) notStartsWith(value, start);
+		else startsWith(value, start);
+	}
+} });
+
+//#endregion
+//#region src/expect/throw.ts
+use({ throw: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? notThrows(value, ...args) : throws(value, ...args);
+	}
+} });
+
+//#endregion
+//#region src/expect/type-shorthand.ts
+use(Object.fromEntries([
+	"NaN",
+	"array",
+	"bigint",
+	"boolean",
+	"function",
+	"null",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+].map((type) => {
+	return [type, {
+		type: "method",
+		value: ({ value, inverted }) => () => {
+			if (inverted) notIsType(value, type);
+			else isType(value, type);
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/type.ts
+use({ type: {
+	type: "method",
+	value: ({ value, inverted }) => (type) => {
+		if (inverted) notIsType(value, type);
+		else isType(value, type);
+	}
+} });
+
+//#endregion
+//#region src/utils/fail.ts
+/**
+* Throw an AssertionError
+* @param {string} message - The message to pass to the AssertionError
+*/
+const fail = (message = "Fail") => {
+	throw new AssertionError$1(void 0, void 0, message);
+};
+
+//#endregion
+//#region src/expect.ts
+use({
+	to: {
+		type: "property",
+		value: () => null
+	},
+	be: {
+		type: "property",
+		value: () => null
+	},
+	a: {
+		type: "property",
+		value: () => null
+	},
+	an: {
+		type: "property",
+		value: () => null
+	},
+	and: {
+		type: "property",
+		value: ({ value, every,...rest }) => {
+			const values = mapValues(rest, () => {});
+			return {
+				value,
+				every,
+				...values
+			};
+		}
+	},
+	have: {
+		type: "property",
+		value: () => null
+	},
+	in: {
+		type: "property",
+		value: () => null
+	},
+	not: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			inverted: !state.inverted
+		})
+	},
+	of: {
+		type: "property",
+		value: () => null
+	},
+	length: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			getProperty: getSize
+		})
+	},
+	deep: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			deep: true
+		})
+	},
+	every: {
+		type: "property",
+		value: (state) => ({
+			...state,
+			every: true
+		})
+	}
+});
+const expectChain = (state) => {
+	const chain = {};
+	for (const [key, v] of Object.entries(mixins)) {
+		const definition = v.type === "alias" ? mixins[v.value] : v;
+		if (definition.type === "property") registerProperty(chain, key, () => {
+			const newState = definition.value(state);
+			return expectChain({
+				...state,
+				...newState
+			});
+		});
+		else if (definition.type === "method") registerMethod(chain, key, (...args) => {
+			if (state.getProperty) definition.value({
+				value: state.getProperty(state.value),
+				inverted: state.inverted
+			})(...args);
+			else if (state.every) for (const value of state.value) definition.value({
+				...state,
+				value
+			})(...args);
+			else {
+				const result = definition.value({ ...state })(...args);
+				if (result) return result;
+			}
+			return expectChain(state);
+		});
+	}
+	return chain;
+};
+const expect = ((actual) => {
+	return expectChain({ value: actual });
+});
+expect.fail = fail;
+
+//#endregion
+export { AssertionError, any, assert_exports as assert, createEvaluation, expect, expectChain, fail, use };
 //# sourceMappingURL=index.js.map