hein 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/assert/greater-than-equal.d.ts

@@ -0,0 +1,11 @@
+//#region src/assert/greater-than-equal.d.ts
+interface GreaterThanEqual {
+  /**
+   * check for >=
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const greaterThanEqual: GreaterThanEqual, notGreaterThanEqual: GreaterThanEqual;
+//#endregion
+export { greaterThanEqual, notGreaterThanEqual };
+//# sourceMappingURL=greater-than-equal.d.ts.map

package/dist/assert/greater-than-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than-equal.d.ts","names":[],"sources":["../../src/assert/greater-than-equal.ts"],"sourcesContent":[],"mappings":";UAGU,gBAAA;EAAA;;;aAIqC,MAAA,GAAA,MAAA,GAAd,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAAc,cAG/C,gBAH+C,EAG/B,gBAH+B,EAAA,mBAAA,EAGV,gBAHU"}

package/dist/assert/greater-than-equal.js

@@ -0,0 +1,29 @@
+import { validateNumericsAndDates } from "../utils/validate-numeric-and-dates.js";
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/greater-than-equal.ts
+const [greaterThanEqual, notGreaterThanEqual] = createAssertion({
+	messages: {
+		notGreaterThanEqual: "Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}"
+	},
+	test: (report) => (a, b, message) => {
+		validateNumericsAndDates(a, b);
+		if (a < b) return report({
+			status: "notok",
+			messageId: "notGreaterThanEqual",
+			actual: a,
+			expected: b,
+			message
+		});
+		return report({
+			status: "ok",
+			expected: a,
+			actual: b
+		});
+	}
+});
+
+//#endregion
+export { greaterThanEqual, notGreaterThanEqual };
+//# sourceMappingURL=greater-than-equal.js.map

package/dist/assert/greater-than-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than-equal.js","names":[],"sources":["../../src/assert/greater-than-equal.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { validateNumericsAndDates } from '../utils/validate-numeric-and-dates.js';\n\ninterface GreaterThanEqual {\n    /**\n     * check for >=\n     */\n    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;\n}\n\nexport const [greaterThanEqual, notGreaterThanEqual] = createAssertion({\n    messages: {\n        notGreaterThanEqual: 'Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be greater than or equal to {{= it.expected }}'\n    },\n    test:\n        (report): GreaterThanEqual =>\n        (a: any, b: any, message?: string) => {\n            validateNumericsAndDates(a, b);\n            if (a < b) {\n                return report({ status: 'notok', messageId: 'notGreaterThanEqual', actual: a, expected: b, message });\n            }\n            return report({ status: 'ok', expected: a, actual: b });\n        }\n});\n"],"mappings":";;;;AAUA,MAAa,CAAC,kBAAkB,uBAAuB,gBAAgB;CACnE,UAAU;EACN,qBAAqB;EACrB,KAAK;EACR;CACD,OACK,YACA,GAAQ,GAAQ,YAAqB;AAClC,2BAAyB,GAAG,EAAE;AAC9B,MAAI,IAAI,EACJ,QAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAuB,QAAQ;GAAG,UAAU;GAAG;GAAS,CAAC;AAEzG,SAAO,OAAO;GAAE,QAAQ;GAAM,UAAU;GAAG,QAAQ;GAAG,CAAC;;CAElE,CAAC"}

package/dist/assert/greater-than.cjs

@@ -0,0 +1,33 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_validate_numeric_and_dates = require('../utils/validate-numeric-and-dates.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/greater-than.ts
+const [greaterThan, notGreaterThan] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		smaller: "Expected {{= it.actual }} to be greater than {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be greater than {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		require_validate_numeric_and_dates.validateNumericsAndDates(actual, expected);
+		if (actual > expected) return report({
+			status: "ok",
+			messageId: "not",
+			expected,
+			actual
+		});
+		return report({
+			status: "notok",
+			messageId: "smaller",
+			actual,
+			expected,
+			noStringify: true
+		});
+	}
+});
+
+//#endregion
+exports.greaterThan = greaterThan;
+exports.notGreaterThan = notGreaterThan;
+//# sourceMappingURL=greater-than.cjs.map

package/dist/assert/greater-than.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.cjs","names":[],"sources":["../../src/assert/greater-than.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { validateNumericsAndDates } from '../utils/validate-numeric-and-dates.js';\n\ninterface GreaterThan {\n    /**\n     * check for >\n     */\n    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;\n}\n\nexport const [greaterThan, notGreaterThan] = createAssertion({\n    messages: {\n        smaller: 'Expected {{= it.actual }} to be greater than {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be greater than {{= it.expected }}'\n    },\n    test:\n        (report): GreaterThan =>\n        (actual: any, expected: any) => {\n            validateNumericsAndDates(actual, expected);\n            if (actual > expected) {\n                return report({ status: 'ok', messageId: 'not', expected, actual });\n            }\n            return report({ status: 'notok', messageId: 'smaller', actual, expected, noStringify: true });\n        }\n});\n"],"mappings":";;;;;;AAUA,MAAa,CAAC,aAAa,4DAAkC;CACzD,UAAU;EACN,SAAS;EACT,KAAK;EACR;CACD,OACK,YACA,QAAa,aAAkB;AAC5B,8DAAyB,QAAQ,SAAS;AAC1C,MAAI,SAAS,SACT,QAAO,OAAO;GAAE,QAAQ;GAAM,WAAW;GAAO;GAAU;GAAQ,CAAC;AAEvE,SAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAW;GAAQ;GAAU,aAAa;GAAM,CAAC;;CAExG,CAAC"}

