hein 1.4.2 → 2.0.0-alpha.0

package/dist/expect.types.d.cts

@@ -0,0 +1,3 @@
+import "./throws-D7JsW4NM.cjs";
+import { ArrayExpect, BigIntExpect, BooleanExpect, DateExpect, Expect, FunctionExpect, Loose, MapExpect, NumberExpect, ObjectExpect, PromiseExpect, State, StringExpect, SymbolExpect, ValueExpect } from "./expect.types-s8icgWp5.cjs";
+export { ArrayExpect, BigIntExpect, BooleanExpect, DateExpect, Expect, FunctionExpect, Loose, MapExpect, NumberExpect, ObjectExpect, PromiseExpect, State, StringExpect, SymbolExpect, ValueExpect };

package/dist/expect.types.d.ts

@@ -1,66 +1,3 @@
-import { ThrowsCallback } from './assert/throws';
-import type { fail } from './utils/fail';
-export { State } from './mixins';
-export interface ValueExpect<T> {
-    to: this;
-    be: this;
-    a: this;
-    an: this;
-    not: this;
-    and: this;
-    have: this;
-    in: this;
-    of: this;
-    /**
-     * Use deep equality for object checks
-     */
-    deep: this;
-}
-export interface ArrayExpect<T> extends ValueExpect<T>, ObjectExpect<T> {
-    length: NumberExpect<number> & this;
-    array(): this;
-}
-export interface BigIntExpect<T = bigint> extends NumberExpect<T> {
-}
-export interface BooleanExpect<T = boolean> extends ValueExpect<T> {
-}
-export interface DateExpect<T = Date> extends ValueExpect<T>, ObjectExpect<T> {
-}
-export interface FunctionExpect<T> extends ValueExpect<T> {
-}
-export interface NumberExpect<T = number> extends ValueExpect<T> {
-}
-export interface MapExpect<T> extends ValueExpect<T> {
-    size: NumberExpect<number>;
-}
-export interface ObjectExpect<T> extends ValueExpect<T> {
-    size: NumberExpect<number>;
-}
-export interface PromiseExpect<T> extends ValueExpect<T> {
-}
-export interface StringExpect<T = string> extends ValueExpect<T> {
-}
-export interface SymbolExpect<T> extends ValueExpect<T> {
-}
-declare const LooseSymbol: unique symbol;
-export interface Loose {
-    [LooseSymbol]: true;
-}
-type AllExpects<T> = ArrayExpect<T> & BigIntExpect<T> & BooleanExpect<T> & DateExpect<T> & FunctionExpect<T> & NumberExpect<T> & MapExpect<T> & ObjectExpect<T> & PromiseExpect<T> & StringExpect<T> & SymbolExpect<T> & ValueExpect<T>;
-export interface Expect {
-    <T extends Loose>(actual: T): AllExpects<T>;
-    <T extends ThrowsCallback>(actual: T): FunctionExpect<T>;
-    <T extends Promise<any>>(actual: T): PromiseExpect<T>;
-    <T extends any[]>(actual: T): ArrayExpect<T>;
-    <T extends Date>(actual: T): DateExpect<T>;
-    <T extends Map<any, any>>(actual: T): MapExpect<T>;
-    <T extends Record<string, any>>(actual: T): ObjectExpect<T>;
-    <T extends number>(actual: T): NumberExpect;
-    <T extends bigint>(actual: T): BigIntExpect;
-    <T extends boolean>(actual: T): BooleanExpect;
-    <T extends string>(actual: T): StringExpect;
-    <T extends symbol>(actual: T): SymbolExpect<T>;
-    <T>(actual: T): ValueExpect<T>;
-    fail: typeof fail;
-}
-//# sourceMappingURL=expect.types.d.ts.map
+import "./throws-BrCCeBBl.js";
+import { ArrayExpect, BigIntExpect, BooleanExpect, DateExpect, Expect, FunctionExpect, Loose, MapExpect, NumberExpect, ObjectExpect, PromiseExpect, State, StringExpect, SymbolExpect, ValueExpect } from "./expect.types-DPl6xY56.js";
+export { ArrayExpect, BigIntExpect, BooleanExpect, DateExpect, Expect, FunctionExpect, Loose, MapExpect, NumberExpect, ObjectExpect, PromiseExpect, State, StringExpect, SymbolExpect, ValueExpect };

