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

package/dist/assert/is-between.js

@@ -0,0 +1,44 @@
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/is-between.ts
+const [isBetween, notBetween] = createAssertion({
+	messages: {
+		notBetween: "Expected {{= it.actual }} to be between {{= it.lesser }} and {{= it.greater }}",
+		not: "Expected {{= it.actual }} to not be between {{= it.lesser }} and {{= it.greater }}"
+	},
+	test: (report) => (actual, start, end, { inclusive = true } = {}) => {
+		const [greater, lesser] = end > start ? [end, start] : [start, end];
+		const inclusivelyBetween = actual <= greater && actual >= lesser;
+		const exclusivelyBetween = actual < greater && actual > lesser;
+		if (inclusive && !inclusivelyBetween) return report({
+			messageId: "notBetween",
+			status: "notok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+		if (!inclusive && !exclusivelyBetween) return report({
+			messageId: "notBetween",
+			status: "notok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+		return report({
+			status: "ok",
+			actual,
+			data: {
+				lesser,
+				greater
+			}
+		});
+	}
+});
+
+//#endregion
+export { isBetween, notBetween };
+//# sourceMappingURL=is-between.js.map

package/dist/assert/is-between.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-between.js","names":[],"sources":["../../src/assert/is-between.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\n\ninterface IsBetweenOptions {\n    inclusive?: boolean;\n}\n\ninterface IsBetween {\n    /**\n     * check that date is Between another date\n     */\n    <T extends Date>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;\n    <T extends number>(actual: T, start: T, end: T, options?: IsBetweenOptions): void;\n}\n\nexport const [isBetween, notBetween] = createAssertion({\n    messages: {\n        notBetween: 'Expected {{= it.actual }} to be between {{= it.lesser }} and {{= it.greater }}',\n        not: 'Expected {{= it.actual }} to not be between {{= it.lesser }} and {{= it.greater }}'\n    },\n    test:\n        (report): IsBetween =>\n        <T extends Date | number>(actual: T, start: T, end: T, { inclusive = true }: IsBetweenOptions = {}) => {\n            const [greater, lesser] = end > start ? [end, start] : [start, end];\n            const inclusivelyBetween = actual <= greater && actual >= lesser;\n            const exclusivelyBetween = actual < greater && actual > lesser;\n            if (inclusive && !inclusivelyBetween) {\n                return report({\n                    messageId: 'notBetween',\n                    status: 'notok',\n                    actual,\n                    data: { lesser, greater }\n                });\n            }\n            if (!inclusive && !exclusivelyBetween) {\n                return report({\n                    messageId: 'notBetween',\n                    status: 'notok',\n                    actual,\n                    data: { lesser, greater }\n                });\n            }\n            return report({\n                status: 'ok',\n                actual,\n                data: { lesser, greater }\n            });\n        }\n});\n"],"mappings":";;;AAcA,MAAa,CAAC,WAAW,cAAc,gBAAgB;CACnD,UAAU;EACN,YAAY;EACZ,KAAK;EACR;CACD,OACK,YACyB,QAAW,OAAU,KAAQ,EAAE,YAAY,SAA2B,EAAE,KAAK;EACnG,MAAM,CAAC,SAAS,UAAU,MAAM,QAAQ,CAAC,KAAK,MAAM,GAAG,CAAC,OAAO,IAAI;EACnE,MAAM,qBAAqB,UAAU,WAAW,UAAU;EAC1D,MAAM,qBAAqB,SAAS,WAAW,SAAS;AACxD,MAAI,aAAa,CAAC,mBACd,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;AAEN,MAAI,CAAC,aAAa,CAAC,mBACf,QAAO,OAAO;GACV,WAAW;GACX,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR;GACA,MAAM;IAAE;IAAQ;IAAS;GAC5B,CAAC;;CAEb,CAAC"}

package/dist/assert/is-empty.cjs