package/dist/assert/greater-than.d.cts

@@ -0,0 +1,11 @@
+//#region src/assert/greater-than.d.ts
+interface GreaterThan {
+  /**
+   * check for >
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const greaterThan: GreaterThan, notGreaterThan: GreaterThan;
+//#endregion
+export { greaterThan, notGreaterThan };
+//# sourceMappingURL=greater-than.d.cts.map

package/dist/assert/greater-than.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.d.cts","names":[],"sources":["../../src/assert/greater-than.ts"],"sourcesContent":[],"mappings":";UAGU,WAAA;EAAA;;;aAIqC,MAAA,GAAA,MAAA,GAAd,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAAc,cAG/C,WAH+C,EAGpC,WAHoC,EAAA,cAAA,EAGpB,WAHoB"}

package/dist/assert/greater-than.d.ts

@@ -0,0 +1,11 @@
+//#region src/assert/greater-than.d.ts
+interface GreaterThan {
+  /**
+   * check for >
+   */
+  <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;
+}
+declare const greaterThan: GreaterThan, notGreaterThan: GreaterThan;
+//#endregion
+export { greaterThan, notGreaterThan };
+//# sourceMappingURL=greater-than.d.ts.map

package/dist/assert/greater-than.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.d.ts","names":[],"sources":["../../src/assert/greater-than.ts"],"sourcesContent":[],"mappings":";UAGU,WAAA;EAAA;;;aAIqC,MAAA,GAAA,MAAA,GAAd,IAAc,CAAA,CAAA,MAAA,EAAA,CAAA,EAAA,QAAA,EAAa,CAAb,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAAc,cAG/C,WAH+C,EAGpC,WAHoC,EAAA,cAAA,EAGpB,WAHoB"}

package/dist/assert/greater-than.js

@@ -0,0 +1,30 @@
+import { validateNumericsAndDates } from "../utils/validate-numeric-and-dates.js";
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/greater-than.ts
+const [greaterThan, notGreaterThan] = createAssertion({
+	messages: {
+		smaller: "Expected {{= it.actual }} to be greater than {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be greater than {{= it.expected }}"
+	},
+	test: (report) => (actual, expected) => {
+		validateNumericsAndDates(actual, expected);
+		if (actual > expected) return report({
+			status: "ok",
+			messageId: "not",
+			expected,
+			actual
+		});
+		return report({
+			status: "notok",
+			messageId: "smaller",
+			actual,
+			expected,
+			noStringify: true
+		});
+	}
+});
+
+//#endregion
+export { greaterThan, notGreaterThan };
+//# sourceMappingURL=greater-than.js.map

package/dist/assert/greater-than.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than.js","names":[],"sources":["../../src/assert/greater-than.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { validateNumericsAndDates } from '../utils/validate-numeric-and-dates.js';\n\ninterface GreaterThan {\n    /**\n     * check for >\n     */\n    <T extends number | bigint | Date>(actual: T, expected: T, message?: string): void;\n}\n\nexport const [greaterThan, notGreaterThan] = createAssertion({\n    messages: {\n        smaller: 'Expected {{= it.actual }} to be greater than {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not be greater than {{= it.expected }}'\n    },\n    test:\n        (report): GreaterThan =>\n        (actual: any, expected: any) => {\n            validateNumericsAndDates(actual, expected);\n            if (actual > expected) {\n                return report({ status: 'ok', messageId: 'not', expected, actual });\n            }\n            return report({ status: 'notok', messageId: 'smaller', actual, expected, noStringify: true });\n        }\n});\n"],"mappings":";;;;AAUA,MAAa,CAAC,aAAa,kBAAkB,gBAAgB;CACzD,UAAU;EACN,SAAS;EACT,KAAK;EACR;CACD,OACK,YACA,QAAa,aAAkB;AAC5B,2BAAyB,QAAQ,SAAS;AAC1C,MAAI,SAAS,SACT,QAAO,OAAO;GAAE,QAAQ;GAAM,WAAW;GAAO;GAAU;GAAQ,CAAC;AAEvE,SAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAW;GAAQ;GAAU,aAAa;GAAM,CAAC;;CAExG,CAAC"}

