@augment-vir/assert 31.0.0 → 31.1.0

package/dist/assertions/values.js

@@ -1,88 +1,330 @@
 import { stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
-import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
-function hasValue(parent, value, failureMessage) {
+import { createWaitUntil } from '../guard-types/wait-until-function.js';
+function hasValue(parent, value) {
+    if (typeof parent === 'string') {
+        return typeof value === 'string' && parent.includes(value);
+    }
     /** Wrap this in a try/catch because `Reflect.ownKeys` can fail depending on what its input is. */
+    let hasValue = true;
     try {
-        const hasValue = Reflect.ownKeys(parent)
+        hasValue = Reflect.ownKeys(parent)
             .map((key) => parent[key])
             .includes(value);
-        if (!hasValue) {
-            throw new Error('fail');
-        }
-    }
-    catch {
-        throw new AssertionError(`'${stringify(parent)}' does not have value '${stringify(value)}'.`, failureMessage);
-    }
-}
-function lacksValue(parent, value, failureMessage) {
-    try {
-        hasValue(parent, value);
     }
     catch {
-        return;
+        return false;
     }
-    throw new AssertionError(`'${stringify(parent)}' has value '${stringify(value)}'.`, failureMessage);
+    return hasValue;
 }
-function hasValues(parent, values, failureMessage) {
-    values.forEach((value) => hasValue(parent, value, failureMessage));
-}
-function lacksValues(parent, values, failureMessage) {
-    values.forEach((value) => lacksValue(parent, value, failureMessage));
-}
-export function isIn(child, parent, failureMessage) {
+export function isIn(child, parent) {
     if (typeof parent === 'string') {
-        if (!parent.includes(child)) {
-            throw new AssertionError(`${stringify(child)} is not in '${parent}'.`, failureMessage);
-        }
+        return parent.includes(child);
     }
     else {
-        hasValue(parent, child, failureMessage);
-    }
-}
-function isNotIn(child, parent, failureMessage) {
-    try {
-        isIn(child, parent);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`${stringify(child)} is not in ${stringify(parent)}.`, failureMessage);
-}
-function isEmpty(actual, failureMessage) {
-    const input = actual;
-    if (!input) {
-        return;
-    }
-    else if (typeof input !== 'string' && typeof input !== 'object') {
-        throw new TypeError(`Cannot check if '${stringify(input)}' is empty.`);
-    }
-    else if ((typeof input === 'string' && input) ||
-        (Array.isArray(input) && input.length) ||
-        (input instanceof Map && input.size) ||
-        (input instanceof Set && input.size) ||
-        (input && typeof input === 'object' && Object.keys(input).length)) {
-        throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+        return hasValue(parent, child);
     }
 }
-function isNotEmpty(actual, failureMessage) {
-    try {
-        isEmpty(actual);
-    }
-    catch {
-        return;
-    }
-    throw new AssertionError(`'${stringify(actual)}' is empty.`, failureMessage);
-}
 const assertions = {
-    hasValue,
-    lacksValue,
-    hasValues,
-    lacksValues,
-    isIn,
-    isNotIn,
-    isEmpty,
-    isNotEmpty,
+    /**
+     * Asserts that an object/array parent includes a child value through reference equality.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     *
+     * assert.hasValue({child}, child); // passes
+     * assert.hasValue({child: {a: 'a'}}, child); // fails
+     * assert.hasValue([child], child); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.lacksValue} : the opposite assertion.
+     * - {@link assert.hasValues} : the multi-value assertion.
+     */
+    hasValue(parent, value, failureMessage) {
+        if (!hasValue(parent, value)) {
+            throw new AssertionError(`'${stringify(parent)}' does not have value '${stringify(value)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that an object/array parent does _not_ include a child value through reference
+     * equality.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     *
+     * assert.lacksValue({child}, child); // fails
+     * assert.lacksValue({child: {a: 'a'}}, child); // passes
+     * assert.lacksValue([child], child); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.hasValue} : the opposite assertion.
+     * - {@link assert.lacksValues} : the multi-value assertion.
+     */
+    lacksValue(parent, value, failureMessage) {
+        if (hasValue(parent, value)) {
+            throw new AssertionError(`'${stringify(parent)}' has value '${stringify(value)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that an object/array parent includes all child values through reference equality.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     * const child2 = {b: 'b'};
+     *
+     * assert.hasValues({child, child2}, [child, child2]); // passes
+     * assert.hasValues({child: {a: 'a'}, child2}, [child, child2]); // fails
+     * assert.hasValues([child], [child, child2]); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.lacksValues} : the opposite assertion.
+     * - {@link assert.hasValue} : the single-value assertion.
+     */
+    hasValues(parent, values, failureMessage) {
+        let missingValues = [];
+        if (typeof parent === 'string') {
+            missingValues = values.filter((value) => {
+                return !(typeof value === 'string' && parent.includes(value));
+            });
+        }
+        else {
+            try {
+                const actualValues = Reflect.ownKeys(parent).map((key) => parent[key]);
+                missingValues = values.filter((value) => {
+                    return !actualValues.includes(value);
+                });
+            }
+            catch {
+                throw new AssertionError(`'${stringify(parent)}' does not have values '${stringify(values)}'.`, failureMessage);
+            }
+        }
+        if (missingValues.length) {
+            throw new AssertionError(`'${stringify(parent)}' does not have values '${stringify(missingValues)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that an object/array parent includes none of the provided child values through
+     * reference equality.
+     *
+     * Performs no type guarding.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     * const child2 = {b: 'b'};
+     *
+     * assert.lacksValues({}, [child, child2]); // passes
+     * assert.lacksValues({child, child2}, [child, child2]); // fails
+     * assert.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.lacksValues} : the opposite assertion.
+     * - {@link assert.hasValue} : the single-value assertion.
+     */
+    lacksValues(parent, values, failureMessage) {
+        let includedValues = [];
+        if (typeof parent === 'string') {
+            includedValues = values.filter((value) => {
+                return typeof value === 'string' && parent.includes(value);
+            });
+        }
+        else {
+            try {
+                const actualValues = Reflect.ownKeys(parent).map((key) => parent[key]);
+                includedValues = values.filter((value) => {
+                    return actualValues.includes(value);
+                });
+            }
+            catch {
+                // ignore error
+            }
+        }
+        if (includedValues.length) {
+            throw new AssertionError(`'${stringify(parent)}' has values '${stringify(includedValues)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that child value is contained within a parent object, array, or string through
+     * reference equality.
+     *
+     * Type guards the child when possible.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     *
+     * assert.isIn(child, {child}); // passes
+     * assert.isIn('a', 'ab'); // passes
+     * assert.isIn(child, [child]); // passes
+     *
+     * assert.isIn(child, {child: {a: 'a'}}); // fails
+     * assert.isIn('a', 'bc'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotIn} : the opposite assertion.
+     */
+    isIn(child, parent, failureMessage) {
+        if (!isIn(child, parent)) {
+            throw new AssertionError(`'${stringify(child)}'\n\nis not in\n\n${stringify(parent)}.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that child value is _not_ contained within a parent object, array, or string through
+     * reference equality.
+     *
+     * Type guards the child when possible.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * const child = {a: 'a'};
+     *
+     * assert.isNotIn(child, {child}); // fails
+     * assert.isNotIn('a', 'ab'); // fails
+     * assert.isNotIn(child, [child]); // fails
+     *
+     * assert.isNotIn(child, {child: {a: 'a'}}); // passes
+     * assert.isNotIn('a', 'bc'); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isIn} : the opposite assertion.
+     */
+    isNotIn(child, parent, failureMessage) {
+        if (isIn(child, parent)) {
+            throw new AssertionError(`'${stringify(child)}'\n\nis in\n\n${stringify(parent)}.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isEmpty({}); // passes
+     * assert.isEmpty(''); // passes
+     * assert.isEmpty([]); // passes
+     *
+     * assert.isEmpty('a'); // fails
+     * assert.isEmpty({a: 'a'}); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isNotEmpty} : the opposite assertion.
+     */
+    isEmpty(actual, failureMessage) {
+        if (typeof actual !== 'string' && typeof actual !== 'object') {
+            throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+        }
+        if (typeof actual === 'string' && !actual) {
+            // eslint-disable-next-line sonarjs/no-gratuitous-expressions
+            if (!actual) {
+                return;
+            }
+        }
+        else if (Array.isArray(actual)) {
+            if (!actual.length) {
+                return;
+            }
+        }
+        else if (actual instanceof Map || actual instanceof Set) {
+            if (!actual.size) {
+                return;
+            }
+        }
+        else if (typeof actual === 'object' && !Object.keys(actual).length) {
+            return;
+        }
+        throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+    },
+    /**
+     * Asserts that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
+     *
+     * Type guards the value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.isNotEmpty({}); // fails
+     * assert.isNotEmpty(''); // fails
+     * assert.isNotEmpty([]); // fails
+     *
+     * assert.isNotEmpty('a'); // passes
+     * assert.isNotEmpty({a: 'a'}); // passes
+     * ```
+     *
+     * @throws {@link AssertionError} If the assertion fails.
+     * @see
+     * - {@link assert.isEmpty} : the opposite assertion.
+     */
+    isNotEmpty(actual, failureMessage) {
+        if (typeof actual !== 'string' && typeof actual !== 'object') {
+            return;
+        }
+        if (typeof actual === 'string' && !actual) {
+            // eslint-disable-next-line sonarjs/no-gratuitous-expressions
+            if (!actual) {
+                throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+            }
+        }
+        else if (Array.isArray(actual)) {
+            if (!actual.length) {
+                throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+            }
+        }
+        else if (actual instanceof Map || actual instanceof Set) {
+            if (!actual.size) {
+                throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+            }
+        }
+        else if (typeof actual === 'object' && !Object.keys(actual).length) {
+            throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+        }
+    },
 };
 export const valueGuards = {
     assert: assertions,
@@ -108,7 +350,9 @@ export const valueGuards = {
          * - {@link check.lacksValue} : the opposite check.
          * - {@link check.hasValues} : the multi-value check.
          */
-        hasValue: autoGuardSymbol,
+        hasValue(parent, value) {
+            return hasValue(parent, value);
+        },
         /**
          * Checks that an object/array parent does _not_ include a child value through reference
          * equality.
@@ -131,7 +375,9 @@ export const valueGuards = {
          * - {@link check.hasValue} : the opposite check.
          * - {@link check.lacksValues} : the multi-value check.
          */
-        lacksValue: autoGuardSymbol,
+        lacksValue(parent, value) {
+            return !hasValue(parent, value);
+        },
         /**
          * Checks that an object/array parent includes all child values through reference equality.
          *
@@ -145,28 +391,18 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * check.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `true`
-         * check.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
-         * check.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `true`
+         * check.hasValues({child, child2}, [child, child2]); // returns `true`
+         * check.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
+         * check.hasValues([child], [child, child2]); // returns `true`
          * ```
          *
          * @see
          * - {@link check.lacksValues} : the opposite check.
          * - {@link check.hasValue} : the single-value check.
          */
-        hasValues: autoGuardSymbol,
+        hasValues(parent, values) {
+            return values.every((value) => hasValue(parent, value));
+        },
         /**
          * Checks that an object/array parent includes none of the provided child values through
          * reference equality.
@@ -181,25 +417,18 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * check.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `true`
-         * check.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
-         * check.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `false`
+         * check.lacksValues({}, [child, child2]); // returns `true`
+         * check.lacksValues({child, child2}, [child, child2]); // returns `false`
+         * check.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `false`
          * ```
          *
          * @see
          * - {@link check.lacksValues} : the opposite check.
          * - {@link check.hasValue} : the single-value check.
          */
-        lacksValues: autoGuardSymbol,
+        lacksValues(parent, values) {
+            return values.every((value) => !hasValue(parent, value));
+        },
         /**
          * Checks that child value is contained within a parent object, array, or string through
          * reference equality.
@@ -224,7 +453,9 @@ export const valueGuards = {
          * @see
          * - {@link check.isNotIn} : the opposite check.
          */
-        isIn: autoGuard(),
+        isIn(child, parent) {
+            return isIn(child, parent);
+        },
         /**
          * Checks that child value is _not_ contained within a parent object, array, or string
          * through reference equality.
@@ -249,7 +480,9 @@ export const valueGuards = {
          * @see
          * - {@link check.isIn} : the opposite check.
          */
-        isNotIn: autoGuard(),
+        isNotIn(child, parent) {
+            return !isIn(child, parent);
+        },
         /**
          * Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -271,7 +504,26 @@ export const valueGuards = {
          * @see
          * - {@link check.isNotEmpty} : the opposite check.
          */
-        isEmpty: autoGuard(),
+        isEmpty(actual) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                return false;
+            }
+            if (typeof actual === 'string') {
+                return !actual;
+            }
+            else if (Array.isArray(actual)) {
+                return !actual.length;
+            }
+            else if (actual instanceof Map) {
+                return !actual.size;
+            }
+            else if (actual instanceof Set) {
+                return !actual.size;
+            }
+            else {
+                return !Object.keys(actual).length;
+            }
+        },
         /**
          * Checks that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -293,7 +545,26 @@ export const valueGuards = {
          * @see
          * - {@link check.isEmpty} : the opposite check.
          */
-        isNotEmpty: autoGuard(),
+        isNotEmpty(actual) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                return true;
+            }
+            if (typeof actual === 'string') {
+                return !!actual;
+            }
+            else if (Array.isArray(actual)) {
+                return !!actual.length;
+            }
+            else if (actual instanceof Map) {
+                return !!actual.size;
+            }
+            else if (actual instanceof Set) {
+                return !!actual.size;
+            }
+            else {
+                return !!Object.keys(actual).length;
+            }
+        },
     },
     assertWrap: {
         /**
@@ -320,7 +591,12 @@ export const valueGuards = {
          * - {@link assertWrap.lacksValue} : the opposite assertion.
          * - {@link assertWrap.hasValues} : the multi-value assertion.
          */
-        hasValue: autoGuardSymbol,
+        hasValue(parent, value, failureMessage) {
+            if (!hasValue(parent, value)) {
+                throw new AssertionError(`'${stringify(parent)}' does not have value '${stringify(value)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that an object/array parent does _not_ include a child value through reference
          * equality. Returns the parent value if the assertion passes.
@@ -345,7 +621,12 @@ export const valueGuards = {
          * - {@link assertWrap.hasValue} : the opposite assertion.
          * - {@link assertWrap.lacksValues} : the multi-value assertion.
          */
-        lacksValue: autoGuardSymbol,
+        lacksValue(parent, value, failureMessage) {
+            if (hasValue(parent, value)) {
+                throw new AssertionError(`'${stringify(parent)}' has value '${stringify(value)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that an object/array parent includes all child values through reference equality.
          * Returns the parent value if the assertion passes.
@@ -360,21 +641,9 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assertWrap.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{child, child2}`;
-         * assertWrap.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
-         * assertWrap.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `[child]`;
+         * assertWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`;
+         * assertWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
+         * assertWrap.hasValues([child], [child, child2]); // returns `[child]`;
          * ```
          *
          * @returns The value if the assertion passes.
@@ -383,7 +652,29 @@ export const valueGuards = {
          * - {@link assertWrap.lacksValues} : the opposite assertion.
          * - {@link assertWrap.hasValue} : the single-value assertion.
          */
-        hasValues: autoGuardSymbol,
+        hasValues(parent, values, failureMessage) {
+            let missingValues = [];
+            if (typeof parent === 'string') {
+                missingValues = values.filter((value) => {
+                    return !(typeof value === 'string' && parent.includes(value));
+                });
+            }
+            else {
+                try {
+                    const actualValues = Reflect.ownKeys(parent).map((key) => parent[key]);
+                    missingValues = values.filter((value) => {
+                        return !actualValues.includes(value);
+                    });
+                }
+                catch {
+                    throw new AssertionError(`'${stringify(parent)}' does not have values '${stringify(values)}'.`, failureMessage);
+                }
+            }
+            if (missingValues.length) {
+                throw new AssertionError(`'${stringify(parent)}' does not have values '${stringify(missingValues)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that an object/array parent includes none of the provided child values through
          * reference equality. Returns the parent value if the assertion passes.
@@ -398,18 +689,9 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * assertWrap.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{}`;
-         * assertWrap.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
-         * assertWrap.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // throws an error
+         * assertWrap.lacksValues({}, [child, child2]); // returns `{}`;
+         * assertWrap.lacksValues({child, child2}, [child, child2]); // throws an error
+         * assertWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // throws an error
          * ```
          *
          * @returns The value if the assertion passes.
@@ -418,7 +700,29 @@ export const valueGuards = {
          * - {@link assertWrap.lacksValues} : the opposite assertion.
          * - {@link assertWrap.hasValue} : the single-value assertion.
          */
-        lacksValues: autoGuardSymbol,
+        lacksValues(parent, values, failureMessage) {
+            let includedValues = [];
+            if (typeof parent === 'string') {
+                includedValues = values.filter((value) => {
+                    return typeof value === 'string' && parent.includes(value);
+                });
+            }
+            else {
+                try {
+                    const actualValues = Reflect.ownKeys(parent).map((key) => parent[key]);
+                    includedValues = values.filter((value) => {
+                        return actualValues.includes(value);
+                    });
+                }
+                catch {
+                    // ignore error
+                }
+            }
+            if (includedValues.length) {
+                throw new AssertionError(`'${stringify(parent)}' has values '${stringify(includedValues)}'.`, failureMessage);
+            }
+            return parent;
+        },
         /**
          * Asserts that child value is contained within a parent object, array, or string through
          * reference equality. Returns the child value if the assertion passes.
@@ -445,7 +749,12 @@ export const valueGuards = {
          * @see
          * - {@link assertWrap.isNotIn} : the opposite assertion.
          */
-        isIn: autoGuard(),
+        isIn(child, parent, failureMessage) {
+            if (!isIn(child, parent)) {
+                throw new AssertionError(`'${stringify(child)}'\n\nis not in\n\n${stringify(parent)}.`, failureMessage);
+            }
+            return child;
+        },
         /**
          * Asserts that child value is _not_ contained within a parent object, array, or string
          * through reference equality. Returns the child value if the assertion passes.
@@ -472,7 +781,12 @@ export const valueGuards = {
          * @see
          * - {@link assertWrap.isIn} : the opposite assertion.
          */
-        isNotIn: autoGuard(),
+        isNotIn(child, parent, failureMessage) {
+            if (isIn(child, parent)) {
+                throw new AssertionError(`'${stringify(child)}'\n\nis in\n\n${stringify(parent)}.`, failureMessage);
+            }
+            return child;
+        },
         /**
          * Asserts that a value is empty. Supports strings, Maps, Sets, objects, and arrays. Returns
          * the value if the assertion passes.
@@ -497,7 +811,31 @@ export const valueGuards = {
          * @see
          * - {@link assertWrap.isNotEmpty} : the opposite assertion.
          */
-        isEmpty: autoGuard(),
+        isEmpty(actual, failureMessage) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+            }
+            if (typeof actual === 'string' && !actual) {
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
+                if (!actual) {
+                    return actual;
+                }
+            }
+            else if (Array.isArray(actual)) {
+                if (!actual.length) {
+                    return actual;
+                }
+            }
+            else if (actual instanceof Map || actual instanceof Set) {
+                if (!actual.size) {
+                    return actual;
+                }
+            }
+            else if (typeof actual === 'object' && !Object.keys(actual).length) {
+                return actual;
+            }
+            throw new AssertionError(`'${stringify(actual)}' is not empty.`, failureMessage);
+        },
         /**
          * Asserts that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          * Returns the value if the assertion passes.
@@ -522,7 +860,31 @@ export const valueGuards = {
          * @see
          * - {@link assertWrap.isEmpty} : the opposite assertion.
          */
-        isNotEmpty: autoGuard(),
+        isNotEmpty(actual, failureMessage) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                return actual;
+            }
+            if (typeof actual === 'string' && !actual) {
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
+                if (!actual) {
+                    throw new AssertionError(`'${stringify(actual)}' is empty.`, failureMessage);
+                }
+            }
+            else if (Array.isArray(actual)) {
+                if (!actual.length) {
+                    throw new AssertionError(`'${stringify(actual)}' is empty.`, failureMessage);
+                }
+            }
+            else if (actual instanceof Map || actual instanceof Set) {
+                if (!actual.size) {
+                    throw new AssertionError(`'${stringify(actual)}' is empty.`, failureMessage);
+                }
+            }
+            else if (typeof actual === 'object' && !Object.keys(actual).length) {
+                throw new AssertionError(`'${stringify(actual)}' is empty.`, failureMessage);
+            }
+            return actual;
+        },
     },
     checkWrap: {
         /**
@@ -546,7 +908,14 @@ export const valueGuards = {
          * - {@link checkWrap.lacksValue} : the opposite check.
          * - {@link checkWrap.hasValues} : the multi-value check.
          */
-        hasValue: autoGuardSymbol,
+        hasValue(parent, value) {
+            if (hasValue(parent, value)) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that an object/array parent does _not_ include a child value through reference
          * equality.
@@ -569,7 +938,14 @@ export const valueGuards = {
          * - {@link checkWrap.hasValue} : the opposite check.
          * - {@link checkWrap.lacksValues} : the multi-value check.
          */
-        lacksValue: autoGuardSymbol,
+        lacksValue(parent, value) {
+            if (hasValue(parent, value)) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        },
         /**
          * Checks that an object/array parent includes all child values through reference equality.
          *
@@ -583,28 +959,23 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * checkWrap.hasValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{child, child2}`
-         * checkWrap.hasValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
-         * checkWrap.hasValues(
-         *     [child],
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         * ); // returns `[child]`
+         * checkWrap.hasValues({child, child2}, [child, child2]); // returns `{child, child2}`
+         * checkWrap.hasValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
+         * checkWrap.hasValues([child], [child, child2]); // returns `[child]`
          * ```
          *
          * @see
          * - {@link checkWrap.lacksValues} : the opposite check.
          * - {@link checkWrap.hasValue} : the single-value check.
          */
-        hasValues: autoGuardSymbol,
+        hasValues(parent, values) {
+            if (values.every((value) => hasValue(parent, value))) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that an object/array parent includes none of the provided child values through
          * reference equality.
@@ -619,25 +990,23 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * checkWrap.lacksValues({}, [
-         *     child,
-         *     child2,
-         * ]); // returns `{}`
-         * checkWrap.lacksValues({child, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
-         * checkWrap.lacksValues({child: {a: 'a'}, child2}, [
-         *     child,
-         *     child2,
-         * ]); // returns `undefined`
+         * checkWrap.lacksValues({}, [child, child2]); // returns `{}`
+         * checkWrap.lacksValues({child, child2}, [child, child2]); // returns `undefined`
+         * checkWrap.lacksValues({child: {a: 'a'}, child2}, [child, child2]); // returns `undefined`
          * ```
          *
          * @see
          * - {@link checkWrap.lacksValues} : the opposite check.
          * - {@link checkWrap.hasValue} : the single-value check.
          */
-        lacksValues: autoGuardSymbol,
+        lacksValues(parent, values) {
+            if (values.every((value) => hasValue(parent, value))) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        },
         /**
          * Checks that child value is contained within a parent object, array, or string through
          * reference equality.
@@ -662,7 +1031,14 @@ export const valueGuards = {
          * @see
          * - {@link checkWrap.isNotIn} : the opposite check.
          */
-        isIn: autoGuard(),
+        isIn(child, parent) {
+            if (isIn(child, parent)) {
+                return child;
+            }
+            else {
+                return undefined;
+            }
+        },
         /**
          * Checks that child value is _not_ contained within a parent object, array, or string
          * through reference equality.
@@ -687,7 +1063,14 @@ export const valueGuards = {
          * @see
          * - {@link checkWrap.isIn} : the opposite check.
          */
-        isNotIn: autoGuard(),
+        isNotIn(child, parent) {
+            if (isIn(child, parent)) {
+                return undefined;
+            }
+            else {
+                return child;
+            }
+        },
         /**
          * Checks that a value is empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -709,7 +1092,30 @@ export const valueGuards = {
          * @see
          * - {@link checkWrap.isNotEmpty} : the opposite check.
          */
-        isEmpty: autoGuard(),
+        isEmpty(actual) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                return undefined;
+            }
+            if (typeof actual === 'string') {
+                if (!actual) {
+                    return actual;
+                }
+            }
+            else if (Array.isArray(actual)) {
+                if (!actual.length) {
+                    return actual;
+                }
+            }
+            else if (actual instanceof Map || actual instanceof Set) {
+                if (!actual.size) {
+                    return actual;
+                }
+            }
+            else if (typeof actual === 'object' && !Object.keys(actual).length) {
+                return actual;
+            }
+            return undefined;
+        },
         /**
          * Checks that a value is _not_ empty. Supports strings, Maps, Sets, objects, and arrays.
          *
@@ -731,7 +1137,30 @@ export const valueGuards = {
          * @see
          * - {@link checkWrap.isEmpty} : the opposite check.
          */
-        isNotEmpty: autoGuard(),
+        isNotEmpty(actual) {
+            if (typeof actual !== 'string' && typeof actual !== 'object') {
+                return actual;
+            }
+            if (typeof actual === 'string') {
+                if (!actual) {
+                    return undefined;
+                }
+            }
+            else if (Array.isArray(actual)) {
+                if (!actual.length) {
+                    return undefined;
+                }
+            }
+            else if (actual instanceof Map || actual instanceof Set) {
+                if (!actual.size) {
+                    return undefined;
+                }
+            }
+            else if (typeof actual === 'object' && !Object.keys(actual).length) {
+                return undefined;
+            }
+            return actual;
+        },
     },
     waitUntil: {
         /**
@@ -763,7 +1192,7 @@ export const valueGuards = {
          * - {@link waitUntil.lacksValue} : the opposite assertion.
          * - {@link waitUntil.hasValues} : the multi-value assertion.
          */
-        hasValue: autoGuardSymbol,
+        hasValue: createWaitUntil(assertions.hasValue),
         /**
          * Repeatedly calls a callback until its output is an object/array parent does _not_ include
          * a child value through reference equality. Once the callback output passes, it is
@@ -793,7 +1222,7 @@ export const valueGuards = {
          * - {@link waitUntil.hasValue} : the opposite assertion.
          * - {@link waitUntil.lacksValues} : the multi-value assertion.
          */
-        lacksValue: autoGuardSymbol,
+        lacksValue: createWaitUntil(assertions.lacksValue),
         /**
          * Repeatedly calls a callback until its output is an object/array parent includes all child
          * values through reference equality. Once the callback output passes, it is returned. If
@@ -809,31 +1238,13 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child, child2};
-         *     },
-         * ); // returns `{child, child2}`;
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child: {a: 'a'}, child2};
-         *     },
-         * ); // throws an error
-         * await waitUntil.hasValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => [child],
-         * ); // returns `[child]`;
+         * await waitUntil.hasValues([child, child2], () => {
+         *     return {child, child2};
+         * }); // returns `{child, child2}`;
+         * await waitUntil.hasValues([child, child2], () => {
+         *     return {child: {a: 'a'}, child2};
+         * }); // throws an error
+         * await waitUntil.hasValues([child, child2], () => [child]); // returns `[child]`;
          * ```
          *
          * @returns The callback output once it passes.
@@ -842,7 +1253,7 @@ export const valueGuards = {
          * - {@link waitUntil.lacksValues} : the opposite assertion.
          * - {@link waitUntil.hasValue} : the single-value assertion.
          */
-        hasValues: autoGuardSymbol,
+        hasValues: createWaitUntil(assertions.hasValues),
         /**
          * Repeatedly calls a callback until its output is an object/array parent includes none of
          * the provided child values through reference equality. Once the callback output passes, it
@@ -858,33 +1269,15 @@ export const valueGuards = {
          * const child = {a: 'a'};
          * const child2 = {b: 'b'};
          *
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {};
-         *     },
-         * ); // returns `{}`;
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child, child2};
-         *     },
-         * ); // throws an error
-         * await waitUntil.lacksValues(
-         *     [
-         *         child,
-         *         child2,
-         *     ],
-         *     () => {
-         *         return {child: {a: 'a'}, child2};
-         *     },
-         * ); // throws an error
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {};
+         * }); // returns `{}`;
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {child, child2};
+         * }); // throws an error
+         * await waitUntil.lacksValues([child, child2], () => {
+         *     return {child: {a: 'a'}, child2};
+         * }); // throws an error
          * ```
          *
          * @returns The callback output once it passes.
@@ -893,7 +1286,7 @@ export const valueGuards = {
          * - {@link waitUntil.lacksValues} : the opposite assertion.
          * - {@link waitUntil.hasValue} : the single-value assertion.
          */
-        lacksValues: autoGuardSymbol,
+        lacksValues: createWaitUntil(assertions.lacksValues),
         /**
          * Repeatedly calls a callback until its output is child value is contained within a parent
          * object, array, or string through reference equality. Once the callback output passes, it
@@ -921,7 +1314,7 @@ export const valueGuards = {
          * @see
          * - {@link waitUntil.isNotIn} : the opposite assertion.
          */
-        isIn: autoGuard(),
+        isIn: createWaitUntil(assertions.isIn),
         /**
          * Repeatedly calls a callback until its output is child value is _not_ contained within a
          * parent object, array, or string through reference equality. Once the callback output
@@ -949,7 +1342,7 @@ export const valueGuards = {
          * @see
          * - {@link waitUntil.isIn} : the opposite assertion.
          */
-        isNotIn: autoGuard(),
+        isNotIn: createWaitUntil(assertions.isNotIn),
         /**
          * Repeatedly calls a callback until its output is a value is empty. Supports strings, Maps,
          * Sets, objects, and arrays. Once the callback output passes, it is returned. If the
@@ -979,7 +1372,7 @@ export const valueGuards = {
          * @see
          * - {@link waitUntil.isNotEmpty} : the opposite assertion.
          */
-        isEmpty: autoGuard(),
+        isEmpty: createWaitUntil(assertions.isEmpty),
         /**
          * Repeatedly calls a callback until its output is a value is _not_ empty. Supports strings,
          * Maps, Sets, objects, and arrays. Once the callback output passes, it is returned. If the
@@ -1009,6 +1402,6 @@ export const valueGuards = {
          * @see
          * - {@link waitUntil.isEmpty} : the opposite assertion.
          */
-        isNotEmpty: autoGuard(),
+        isNotEmpty: createWaitUntil(assertions.isNotEmpty),
     },
 };