package/dist/expect.types.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const LooseSymbol = Symbol();
-//# sourceMappingURL=expect.types.js.map
+export {  };

package/dist/index.cjs

@@ -0,0 +1,596 @@
+const require_assert = require('./assert-DZjgWjOw.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_assert.__toESM(hein_assertion_utils);
+let lodash_isPlainObject_js = require("lodash/isPlainObject.js");
+lodash_isPlainObject_js = require_assert.__toESM(lodash_isPlainObject_js);
+let lodash_omit_js = require("lodash/omit.js");
+lodash_omit_js = require_assert.__toESM(lodash_omit_js);
+let lodash_mapValues_js = require("lodash/mapValues.js");
+lodash_mapValues_js = require_assert.__toESM(lodash_mapValues_js);
+
+//#region src/mixins.ts
+const mixins = {};
+const use = (plugins) => {
+	Object.assign(mixins, plugins);
+};
+
+//#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 ((0, lodash_isPlainObject_js.default)(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) require_assert.notAfter(value, date);
+		else require_assert.isAfter(value, date);
+	}
+} });
+
+//#endregion
+//#region src/expect/ballpark.ts
+use({ ballpark: {
+	type: "method",
+	value: ({ value, inverted }) => (ballpark, multiplier = .1) => {
+		if (inverted) require_assert.notInBallpark(value, ballpark, multiplier);
+		else require_assert.inBallpark(value, ballpark, multiplier);
+	}
+} });
+
+//#endregion
+//#region src/expect/before.ts
+use({ before: {
+	type: "method",
+	value: ({ value, inverted }) => (date) => {
+		if (inverted) require_assert.notBefore(value, date);
+		else require_assert.isBefore(value, date);
+	}
+} });
+
+//#endregion
+//#region src/expect/between.ts
+use({ between: {
+	type: "method",
+	value: ({ value, inverted }) => (start, end, inclusive = true) => {
+		if (inverted) require_assert.notBetween(value, start, end, { inclusive });
+		else require_assert.isBetween(value, start, end, { inclusive });
+	}
+} });
+
+//#endregion
+//#region src/expect/empty.ts
+use({ empty: {
+	type: "method",
+	value: ({ value, inverted }) => (message) => {
+		if (inverted) require_assert.notIsEmpty(value, message);
+		else require_assert.isEmpty(value, message);
+	}
+} });
+
+//#endregion
+//#region src/expect/end-with.ts
+use({ endWith: {
+	type: "method",
+	value: ({ value, inverted }) => (end) => {
+		if (inverted) require_assert.notEndsWith(value, end);
+		else require_assert.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) require_assert.notDeepEqual(value, other, partial, message);
+			else require_assert.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 = (0, hein_assertion_utils.format)("Expected {{= it.value }} to not be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				require_assert.notEqual(value, expectValue, message);
+			} else {
+				const message = (0, hein_assertion_utils.format)("Expected {{= it.value }} to be {{= it.key }}", {
+					key,
+					value
+				}, true);
+				require_assert.equal(value, expectValue, message);
+			}
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/equal.ts
+use({
+	equal: {
+		type: "method",
+		value: ({ value, inverted, deep }) => (other, message) => {
+			if (deep) {
+				if (inverted) require_assert.notDeepEqual(value, other, message);
+				else require_assert.deepEqual(value, other, message);
+				return;
+			}
+			if (inverted) require_assert.notEqual(value, other, message);
+			else require_assert.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: (0, lodash_omit_js.default)(state.value, keys)
+		});
+	}
+} });
+
+//#endregion
+//#region src/expect/greater-than-equal.ts
+use({
+	greaterThanOrEqual: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) require_assert.notGreaterThanEqual(value, other);
+			else require_assert.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) require_assert.notGreaterThan(value, other);
+			else require_assert.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 require_assert.deepNotHasProperty(value, ...args);
+			return require_assert.deepHasProperty(value, ...args);
+		}
+		if (inverted) return require_assert.notHasProperty(value, ...args);
+		return require_assert.hasProperty(value, ...args);
+	}
+} });
+
+//#endregion
+//#region src/expect/include.ts
+use({
+	include: {
+		type: "method",
+		value: ({ value, inverted }) => (...elements) => {
+			if (inverted) require_assert.notIncludes(value, ...elements);
+			else require_assert.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) require_assert.notInstanceOf(value, constructor);
+			else require_assert.instanceOf(value, constructor);
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/instance-of.ts
+use({ instanceOf: {
+	type: "method",
+	value: ({ value, inverted }) => (constructor) => {
+		if (inverted) require_assert.notInstanceOf(value, constructor);
+		else require_assert.instanceOf(value, constructor);
+	}
+} });
+
+//#endregion
+//#region src/expect/keys.ts
+use({ keys: {
+	type: "method",
+	value: ({ value, inverted }) => (keys) => {
+		if (inverted) require_assert.notHasKeys(value, keys);
+		else require_assert.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) require_assert.notHasSize(value, length, message);
+			else require_assert.hasSize(value, length, message);
+		}
+	}
+});
+
+//#endregion
+//#region src/expect/less-than-equal.ts
+use({
+	lessThanOrEqual: {
+		type: "method",
+		value: ({ value, inverted }) => (other) => {
+			if (inverted) require_assert.notLessThanEqual(value, other);
+			else require_assert.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) require_assert.notLessThan(value, other);
+			else require_assert.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) require_assert.notMatch(value, regex);
+		else require_assert.match(value, regex);
+	}
+} });
+
+//#endregion
+//#region src/expect/members.ts
+use({
+	members: {
+		type: "method",
+		value: ({ value, inverted, same, deep, ordered, partial }) => (other, message) => {
+			if (inverted) require_assert.notHasMembers(value, other, {
+				deep,
+				same,
+				ordered,
+				partial
+			}, message);
+			else require_assert.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 ? require_assert.notRejects(value, ...args) : require_assert.rejects(value, ...args);
+	}
+} });
+
+//#endregion
+//#region src/expect/round-to.ts
+use({ roundTo: {
+	type: "method",
+	value: ({ value, inverted }) => (target, decimal = 0) => {
+		if (inverted) require_assert.notRoundTo(value, target, decimal);
+		else require_assert.roundTo(value, target, decimal);
+	}
+} });
+
+//#endregion
+//#region src/expect/start-with.ts
+use({ startWith: {
+	type: "method",
+	value: ({ value, inverted }) => (start) => {
+		if (inverted) require_assert.notStartsWith(value, start);
+		else require_assert.startsWith(value, start);
+	}
+} });
+
+//#endregion
+//#region src/expect/throw.ts
+use({ throw: {
+	type: "method",
+	value: ({ value, inverted }) => (...args) => {
+		return inverted ? require_assert.notThrows(value, ...args) : require_assert.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) require_assert.notIsType(value, type);
+			else require_assert.isType(value, type);
+		}
+	}];
+})));
+
+//#endregion
+//#region src/expect/type.ts
+use({ type: {
+	type: "method",
+	value: ({ value, inverted }) => (type) => {
+		if (inverted) require_assert.notIsType(value, type);
+		else require_assert.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 hein_assertion_utils.AssertionError(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 = (0, lodash_mapValues_js.default)(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
+Object.defineProperty(exports, 'AssertionError', {
+  enumerable: true,
+  get: function () {
+    return hein_assertion_utils.AssertionError;
+  }
+});
+exports.any = require_assert.any;
+Object.defineProperty(exports, 'assert', {
+  enumerable: true,
+  get: function () {
+    return require_assert.assert_exports;
+  }
+});
+exports.createEvaluation = require_assert.createEvaluation;
+exports.expect = expect;
+exports.expectChain = expectChain;
+exports.fail = fail;
+exports.use = use;
+//# sourceMappingURL=index.cjs.map