package/dist/assert/has-keys.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+let lodash_castArray_js = require("lodash/castArray.js");
+lodash_castArray_js = require_rolldown_runtime.__toESM(lodash_castArray_js);
+
+//#region src/assert/has-keys.ts
+const [hasKeys, notHasKeys] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		noKey: "Expected {{= it.object }} to have keys {{= it.expected }}",
+		not: "Expected {{= it.object }} to not have keys {{= it.expected }}"
+	},
+	test: (report) => (object, keys, message) => {
+		const keysArray = (0, lodash_castArray_js.default)(keys);
+		if (object instanceof Map) {
+			for (const key of keysArray) if (!object.has(key)) {
+				report({
+					status: "notok",
+					message,
+					messageId: "noKey",
+					data: { object },
+					actual: [...object.keys()],
+					expected: keysArray
+				});
+				return;
+			}
+			report({
+				status: "ok",
+				data: { object },
+				actual: [...object.keys()],
+				expected: keysArray
+			});
+			return;
+		}
+		for (const key of keysArray) if (!(key in object)) {
+			report({
+				status: "notok",
+				message,
+				messageId: "noKey",
+				data: { object },
+				actual: object,
+				expected: keysArray
+			});
+			return;
+		}
+		report({
+			status: "ok",
+			data: { object },
+			actual: Object.keys(object),
+			expected: keysArray
+		});
+	}
+});
+
+//#endregion
+exports.hasKeys = hasKeys;
+exports.notHasKeys = notHasKeys;
+//# sourceMappingURL=has-keys.cjs.map

package/dist/assert/has-keys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-keys.cjs","names":[],"sources":["../../src/assert/has-keys.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport castArray from 'lodash/castArray.js';\n\ninterface HasKeys {\n    /**\n     * check if object has keys\n     * @param object\n     * @param keys a key or array of keys in the object.\n     * @example hasKeys({a: 1}, 'a');\n     * @example hasKeys({a: 1, b: 2}, ['a', 'b']);\n     */\n    <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;\n    <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;\n}\n\nexport const [hasKeys, notHasKeys] = createAssertion({\n    messages: {\n        noKey: 'Expected {{= it.object }} to have keys {{= it.expected }}',\n        not: 'Expected {{= it.object }} to not have keys {{= it.expected }}'\n    },\n    test:\n        (report): HasKeys =>\n        (object, keys, message) => {\n            const keysArray = castArray(keys);\n            if (object instanceof Map) {\n                for (const key of keysArray) {\n                    if (!object.has(key)) {\n                        report({\n                            status: 'notok',\n                            message,\n                            messageId: 'noKey',\n                            data: { object },\n                            actual: [...object.keys()],\n                            expected: keysArray\n                        });\n                        return;\n                    }\n                }\n                report({ status: 'ok', data: { object }, actual: [...object.keys()], expected: keysArray });\n                return;\n            }\n            for (const key of keysArray) {\n                if (!(key in object)) {\n                    report({\n                        status: 'notok',\n                        message,\n                        messageId: 'noKey',\n                        data: { object },\n                        actual: object,\n                        expected: keysArray\n                    });\n                    return;\n                }\n            }\n            report({ status: 'ok', data: { object }, actual: Object.keys(object), expected: keysArray });\n        }\n});\n"],"mappings":";;;;;;;AAeA,MAAa,CAAC,SAAS,wDAA8B;CACjD,UAAU;EACN,OAAO;EACP,KAAK;EACR;CACD,OACK,YACA,QAAQ,MAAM,YAAY;EACvB,MAAM,6CAAsB,KAAK;AACjC,MAAI,kBAAkB,KAAK;AACvB,QAAK,MAAM,OAAO,UACd,KAAI,CAAC,OAAO,IAAI,IAAI,EAAE;AAClB,WAAO;KACH,QAAQ;KACR;KACA,WAAW;KACX,MAAM,EAAE,QAAQ;KAChB,QAAQ,CAAC,GAAG,OAAO,MAAM,CAAC;KAC1B,UAAU;KACb,CAAC;AACF;;AAGR,UAAO;IAAE,QAAQ;IAAM,MAAM,EAAE,QAAQ;IAAE,QAAQ,CAAC,GAAG,OAAO,MAAM,CAAC;IAAE,UAAU;IAAW,CAAC;AAC3F;;AAEJ,OAAK,MAAM,OAAO,UACd,KAAI,EAAE,OAAO,SAAS;AAClB,UAAO;IACH,QAAQ;IACR;IACA,WAAW;IACX,MAAM,EAAE,QAAQ;IAChB,QAAQ;IACR,UAAU;IACb,CAAC;AACF;;AAGR,SAAO;GAAE,QAAQ;GAAM,MAAM,EAAE,QAAQ;GAAE,QAAQ,OAAO,KAAK,OAAO;GAAE,UAAU;GAAW,CAAC;;CAEvG,CAAC"}

package/dist/assert/has-keys.d.cts

@@ -0,0 +1,16 @@
+//#region src/assert/has-keys.d.ts
+interface HasKeys {
+  /**
+   * check if object has keys
+   * @param object
+   * @param keys a key or array of keys in the object.
+   * @example hasKeys({a: 1}, 'a');
+   * @example hasKeys({a: 1, b: 2}, ['a', 'b']);
+   */
+  <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;
+  <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;
+}
+declare const hasKeys: HasKeys, notHasKeys: HasKeys;
+//#endregion
+export { hasKeys, notHasKeys };
+//# sourceMappingURL=has-keys.d.cts.map

package/dist/assert/has-keys.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-keys.d.cts","names":[],"sources":["../../src/assert/has-keys.ts"],"sourcesContent":[],"mappings":";UAGU,OAAA;EAAA;;;;;;;aAQK,MACO,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,UAAA,MAD8B,CAC9B,CAAA,CAAA,MAAA,EADyC,CACzC,EAAA,IAAA,EADkD,CAClD,EAAA,GADwD,CACxD,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;MAAJ,UAAA,GAAA,CAAI,CAAJ,EAAA,GAAA,CAAA,CAAA,CAAA,MAAA,EAAqB,CAArB,EAAA,IAAA,EAA8B,CAA9B,EAAA,GAAoC,CAApC,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAA8B,cAGlC,OAHkC,EAG3B,OAH2B,EAAA,UAAA,EAGf,OAHe"}