@@ -0,0 +1,98 @@
+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_isPlainObject_js = require("lodash/isPlainObject.js");
+lodash_isPlainObject_js = require_rolldown_runtime.__toESM(lodash_isPlainObject_js);
+
+//#region src/assert/is-empty.ts
+const [isEmpty, notIsEmpty] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		array: "Expected array to be empty",
+		object: "Expected object to be empty",
+		map: "Expected Map to be empty",
+		set: "Expected Set to be empty",
+		not: "Expected array to not be empty",
+		notObject: "Expected object to not be empty",
+		notMap: "Expected Map to not be empty",
+		notSet: "Expected Set to not be empty",
+		invalidArgument: "Expected {{= it.actual }} to be an array, object, Map, or Set"
+	},
+	test: (report) => (actual, message) => {
+		if (Array.isArray(actual)) {
+			if (actual.length === 0) return report({
+				message,
+				status: "ok",
+				actual,
+				expected: []
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "array",
+				actual,
+				expected: []
+			});
+		}
+		if ((0, lodash_isPlainObject_js.default)(actual)) {
+			if (Object.keys(actual).length === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notObject",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "object",
+				actual,
+				expected: {}
+			});
+		}
+		if (actual instanceof Map) {
+			if (actual.size === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notMap",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "map",
+				actual,
+				expected: /* @__PURE__ */ new Map()
+			});
+		}
+		if (actual instanceof Set) {
+			if (actual.size === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notSet",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "set",
+				actual
+			});
+		}
+		report({
+			message,
+			status: "notok",
+			messageId: "invalidArgument",
+			actual
+		});
+		report({
+			message,
+			status: "ok",
+			messageId: "invalidArgument",
+			actual
+		});
+	}
+});
+
+//#endregion
+exports.isEmpty = isEmpty;
+exports.notIsEmpty = notIsEmpty;
+//# sourceMappingURL=is-empty.cjs.map

