hein 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/index.cjs

@@ -1,596 +1,27 @@
-const require_assert = require('./assert-DZjgWjOw.cjs');
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_match = require('./utils/match.cjs');
+const require_assert = require('./assert.cjs');
+const require_mixins = require('./mixins.cjs');
+const require_fail = require('./utils/fail.cjs');
+const require_expect = require('./expect.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);
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
 
-//#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;
+exports.any = require_match.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
+exports.createEvaluation = require_match.createEvaluation;
+exports.expect = require_expect.expect;
+exports.expectChain = require_expect.expectChain;
+exports.fail = require_fail.fail;
+exports.use = require_mixins.use;

package/dist/index.d.cts

@@ -1,16 +1,9 @@
-import { assert_d_exports } from "./assert-ChQPKP5C.cjs";
-import { ErrorPredicate, ValueType } from "./throws-CYLYG7gu.cjs";
-import { Alias, Expect, Method, Property, State, fail, use } from "./expect.types-CHYPdbCW.cjs";
+import { ErrorPredicate } from "./utils/process-error.cjs";
+import { ValueType } from "./utils/get-type.cjs";
+import { assert_d_exports } from "./assert.cjs";
+import { fail } from "./utils/fail.cjs";
+import { Alias, Method, Property, State, use } from "./mixins.cjs";
+import { expect, expectChain } from "./expect.cjs";
+import { any, createEvaluation } from "./utils/match.cjs";
 import { AssertionError } from "hein-assertion-utils";
-
-//#region src/expect.d.ts
-
-declare const expectChain: <T>(state: State<T>) => any;
-declare const expect: Expect;
-//#endregion
-//#region src/utils/match.d.ts
-declare const createEvaluation: (callback: (value: any) => boolean) => any;
-declare const any: any;
-//#endregion
-export { type Alias, AssertionError, type ErrorPredicate, type Method, type Property, type State, type ValueType, any, assert_d_exports as assert, createEvaluation, expect, expectChain, fail, use };
-//# sourceMappingURL=index.d.cts.map
+export { type Alias, AssertionError, type ErrorPredicate, type Method, type Property, type State, type ValueType, any, assert_d_exports as assert, createEvaluation, expect, expectChain, fail, use };

package/dist/index.d.ts

@@ -1,16 +1,9 @@
-import { assert_d_exports } from "./assert-CsN7srt-.js";
-import { ErrorPredicate, ValueType } from "./throws-BlzO4xvg.js";
-import { Alias, Expect, Method, Property, State, fail, use } from "./expect.types-nBq4Rg8e.js";
+import { ErrorPredicate } from "./utils/process-error.js";
+import { ValueType } from "./utils/get-type.js";
+import { assert_d_exports } from "./assert.js";
+import { fail } from "./utils/fail.js";
+import { Alias, Method, Property, State, use } from "./mixins.js";
+import { expect, expectChain } from "./expect.js";
+import { any, createEvaluation } from "./utils/match.js";
 import { AssertionError } from "hein-assertion-utils";
-
-//#region src/expect.d.ts
-
-declare const expectChain: <T>(state: State<T>) => any;
-declare const expect: Expect;
-//#endregion
-//#region src/utils/match.d.ts
-declare const createEvaluation: (callback: (value: any) => boolean) => any;
-declare const any: any;
-//#endregion
-export { type Alias, AssertionError, type ErrorPredicate, type Method, type Property, type State, type ValueType, any, assert_d_exports as assert, createEvaluation, expect, expectChain, fail, use };
-//# sourceMappingURL=index.d.ts.map
+export { type Alias, AssertionError, type ErrorPredicate, type Method, type Property, type State, type ValueType, any, assert_d_exports as assert, createEvaluation, expect, expectChain, fail, use };