package/dist/assert/has-keys.d.ts

@@ -0,0 +1,16 @@
+//#region src/assert/has-keys.d.ts
+interface HasKeys {
+  /**
+   * check if object has keys
+   * @param object
+   * @param keys a key or array of keys in the object.
+   * @example hasKeys({a: 1}, 'a');
+   * @example hasKeys({a: 1, b: 2}, ['a', 'b']);
+   */
+  <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;
+  <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;
+}
+declare const hasKeys: HasKeys, notHasKeys: HasKeys;
+//#endregion
+export { hasKeys, notHasKeys };
+//# sourceMappingURL=has-keys.d.ts.map

package/dist/assert/has-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-keys.d.ts","names":[],"sources":["../../src/assert/has-keys.ts"],"sourcesContent":[],"mappings":";UAGU,OAAA;EAAA;;;;;;;aAQK,MACO,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,UAAA,MAD8B,CAC9B,CAAA,CAAA,MAAA,EADyC,CACzC,EAAA,IAAA,EADkD,CAClD,EAAA,GADwD,CACxD,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;MAAJ,UAAA,GAAA,CAAI,CAAJ,EAAA,GAAA,CAAA,CAAA,CAAA,MAAA,EAAqB,CAArB,EAAA,IAAA,EAA8B,CAA9B,EAAA,GAAoC,CAApC,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AAA8B,cAGlC,OAHkC,EAG3B,OAH2B,EAAA,UAAA,EAGf,OAHe"}

package/dist/assert/has-keys.js

@@ -0,0 +1,54 @@
+import { createAssertion } from "hein-assertion-utils";
+import castArray from "lodash/castArray.js";
+
+//#region src/assert/has-keys.ts
+const [hasKeys, notHasKeys] = createAssertion({
+	messages: {
+		noKey: "Expected {{= it.object }} to have keys {{= it.expected }}",
+		not: "Expected {{= it.object }} to not have keys {{= it.expected }}"
+	},
+	test: (report) => (object, keys, message) => {
+		const keysArray = castArray(keys);
+		if (object instanceof Map) {
+			for (const key of keysArray) if (!object.has(key)) {
+				report({
+					status: "notok",
+					message,
+					messageId: "noKey",
+					data: { object },
+					actual: [...object.keys()],
+					expected: keysArray
+				});
+				return;
+			}
+			report({
+				status: "ok",
+				data: { object },
+				actual: [...object.keys()],
+				expected: keysArray
+			});
+			return;
+		}
+		for (const key of keysArray) if (!(key in object)) {
+			report({
+				status: "notok",
+				message,
+				messageId: "noKey",
+				data: { object },
+				actual: object,
+				expected: keysArray
+			});
+			return;
+		}
+		report({
+			status: "ok",
+			data: { object },
+			actual: Object.keys(object),
+			expected: keysArray
+		});
+	}
+});
+
+//#endregion
+export { hasKeys, notHasKeys };
+//# sourceMappingURL=has-keys.js.map

package/dist/assert/has-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-keys.js","names":[],"sources":["../../src/assert/has-keys.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport castArray from 'lodash/castArray.js';\n\ninterface HasKeys {\n    /**\n     * check if object has keys\n     * @param object\n     * @param keys a key or array of keys in the object.\n     * @example hasKeys({a: 1}, 'a');\n     * @example hasKeys({a: 1, b: 2}, ['a', 'b']);\n     */\n    <T extends Record<string, any>, K extends keyof T>(object: T, keys: K[] | K, message?: string): void;\n    <K, T extends Map<K, any>>(object: T, keys: K[] | K, message?: string): void;\n}\n\nexport const [hasKeys, notHasKeys] = createAssertion({\n    messages: {\n        noKey: 'Expected {{= it.object }} to have keys {{= it.expected }}',\n        not: 'Expected {{= it.object }} to not have keys {{= it.expected }}'\n    },\n    test:\n        (report): HasKeys =>\n        (object, keys, message) => {\n            const keysArray = castArray(keys);\n            if (object instanceof Map) {\n                for (const key of keysArray) {\n                    if (!object.has(key)) {\n                        report({\n                            status: 'notok',\n                            message,\n                            messageId: 'noKey',\n                            data: { object },\n                            actual: [...object.keys()],\n                            expected: keysArray\n                        });\n                        return;\n                    }\n                }\n                report({ status: 'ok', data: { object }, actual: [...object.keys()], expected: keysArray });\n                return;\n            }\n            for (const key of keysArray) {\n                if (!(key in object)) {\n                    report({\n                        status: 'notok',\n                        message,\n                        messageId: 'noKey',\n                        data: { object },\n                        actual: object,\n                        expected: keysArray\n                    });\n                    return;\n                }\n            }\n            report({ status: 'ok', data: { object }, actual: Object.keys(object), expected: keysArray });\n        }\n});\n"],"mappings":";;;;AAeA,MAAa,CAAC,SAAS,cAAc,gBAAgB;CACjD,UAAU;EACN,OAAO;EACP,KAAK;EACR;CACD,OACK,YACA,QAAQ,MAAM,YAAY;EACvB,MAAM,YAAY,UAAU,KAAK;AACjC,MAAI,kBAAkB,KAAK;AACvB,QAAK,MAAM,OAAO,UACd,KAAI,CAAC,OAAO,IAAI,IAAI,EAAE;AAClB,WAAO;KACH,QAAQ;KACR;KACA,WAAW;KACX,MAAM,EAAE,QAAQ;KAChB,QAAQ,CAAC,GAAG,OAAO,MAAM,CAAC;KAC1B,UAAU;KACb,CAAC;AACF;;AAGR,UAAO;IAAE,QAAQ;IAAM,MAAM,EAAE,QAAQ;IAAE,QAAQ,CAAC,GAAG,OAAO,MAAM,CAAC;IAAE,UAAU;IAAW,CAAC;AAC3F;;AAEJ,OAAK,MAAM,OAAO,UACd,KAAI,EAAE,OAAO,SAAS;AAClB,UAAO;IACH,QAAQ;IACR;IACA,WAAW;IACX,MAAM,EAAE,QAAQ;IAChB,QAAQ;IACR,UAAU;IACb,CAAC;AACF;;AAGR,SAAO;GAAE,QAAQ;GAAM,MAAM,EAAE,QAAQ;GAAE,QAAQ,OAAO,KAAK,OAAO;GAAE,UAAU;GAAW,CAAC;;CAEvG,CAAC"}