package/dist/assert/is-empty.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.cjs","names":[],"sources":["../../src/assert/is-empty.ts"],"sourcesContent":["import isPlainObject from 'lodash/isPlainObject.js';\nimport { createAssertion } from 'hein-assertion-utils';\n\ninterface IsEmpty {\n    /**\n     * check if array is empty\n     * @param array\n     * @example isEmpty([]);\n     */\n    <T>(array: T[], message?: string): void;\n    /**\n     * check if object is empty\n     * @param object\n     * @example isEmpty({});\n     */\n    (object: Record<string, unknown>, message?: string): void;\n    /**\n     * check if Map is empty\n     * @param map\n     * @example isEmpty(new Map());\n     */\n    <K, V>(map: Map<K, V>, message?: string): void;\n    /**\n     * check if Set is empty\n     * @param set\n     * @example isEmpty(new Set());\n     */\n    <T>(set: Set<T>, message?: string): void;\n}\n\nexport const [isEmpty, notIsEmpty] = createAssertion({\n    messages: {\n        array: 'Expected array to be empty',\n        object: 'Expected object to be empty',\n        map: 'Expected Map to be empty',\n        set: 'Expected Set to be empty',\n        not: 'Expected array to not be empty',\n        notObject: 'Expected object to not be empty',\n        notMap: 'Expected Map to not be empty',\n        notSet: 'Expected Set to not be empty',\n        invalidArgument: 'Expected {{= it.actual }} to be an array, object, Map, or Set'\n    },\n    test:\n        (report): IsEmpty =>\n        <T>(actual: T, message?: string) => {\n            if (Array.isArray(actual)) {\n                if (actual.length === 0) {\n                    return report({ message, status: 'ok', actual, expected: [] as any });\n                }\n                return report({ message, status: 'notok', messageId: 'array', actual, expected: [] as any });\n            }\n            if (isPlainObject(actual)) {\n                if (Object.keys(actual).length === 0) {\n                    return report({ message, status: 'ok', messageId: 'notObject', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'object', actual, expected: {} });\n            }\n            if (actual instanceof Map) {\n                if (actual.size === 0) {\n                    return report({ message, status: 'ok', messageId: 'notMap', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'map', actual, expected: new Map() });\n            }\n            if (actual instanceof Set) {\n                if (actual.size === 0) {\n                    return report({ message, status: 'ok', messageId: 'notSet', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'set', actual });\n            }\n            report({ message, status: 'notok', messageId: 'invalidArgument', actual });\n            report({ message, status: 'ok', messageId: 'invalidArgument', actual });\n        }\n});\n"],"mappings":";;;;;;;AA8BA,MAAa,CAAC,SAAS,wDAA8B;CACjD,UAAU;EACN,OAAO;EACP,QAAQ;EACR,KAAK;EACL,KAAK;EACL,KAAK;EACL,WAAW;EACX,QAAQ;EACR,QAAQ;EACR,iBAAiB;EACpB;CACD,OACK,YACG,QAAW,YAAqB;AAChC,MAAI,MAAM,QAAQ,OAAO,EAAE;AACvB,OAAI,OAAO,WAAW,EAClB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM;IAAQ,UAAU,EAAE;IAAS,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAS;IAAQ,UAAU,EAAE;IAAS,CAAC;;AAEhG,2CAAkB,OAAO,EAAE;AACvB,OAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EAC/B,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAa;IAAQ,CAAC;AAE5E,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAU;IAAQ,UAAU,EAAE;IAAE,CAAC;;AAE1F,MAAI,kBAAkB,KAAK;AACvB,OAAI,OAAO,SAAS,EAChB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAU;IAAQ,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAO;IAAQ,0BAAU,IAAI,KAAK;IAAE,CAAC;;AAE9F,MAAI,kBAAkB,KAAK;AACvB,OAAI,OAAO,SAAS,EAChB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAU;IAAQ,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAO;IAAQ,CAAC;;AAEzE,SAAO;GAAE;GAAS,QAAQ;GAAS,WAAW;GAAmB;GAAQ,CAAC;AAC1E,SAAO;GAAE;GAAS,QAAQ;GAAM,WAAW;GAAmB;GAAQ,CAAC;;CAElF,CAAC"}

package/dist/assert/is-empty.d.cts

@@ -0,0 +1,31 @@
+//#region src/assert/is-empty.d.ts
+interface IsEmpty {
+  /**
+   * check if array is empty
+   * @param array
+   * @example isEmpty([]);
+   */
+  <T>(array: T[], message?: string): void;
+  /**
+   * check if object is empty
+   * @param object
+   * @example isEmpty({});
+   */
+  (object: Record<string, unknown>, message?: string): void;
+  /**
+   * check if Map is empty
+   * @param map
+   * @example isEmpty(new Map());
+   */
+  <K, V>(map: Map<K, V>, message?: string): void;
+  /**
+   * check if Set is empty
+   * @param set
+   * @example isEmpty(new Set());
+   */
+  <T>(set: Set<T>, message?: string): void;
+}
+declare const isEmpty: IsEmpty, notIsEmpty: IsEmpty;
+//#endregion
+export { isEmpty, notIsEmpty };
+//# sourceMappingURL=is-empty.d.cts.map

package/dist/assert/is-empty.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.d.cts","names":[],"sources":["../../src/assert/is-empty.ts"],"sourcesContent":[],"mappings":";UAGU,OAAA;EAAA;;;;;KAkBa,CAAA,KAAA,EAZR,CAYQ,EAAA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;AASvB;EAAqB,CAAA,MAAA,EAfR,MAeQ,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;cATL,IAAI,GAAG;;;;;;WAMV,IAAI;;cAGH,SAAO,qBAAY"}

package/dist/assert/is-empty.d.ts

@@ -0,0 +1,31 @@
+//#region src/assert/is-empty.d.ts
+interface IsEmpty {
+  /**
+   * check if array is empty
+   * @param array
+   * @example isEmpty([]);
+   */
+  <T>(array: T[], message?: string): void;
+  /**
+   * check if object is empty
+   * @param object
+   * @example isEmpty({});
+   */
+  (object: Record<string, unknown>, message?: string): void;
+  /**
+   * check if Map is empty
+   * @param map
+   * @example isEmpty(new Map());
+   */
+  <K, V>(map: Map<K, V>, message?: string): void;
+  /**
+   * check if Set is empty
+   * @param set
+   * @example isEmpty(new Set());
+   */
+  <T>(set: Set<T>, message?: string): void;
+}
+declare const isEmpty: IsEmpty, notIsEmpty: IsEmpty;
+//#endregion
+export { isEmpty, notIsEmpty };
+//# sourceMappingURL=is-empty.d.ts.map

package/dist/assert/is-empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.d.ts","names":[],"sources":["../../src/assert/is-empty.ts"],"sourcesContent":[],"mappings":";UAGU,OAAA;EAAA;;;;;KAkBa,CAAA,KAAA,EAZR,CAYQ,EAAA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;AASvB;EAAqB,CAAA,MAAA,EAfR,MAeQ,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;;;;;cATL,IAAI,GAAG;;;;;;WAMV,IAAI;;cAGH,SAAO,qBAAY"}

package/dist/assert/is-empty.js

@@ -0,0 +1,94 @@
+import { createAssertion } from "hein-assertion-utils";
+import isPlainObject from "lodash/isPlainObject.js";
+
+//#region src/assert/is-empty.ts
+const [isEmpty, notIsEmpty] = createAssertion({
+	messages: {
+		array: "Expected array to be empty",
+		object: "Expected object to be empty",
+		map: "Expected Map to be empty",
+		set: "Expected Set to be empty",
+		not: "Expected array to not be empty",
+		notObject: "Expected object to not be empty",
+		notMap: "Expected Map to not be empty",
+		notSet: "Expected Set to not be empty",
+		invalidArgument: "Expected {{= it.actual }} to be an array, object, Map, or Set"
+	},
+	test: (report) => (actual, message) => {
+		if (Array.isArray(actual)) {
+			if (actual.length === 0) return report({
+				message,
+				status: "ok",
+				actual,
+				expected: []
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "array",
+				actual,
+				expected: []
+			});
+		}
+		if (isPlainObject(actual)) {
+			if (Object.keys(actual).length === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notObject",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "object",
+				actual,
+				expected: {}
+			});
+		}
+		if (actual instanceof Map) {
+			if (actual.size === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notMap",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "map",
+				actual,
+				expected: /* @__PURE__ */ new Map()
+			});
+		}
+		if (actual instanceof Set) {
+			if (actual.size === 0) return report({
+				message,
+				status: "ok",
+				messageId: "notSet",
+				actual
+			});
+			return report({
+				message,
+				status: "notok",
+				messageId: "set",
+				actual
+			});
+		}
+		report({
+			message,
+			status: "notok",
+			messageId: "invalidArgument",
+			actual
+		});
+		report({
+			message,
+			status: "ok",
+			messageId: "invalidArgument",
+			actual
+		});
+	}
+});
+
+//#endregion
+export { isEmpty, notIsEmpty };
+//# sourceMappingURL=is-empty.js.map

package/dist/assert/is-empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty.js","names":[],"sources":["../../src/assert/is-empty.ts"],"sourcesContent":["import isPlainObject from 'lodash/isPlainObject.js';\nimport { createAssertion } from 'hein-assertion-utils';\n\ninterface IsEmpty {\n    /**\n     * check if array is empty\n     * @param array\n     * @example isEmpty([]);\n     */\n    <T>(array: T[], message?: string): void;\n    /**\n     * check if object is empty\n     * @param object\n     * @example isEmpty({});\n     */\n    (object: Record<string, unknown>, message?: string): void;\n    /**\n     * check if Map is empty\n     * @param map\n     * @example isEmpty(new Map());\n     */\n    <K, V>(map: Map<K, V>, message?: string): void;\n    /**\n     * check if Set is empty\n     * @param set\n     * @example isEmpty(new Set());\n     */\n    <T>(set: Set<T>, message?: string): void;\n}\n\nexport const [isEmpty, notIsEmpty] = createAssertion({\n    messages: {\n        array: 'Expected array to be empty',\n        object: 'Expected object to be empty',\n        map: 'Expected Map to be empty',\n        set: 'Expected Set to be empty',\n        not: 'Expected array to not be empty',\n        notObject: 'Expected object to not be empty',\n        notMap: 'Expected Map to not be empty',\n        notSet: 'Expected Set to not be empty',\n        invalidArgument: 'Expected {{= it.actual }} to be an array, object, Map, or Set'\n    },\n    test:\n        (report): IsEmpty =>\n        <T>(actual: T, message?: string) => {\n            if (Array.isArray(actual)) {\n                if (actual.length === 0) {\n                    return report({ message, status: 'ok', actual, expected: [] as any });\n                }\n                return report({ message, status: 'notok', messageId: 'array', actual, expected: [] as any });\n            }\n            if (isPlainObject(actual)) {\n                if (Object.keys(actual).length === 0) {\n                    return report({ message, status: 'ok', messageId: 'notObject', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'object', actual, expected: {} });\n            }\n            if (actual instanceof Map) {\n                if (actual.size === 0) {\n                    return report({ message, status: 'ok', messageId: 'notMap', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'map', actual, expected: new Map() });\n            }\n            if (actual instanceof Set) {\n                if (actual.size === 0) {\n                    return report({ message, status: 'ok', messageId: 'notSet', actual });\n                }\n                return report({ message, status: 'notok', messageId: 'set', actual });\n            }\n            report({ message, status: 'notok', messageId: 'invalidArgument', actual });\n            report({ message, status: 'ok', messageId: 'invalidArgument', actual });\n        }\n});\n"],"mappings":";;;;AA8BA,MAAa,CAAC,SAAS,cAAc,gBAAgB;CACjD,UAAU;EACN,OAAO;EACP,QAAQ;EACR,KAAK;EACL,KAAK;EACL,KAAK;EACL,WAAW;EACX,QAAQ;EACR,QAAQ;EACR,iBAAiB;EACpB;CACD,OACK,YACG,QAAW,YAAqB;AAChC,MAAI,MAAM,QAAQ,OAAO,EAAE;AACvB,OAAI,OAAO,WAAW,EAClB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM;IAAQ,UAAU,EAAE;IAAS,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAS;IAAQ,UAAU,EAAE;IAAS,CAAC;;AAEhG,MAAI,cAAc,OAAO,EAAE;AACvB,OAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EAC/B,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAa;IAAQ,CAAC;AAE5E,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAU;IAAQ,UAAU,EAAE;IAAE,CAAC;;AAE1F,MAAI,kBAAkB,KAAK;AACvB,OAAI,OAAO,SAAS,EAChB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAU;IAAQ,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAO;IAAQ,0BAAU,IAAI,KAAK;IAAE,CAAC;;AAE9F,MAAI,kBAAkB,KAAK;AACvB,OAAI,OAAO,SAAS,EAChB,QAAO,OAAO;IAAE;IAAS,QAAQ;IAAM,WAAW;IAAU;IAAQ,CAAC;AAEzE,UAAO,OAAO;IAAE;IAAS,QAAQ;IAAS,WAAW;IAAO;IAAQ,CAAC;;AAEzE,SAAO;GAAE;GAAS,QAAQ;GAAS,WAAW;GAAmB;GAAQ,CAAC;AAC1E,SAAO;GAAE;GAAS,QAAQ;GAAM,WAAW;GAAmB;GAAQ,CAAC;;CAElF,CAAC"}

package/dist/assert/is-type.cjs

@@ -0,0 +1,34 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_get_type = require('../utils/get-type.cjs');
+let hein_assertion_utils = require("hein-assertion-utils");
+hein_assertion_utils = require_rolldown_runtime.__toESM(hein_assertion_utils);
+
+//#region src/assert/is-type.ts
+const [isType, notIsType] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		wrongType: "Expected {{= it.actual }} to be a(n) {{= it.expected }}",
+		not: `Expected {{= it.actual }} to not be a(n) {{= it.expected }}`
+	},
+	test: (report) => (value, expectedType) => {
+		const actualType = require_get_type.getType(value);
+		if (actualType !== expectedType) return report({
+			status: "notok",
+			messageId: "wrongType",
+			actual: actualType,
+			expected: expectedType,
+			noStringify: true
+		});
+		return report({
+			status: "ok",
+			messageId: "not",
+			actual: actualType,
+			expected: expectedType,
+			noStringify: true
+		});
+	}
+});
+
+//#endregion
+exports.isType = isType;
+exports.notIsType = notIsType;
+//# sourceMappingURL=is-type.cjs.map