package/dist/assert/has-members.cjs

@@ -0,0 +1,67 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_match = require('../utils/match.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/has-members.ts
+const [hasMembers, notHasMembers] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		hasMembers: "Expected {{= it.actual }} to have members {{= it.expected }}",
+		same: "Expected {{= it.actual }} to have same members as {{= it.expected }}",
+		order: "Expected {{= it.actual }} to have ordered members {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not have members {{= it.expected }}",
+		notSame: "Expected {{= it.actual }} to not have same members as {{= it.expected }}"
+	},
+	test: (report) => (actual, expected, { deep = false, partial = false, ordered = false, same = false } = {}, message) => {
+		let lastIndex = -1;
+		for (const item of expected) if (deep || partial) {
+			const actualIndex = actual.findIndex((actualItem, index) => {
+				if (!ordered) return require_match.match(actualItem, item, { partial });
+				if (lastIndex >= index) return false;
+				return require_match.match(actualItem, item, { partial });
+			});
+			lastIndex = actualIndex;
+			if (actualIndex === -1) return report({
+				status: "notok",
+				messageId: ordered ? "order" : "hasMembers",
+				actual,
+				expected,
+				message
+			});
+		} else if (actual.includes(item)) {
+			if (ordered && lastIndex >= actual.indexOf(item, lastIndex + 1)) return report({
+				status: "notok",
+				messageId: "order",
+				actual,
+				expected,
+				message
+			});
+			lastIndex = actual.indexOf(item, lastIndex + 1);
+		} else return report({
+			status: "notok",
+			messageId: "hasMembers",
+			actual,
+			expected,
+			message
+		});
+		if (same && actual.length !== expected.length) return report({
+			status: "notok",
+			messageId: "same",
+			actual,
+			expected,
+			message
+		});
+		return report({
+			status: "ok",
+			messageId: same ? "notSame" : "not",
+			actual,
+			expected,
+			message
+		});
+	}
+});
+
+//#endregion
+exports.hasMembers = hasMembers;
+exports.notHasMembers = notHasMembers;
+//# sourceMappingURL=has-members.cjs.map

package/dist/assert/has-members.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-members.cjs","names":["match"],"sources":["../../src/assert/has-members.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { match } from '../utils/match.js';\n\ninterface HasMembersOptions {\n    /**\n     * check for deep equality (ie {a: 1} === {a: 1})\n     * @default false\n     * @example\n     * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });\n     */\n    deep?: boolean;\n    /**\n     * use partial matching (ie {a: 1, b: 2} === {a: 1})\n     * implies deep\n     * @default false\n     * @example\n     * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });\n     */\n    partial?: boolean;\n    /**\n     * check that all the members in the first array are present in the second one\n     * @default false\n     * @example\n     * hasMembers([1, 2], [2, 1], { same: true });\n     * notHasMembers([1, 2], [1], { same: true});\n     */\n    same?: boolean;\n    /**\n     * check that the members in the first array are in the same order as the second one\n     * @default false\n     * @example\n     * hasMembers([1, 2], [1, 2], { ordered: true });\n     * notHasMembers([1, 2], [2, 1], { ordered: true });\n     */\n    ordered?: boolean;\n}\n\ninterface HasMembers {\n    /**\n     * check that the members in second array are present in the first one\n     * @example\n     * hasMembers([1], [1]);\n     * hasMembers([1, 2], [2, 1]);\n     * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });\n     */\n    <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;\n}\n\nexport const [hasMembers, notHasMembers] = createAssertion({\n    messages: {\n        hasMembers: 'Expected {{= it.actual }} to have members {{= it.expected }}',\n        same: 'Expected {{= it.actual }} to have same members as {{= it.expected }}',\n        order: 'Expected {{= it.actual }} to have ordered members {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not have members {{= it.expected }}',\n        notSame: 'Expected {{= it.actual }} to not have same members as {{= it.expected }}'\n    },\n    test:\n        (report): HasMembers =>\n        <T>(\n            actual: T[],\n            expected: T[],\n            { deep = false, partial = false, ordered = false, same = false }: HasMembersOptions = {},\n            message?: string\n        ) => {\n            let lastIndex = -1;\n            for (const item of expected) {\n                if (deep || partial) {\n                    const actualIndex = actual.findIndex((actualItem, index) => {\n                        if (!ordered) {\n                            return match(actualItem, item, { partial });\n                        }\n                        if (lastIndex >= index) {\n                            return false;\n                        }\n                        return match(actualItem, item, { partial });\n                    });\n                    lastIndex = actualIndex;\n                    if (actualIndex === -1) {\n                        return report({\n                            status: 'notok',\n                            messageId: ordered ? 'order' : 'hasMembers',\n                            actual,\n                            expected,\n                            message\n                        });\n                    }\n                } else {\n                    if (actual.includes(item)) {\n                        if (ordered && lastIndex >= actual.indexOf(item, lastIndex + 1)) {\n                            return report({ status: 'notok', messageId: 'order', actual, expected, message });\n                        }\n                        lastIndex = actual.indexOf(item, lastIndex + 1);\n                    } else {\n                        return report({ status: 'notok', messageId: 'hasMembers', actual, expected, message });\n                    }\n                }\n            }\n            if (same && actual.length !== expected.length) {\n                return report({ status: 'notok', messageId: 'same', actual, expected, message });\n            }\n            return report({ status: 'ok', messageId: same ? 'notSame' : 'not', actual, expected, message });\n        }\n});\n"],"mappings":";;;;;;AAgDA,MAAa,CAAC,YAAY,2DAAiC;CACvD,UAAU;EACN,YAAY;EACZ,MAAM;EACN,OAAO;EACP,KAAK;EACL,SAAS;EACZ;CACD,OACK,YAEG,QACA,UACA,EAAE,OAAO,OAAO,UAAU,OAAO,UAAU,OAAO,OAAO,UAA6B,EAAE,EACxF,YACC;EACD,IAAI,YAAY;AAChB,OAAK,MAAM,QAAQ,SACf,KAAI,QAAQ,SAAS;GACjB,MAAM,cAAc,OAAO,WAAW,YAAY,UAAU;AACxD,QAAI,CAAC,QACD,QAAOA,oBAAM,YAAY,MAAM,EAAE,SAAS,CAAC;AAE/C,QAAI,aAAa,MACb,QAAO;AAEX,WAAOA,oBAAM,YAAY,MAAM,EAAE,SAAS,CAAC;KAC7C;AACF,eAAY;AACZ,OAAI,gBAAgB,GAChB,QAAO,OAAO;IACV,QAAQ;IACR,WAAW,UAAU,UAAU;IAC/B;IACA;IACA;IACH,CAAC;aAGF,OAAO,SAAS,KAAK,EAAE;AACvB,OAAI,WAAW,aAAa,OAAO,QAAQ,MAAM,YAAY,EAAE,CAC3D,QAAO,OAAO;IAAE,QAAQ;IAAS,WAAW;IAAS;IAAQ;IAAU;IAAS,CAAC;AAErF,eAAY,OAAO,QAAQ,MAAM,YAAY,EAAE;QAE/C,QAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAc;GAAQ;GAAU;GAAS,CAAC;AAIlG,MAAI,QAAQ,OAAO,WAAW,SAAS,OACnC,QAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAQ;GAAQ;GAAU;GAAS,CAAC;AAEpF,SAAO,OAAO;GAAE,QAAQ;GAAM,WAAW,OAAO,YAAY;GAAO;GAAQ;GAAU;GAAS,CAAC;;CAE1G,CAAC"}

package/dist/assert/has-members.d.cts