package/dist/assert/is-type.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.cjs","names":["getType"],"sources":["../../src/assert/is-type.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { type ValueType, getType } from '../utils/get-type.js';\n\ninterface IsType {\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType('foo', 'string');\n     * @example isType(1, 'number');\n     * @example isType(1n, 'bigint');\n     * @example isType(true, 'boolean');\n     * @example isType(Symbol('foo'), 'symbol');\n     * @example isType(undefined, 'undefined');\n     * @example isType({}, 'object');\n     * @example isType(() => {}, 'function');\n     * @example isType(null, 'null');\n     * @example isType(NaN, 'NaN');\n     * @example isType([], 'array');\n     */\n    (value: unknown, expectedType: ValueType): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType('foo', 'string');\n     */\n    (value: string, expectedType: 'string'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(1, 'number');\n     * @example isType(NaN, 'NaN');\n     */\n    (value: number, expectedType: 'number' | 'NaN'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(1n, 'bigint');\n     */\n    (value: bigint, expectedType: 'bigint'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(true, 'boolean');\n     */\n    (value: boolean, expectedType: 'boolean'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(Symbol('foo'), 'symbol');\n     */\n    (value: symbol, expectedType: 'symbol'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(Symbol('foo'), 'symbol');\n     */\n    (value: undefined, expectedType: 'undefined'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType({}, 'object');\n     */\n    (value: object, expectedType: 'object'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(() => {}, 'function');\n     */\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    (value: Function, expectedType: 'function'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(null, 'null');\n     */\n    (value: null, expectedType: 'null'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType([], 'array');\n     */\n    (value: any[], expectedType: 'array'): void;\n}\n\nexport const [isType, notIsType] = createAssertion({\n    messages: {\n        wrongType: 'Expected {{= it.actual }} to be a(n) {{= it.expected }}',\n        not: `Expected {{= it.actual }} to not be a(n) {{= it.expected }}`\n    },\n    test:\n        (report): IsType =>\n        (value: any, expectedType: ValueType) => {\n            const actualType = getType(value);\n            if (actualType !== expectedType) {\n                return report({\n                    status: 'notok',\n                    messageId: 'wrongType',\n                    actual: actualType,\n                    expected: expectedType,\n                    noStringify: true\n                });\n            }\n            return report({\n                status: 'ok',\n                messageId: 'not',\n                actual: actualType,\n                expected: expectedType,\n                noStringify: true\n            });\n        }\n});\n"],"mappings":";;;;;;AA+FA,MAAa,CAAC,QAAQ,uDAA6B;CAC/C,UAAU;EACN,WAAW;EACX,KAAK;EACR;CACD,OACK,YACA,OAAY,iBAA4B;EACrC,MAAM,aAAaA,yBAAQ,MAAM;AACjC,MAAI,eAAe,aACf,QAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,UAAU;GACV,aAAa;GAChB,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,UAAU;GACV,aAAa;GAChB,CAAC;;CAEb,CAAC"}

package/dist/assert/is-type.d.cts

@@ -0,0 +1,97 @@
+import { ValueType } from "../utils/get-type.cjs";
+
+//#region src/assert/is-type.d.ts
+interface IsType {
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   * @example isType(1, 'number');
+   * @example isType(1n, 'bigint');
+   * @example isType(true, 'boolean');
+   * @example isType(Symbol('foo'), 'symbol');
+   * @example isType(undefined, 'undefined');
+   * @example isType({}, 'object');
+   * @example isType(() => {}, 'function');
+   * @example isType(null, 'null');
+   * @example isType(NaN, 'NaN');
+   * @example isType([], 'array');
+   */
+  (value: unknown, expectedType: ValueType): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   */
+  (value: string, expectedType: 'string'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1, 'number');
+   * @example isType(NaN, 'NaN');
+   */
+  (value: number, expectedType: 'number' | 'NaN'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1n, 'bigint');
+   */
+  (value: bigint, expectedType: 'bigint'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(true, 'boolean');
+   */
+  (value: boolean, expectedType: 'boolean'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: symbol, expectedType: 'symbol'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: undefined, expectedType: 'undefined'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType({}, 'object');
+   */
+  (value: object, expectedType: 'object'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(() => {}, 'function');
+   */
+  (value: Function, expectedType: 'function'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(null, 'null');
+   */
+  (value: null, expectedType: 'null'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType([], 'array');
+   */
+  (value: any[], expectedType: 'array'): void;
+}
+declare const isType: IsType, notIsType: IsType;
+//#endregion
+export { isType, notIsType };
+//# sourceMappingURL=is-type.d.cts.map

package/dist/assert/is-type.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.cts","names":[],"sources":["../../src/assert/is-type.ts"],"sourcesContent":[],"mappings":";;;UAGU,MAAA;;AAFqD;;;;;AA8F/D;;;;;;;;;;iCA3EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0DvB;;;;;;;;;;;;;;;;cAiBE,QAAM,mBAAW"}

package/dist/assert/is-type.d.ts

@@ -0,0 +1,97 @@
+import { ValueType } from "../utils/get-type.js";
+
+//#region src/assert/is-type.d.ts
+interface IsType {
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   * @example isType(1, 'number');
+   * @example isType(1n, 'bigint');
+   * @example isType(true, 'boolean');
+   * @example isType(Symbol('foo'), 'symbol');
+   * @example isType(undefined, 'undefined');
+   * @example isType({}, 'object');
+   * @example isType(() => {}, 'function');
+   * @example isType(null, 'null');
+   * @example isType(NaN, 'NaN');
+   * @example isType([], 'array');
+   */
+  (value: unknown, expectedType: ValueType): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType('foo', 'string');
+   */
+  (value: string, expectedType: 'string'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1, 'number');
+   * @example isType(NaN, 'NaN');
+   */
+  (value: number, expectedType: 'number' | 'NaN'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(1n, 'bigint');
+   */
+  (value: bigint, expectedType: 'bigint'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(true, 'boolean');
+   */
+  (value: boolean, expectedType: 'boolean'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: symbol, expectedType: 'symbol'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(Symbol('foo'), 'symbol');
+   */
+  (value: undefined, expectedType: 'undefined'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType({}, 'object');
+   */
+  (value: object, expectedType: 'object'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(() => {}, 'function');
+   */
+  (value: Function, expectedType: 'function'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType(null, 'null');
+   */
+  (value: null, expectedType: 'null'): void;
+  /**
+   * check if value is of a specific type, nulls, NaN and arrays are specially handled
+   * @param value
+   * @param expectedType
+   * @example isType([], 'array');
+   */
+  (value: any[], expectedType: 'array'): void;
+}
+declare const isType: IsType, notIsType: IsType;
+//#endregion
+export { isType, notIsType };
+//# sourceMappingURL=is-type.d.ts.map

package/dist/assert/is-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.d.ts","names":[],"sources":["../../src/assert/is-type.ts"],"sourcesContent":[],"mappings":";;;UAGU,MAAA;;AAFqD;;;;;AA8F/D;;;;;;;;;;iCA3EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0DvB;;;;;;;;;;;;;;;;cAiBE,QAAM,mBAAW"}

package/dist/assert/is-type.js

@@ -0,0 +1,31 @@
+import { getType } from "../utils/get-type.js";
+import { createAssertion } from "hein-assertion-utils";
+
+//#region src/assert/is-type.ts
+const [isType, notIsType] = createAssertion({
+	messages: {
+		wrongType: "Expected {{= it.actual }} to be a(n) {{= it.expected }}",
+		not: `Expected {{= it.actual }} to not be a(n) {{= it.expected }}`
+	},
+	test: (report) => (value, expectedType) => {
+		const actualType = getType(value);
+		if (actualType !== expectedType) return report({
+			status: "notok",
+			messageId: "wrongType",
+			actual: actualType,
+			expected: expectedType,
+			noStringify: true
+		});
+		return report({
+			status: "ok",
+			messageId: "not",
+			actual: actualType,
+			expected: expectedType,
+			noStringify: true
+		});
+	}
+});
+
+//#endregion
+export { isType, notIsType };
+//# sourceMappingURL=is-type.js.map

package/dist/assert/is-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-type.js","names":[],"sources":["../../src/assert/is-type.ts"],"sourcesContent":["import { createAssertion } from 'hein-assertion-utils';\nimport { type ValueType, getType } from '../utils/get-type.js';\n\ninterface IsType {\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType('foo', 'string');\n     * @example isType(1, 'number');\n     * @example isType(1n, 'bigint');\n     * @example isType(true, 'boolean');\n     * @example isType(Symbol('foo'), 'symbol');\n     * @example isType(undefined, 'undefined');\n     * @example isType({}, 'object');\n     * @example isType(() => {}, 'function');\n     * @example isType(null, 'null');\n     * @example isType(NaN, 'NaN');\n     * @example isType([], 'array');\n     */\n    (value: unknown, expectedType: ValueType): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType('foo', 'string');\n     */\n    (value: string, expectedType: 'string'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(1, 'number');\n     * @example isType(NaN, 'NaN');\n     */\n    (value: number, expectedType: 'number' | 'NaN'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(1n, 'bigint');\n     */\n    (value: bigint, expectedType: 'bigint'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(true, 'boolean');\n     */\n    (value: boolean, expectedType: 'boolean'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(Symbol('foo'), 'symbol');\n     */\n    (value: symbol, expectedType: 'symbol'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(Symbol('foo'), 'symbol');\n     */\n    (value: undefined, expectedType: 'undefined'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType({}, 'object');\n     */\n    (value: object, expectedType: 'object'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(() => {}, 'function');\n     */\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    (value: Function, expectedType: 'function'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType(null, 'null');\n     */\n    (value: null, expectedType: 'null'): void;\n    /**\n     * check if value is of a specific type, nulls, NaN and arrays are specially handled\n     * @param value\n     * @param expectedType\n     * @example isType([], 'array');\n     */\n    (value: any[], expectedType: 'array'): void;\n}\n\nexport const [isType, notIsType] = createAssertion({\n    messages: {\n        wrongType: 'Expected {{= it.actual }} to be a(n) {{= it.expected }}',\n        not: `Expected {{= it.actual }} to not be a(n) {{= it.expected }}`\n    },\n    test:\n        (report): IsType =>\n        (value: any, expectedType: ValueType) => {\n            const actualType = getType(value);\n            if (actualType !== expectedType) {\n                return report({\n                    status: 'notok',\n                    messageId: 'wrongType',\n                    actual: actualType,\n                    expected: expectedType,\n                    noStringify: true\n                });\n            }\n            return report({\n                status: 'ok',\n                messageId: 'not',\n                actual: actualType,\n                expected: expectedType,\n                noStringify: true\n            });\n        }\n});\n"],"mappings":";;;;AA+FA,MAAa,CAAC,QAAQ,aAAa,gBAAgB;CAC/C,UAAU;EACN,WAAW;EACX,KAAK;EACR;CACD,OACK,YACA,OAAY,iBAA4B;EACrC,MAAM,aAAa,QAAQ,MAAM;AACjC,MAAI,eAAe,aACf,QAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,UAAU;GACV,aAAa;GAChB,CAAC;AAEN,SAAO,OAAO;GACV,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,UAAU;GACV,aAAa;GAChB,CAAC;;CAEb,CAAC"}

package/dist/assert/less-than-equal.cjs

@@ -0,0 +1,36 @@
+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/less-than-equal.ts
+const [lessThanEqual, notLessThanEqual] = (0, hein_assertion_utils.createAssertion)({
+	messages: {
+		lesserThanEqual: "Expected {{= it.actual }} to be less than or equal to {{= it.expected }}",
+		not: "Expected {{= it.actual }} to not be less than or equal to {{= it.expected }}"
+	},
+	test: (report) => (actual, expected, message) => {
+		require_validate_numeric_and_dates.validateNumericsAndDates(actual, expected);
+		if (actual > expected) return report({
+			status: "notok",
+			messageId: "lesserThanEqual",
+			actual,
+			expected,
+			message,
+			noStringify: true
+		});
+		return report({
+			status: "ok",
+			actual,
+			expected,
+			message,
+			messageId: "not",
+			noStringify: true
+		});
+	}
+});
+
+//#endregion
+exports.lessThanEqual = lessThanEqual;
+exports.notLessThanEqual = notLessThanEqual;
+//# sourceMappingURL=less-than-equal.cjs.map