@@ -0,0 +1,48 @@
+//#region src/assert/has-members.d.ts
+interface HasMembersOptions {
+  /**
+   * check for deep equality (ie {a: 1} === {a: 1})
+   * @default false
+   * @example
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  deep?: boolean;
+  /**
+   * use partial matching (ie {a: 1, b: 2} === {a: 1})
+   * implies deep
+   * @default false
+   * @example
+   * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });
+   */
+  partial?: boolean;
+  /**
+   * check that all the members in the first array are present in the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [2, 1], { same: true });
+   * notHasMembers([1, 2], [1], { same: true});
+   */
+  same?: boolean;
+  /**
+   * check that the members in the first array are in the same order as the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [1, 2], { ordered: true });
+   * notHasMembers([1, 2], [2, 1], { ordered: true });
+   */
+  ordered?: boolean;
+}
+interface HasMembers {
+  /**
+   * check that the members in second array are present in the first one
+   * @example
+   * hasMembers([1], [1]);
+   * hasMembers([1, 2], [2, 1]);
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;
+}
+declare const hasMembers: HasMembers, notHasMembers: HasMembers;
+//#endregion
+export { hasMembers, notHasMembers };
+//# sourceMappingURL=has-members.d.cts.map

package/dist/assert/has-members.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-members.d.cts","names":[],"sources":["../../src/assert/has-members.ts"],"sourcesContent":[],"mappings":";UAGU,iBAAA;EAAA;AAAiB;;;;;EA0CoC,IAAA,CAAA,EAAA,OAAA;EAGjD;;;;;;;;;;;;;;;;;;;;;;;;;UAXJ,UAAA;;;;;;;;cAQM,eAAe,eAAe;;cAGhC,YAAU,2BAAe"}

package/dist/assert/has-members.d.ts

@@ -0,0 +1,48 @@
+//#region src/assert/has-members.d.ts
+interface HasMembersOptions {
+  /**
+   * check for deep equality (ie {a: 1} === {a: 1})
+   * @default false
+   * @example
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  deep?: boolean;
+  /**
+   * use partial matching (ie {a: 1, b: 2} === {a: 1})
+   * implies deep
+   * @default false
+   * @example
+   * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });
+   */
+  partial?: boolean;
+  /**
+   * check that all the members in the first array are present in the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [2, 1], { same: true });
+   * notHasMembers([1, 2], [1], { same: true});
+   */
+  same?: boolean;
+  /**
+   * check that the members in the first array are in the same order as the second one
+   * @default false
+   * @example
+   * hasMembers([1, 2], [1, 2], { ordered: true });
+   * notHasMembers([1, 2], [2, 1], { ordered: true });
+   */
+  ordered?: boolean;
+}
+interface HasMembers {
+  /**
+   * check that the members in second array are present in the first one
+   * @example
+   * hasMembers([1], [1]);
+   * hasMembers([1, 2], [2, 1]);
+   * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });
+   */
+  <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;
+}
+declare const hasMembers: HasMembers, notHasMembers: HasMembers;
+//#endregion
+export { hasMembers, notHasMembers };
+//# sourceMappingURL=has-members.d.ts.map

package/dist/assert/has-members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-members.d.ts","names":[],"sources":["../../src/assert/has-members.ts"],"sourcesContent":[],"mappings":";UAGU,iBAAA;EAAA;AAAiB;;;;;EA0CoC,IAAA,CAAA,EAAA,OAAA;EAGjD;;;;;;;;;;;;;;;;;;;;;;;;;UAXJ,UAAA;;;;;;;;cAQM,eAAe,eAAe;;cAGhC,YAAU,2BAAe"}

package/dist/assert/has-members.js

@@ -0,0 +1,64 @@
+import { match } from "../utils/match.js";
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/has-members.ts
+const [hasMembers, notHasMembers] = createAssertion({
+	messages: {
+		hasMembers: "Expected {{= it.actual }} to have members {{= it.expected }}",
+		same: "Expected {{= it.actual }} to have same members as {{= it.expected }}",
+		order: "Expected {{= it.actual }} to have ordered members {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not have members {{= it.expected }}",
+		notSame: "Expected {{= it.actual }} to not have same members as {{= it.expected }}"
+	},
+	test: (report) => (actual, expected, { deep = false, partial = false, ordered = false, same = false } = {}, message) => {
+		let lastIndex = -1;
+		for (const item of expected) if (deep || partial) {
+			const actualIndex = actual.findIndex((actualItem, index) => {
+				if (!ordered) return match(actualItem, item, { partial });
+				if (lastIndex >= index) return false;
+				return match(actualItem, item, { partial });
+			});
+			lastIndex = actualIndex;
+			if (actualIndex === -1) return report({
+				status: "notok",
+				messageId: ordered ? "order" : "hasMembers",
+				actual,
+				expected,
+				message
+			});
+		} else if (actual.includes(item)) {
+			if (ordered && lastIndex >= actual.indexOf(item, lastIndex + 1)) return report({
+				status: "notok",
+				messageId: "order",
+				actual,
+				expected,
+				message
+			});
+			lastIndex = actual.indexOf(item, lastIndex + 1);
+		} else return report({
+			status: "notok",
+			messageId: "hasMembers",
+			actual,
+			expected,
+			message
+		});
+		if (same && actual.length !== expected.length) return report({
+			status: "notok",
+			messageId: "same",
+			actual,
+			expected,
+			message
+		});
+		return report({
+			status: "ok",
+			messageId: same ? "notSame" : "not",
+			actual,
+			expected,
+			message
+		});
+	}
+});
+
+//#endregion
+export { hasMembers, notHasMembers };
+//# sourceMappingURL=has-members.js.map

package/dist/assert/has-members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-members.js","names":[],"sources":["../../src/assert/has-members.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { match } from '../utils/match.js';\n\ninterface HasMembersOptions {\n    /**\n     * check for deep equality (ie {a: 1} === {a: 1})\n     * @default false\n     * @example\n     * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });\n     */\n    deep?: boolean;\n    /**\n     * use partial matching (ie {a: 1, b: 2} === {a: 1})\n     * implies deep\n     * @default false\n     * @example\n     * hasMembers([{ a: 1, b: 2 }], [{ a: 1 }], { partial: true });\n     */\n    partial?: boolean;\n    /**\n     * check that all the members in the first array are present in the second one\n     * @default false\n     * @example\n     * hasMembers([1, 2], [2, 1], { same: true });\n     * notHasMembers([1, 2], [1], { same: true});\n     */\n    same?: boolean;\n    /**\n     * check that the members in the first array are in the same order as the second one\n     * @default false\n     * @example\n     * hasMembers([1, 2], [1, 2], { ordered: true });\n     * notHasMembers([1, 2], [2, 1], { ordered: true });\n     */\n    ordered?: boolean;\n}\n\ninterface HasMembers {\n    /**\n     * check that the members in second array are present in the first one\n     * @example\n     * hasMembers([1], [1]);\n     * hasMembers([1, 2], [2, 1]);\n     * hasMembers([{ a: 1 }], [{ a: 1 }], { deep: true });\n     */\n    <T>(actual: T[], expected: T[], options?: HasMembersOptions, message?: string): void;\n}\n\nexport const [hasMembers, notHasMembers] = createAssertion({\n    messages: {\n        hasMembers: 'Expected {{= it.actual }} to have members {{= it.expected }}',\n        same: 'Expected {{= it.actual }} to have same members as {{= it.expected }}',\n        order: 'Expected {{= it.actual }} to have ordered members {{= it.expected }}',\n        not: 'Expected {{= it.actual }} to not have members {{= it.expected }}',\n        notSame: 'Expected {{= it.actual }} to not have same members as {{= it.expected }}'\n    },\n    test:\n        (report): HasMembers =>\n        <T>(\n            actual: T[],\n            expected: T[],\n            { deep = false, partial = false, ordered = false, same = false }: HasMembersOptions = {},\n            message?: string\n        ) => {\n            let lastIndex = -1;\n            for (const item of expected) {\n                if (deep || partial) {\n                    const actualIndex = actual.findIndex((actualItem, index) => {\n                        if (!ordered) {\n                            return match(actualItem, item, { partial });\n                        }\n                        if (lastIndex >= index) {\n                            return false;\n                        }\n                        return match(actualItem, item, { partial });\n                    });\n                    lastIndex = actualIndex;\n                    if (actualIndex === -1) {\n                        return report({\n                            status: 'notok',\n                            messageId: ordered ? 'order' : 'hasMembers',\n                            actual,\n                            expected,\n                            message\n                        });\n                    }\n                } else {\n                    if (actual.includes(item)) {\n                        if (ordered && lastIndex >= actual.indexOf(item, lastIndex + 1)) {\n                            return report({ status: 'notok', messageId: 'order', actual, expected, message });\n                        }\n                        lastIndex = actual.indexOf(item, lastIndex + 1);\n                    } else {\n                        return report({ status: 'notok', messageId: 'hasMembers', actual, expected, message });\n                    }\n                }\n            }\n            if (same && actual.length !== expected.length) {\n                return report({ status: 'notok', messageId: 'same', actual, expected, message });\n            }\n            return report({ status: 'ok', messageId: same ? 'notSame' : 'not', actual, expected, message });\n        }\n});\n"],"mappings":";;;;AAgDA,MAAa,CAAC,YAAY,iBAAiB,gBAAgB;CACvD,UAAU;EACN,YAAY;EACZ,MAAM;EACN,OAAO;EACP,KAAK;EACL,SAAS;EACZ;CACD,OACK,YAEG,QACA,UACA,EAAE,OAAO,OAAO,UAAU,OAAO,UAAU,OAAO,OAAO,UAA6B,EAAE,EACxF,YACC;EACD,IAAI,YAAY;AAChB,OAAK,MAAM,QAAQ,SACf,KAAI,QAAQ,SAAS;GACjB,MAAM,cAAc,OAAO,WAAW,YAAY,UAAU;AACxD,QAAI,CAAC,QACD,QAAO,MAAM,YAAY,MAAM,EAAE,SAAS,CAAC;AAE/C,QAAI,aAAa,MACb,QAAO;AAEX,WAAO,MAAM,YAAY,MAAM,EAAE,SAAS,CAAC;KAC7C;AACF,eAAY;AACZ,OAAI,gBAAgB,GAChB,QAAO,OAAO;IACV,QAAQ;IACR,WAAW,UAAU,UAAU;IAC/B;IACA;IACA;IACH,CAAC;aAGF,OAAO,SAAS,KAAK,EAAE;AACvB,OAAI,WAAW,aAAa,OAAO,QAAQ,MAAM,YAAY,EAAE,CAC3D,QAAO,OAAO;IAAE,QAAQ;IAAS,WAAW;IAAS;IAAQ;IAAU;IAAS,CAAC;AAErF,eAAY,OAAO,QAAQ,MAAM,YAAY,EAAE;QAE/C,QAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAc;GAAQ;GAAU;GAAS,CAAC;AAIlG,MAAI,QAAQ,OAAO,WAAW,SAAS,OACnC,QAAO,OAAO;GAAE,QAAQ;GAAS,WAAW;GAAQ;GAAQ;GAAU;GAAS,CAAC;AAEpF,SAAO,OAAO;GAAE,QAAQ;GAAM,WAAW,OAAO,YAAY;GAAO;GAAQ;GAAU;GAAS,CAAC;;CAE1G,CAAC"}