@augment-vir/assert 31.71.4 → 31.72.0

package/dist/assertions/keys.d.ts

@@ -1,12 +1,38 @@
-import { type MaybePromise, type NarrowToExpected, type RequiredKeysOf } from '@augment-vir/core';
+import { type AnyObject, type MaybePromise, type NarrowToExpected, type RequiredKeysOf, type SetRequiredAndNotNull } from '@augment-vir/core';
 import { type SetRequired } from 'type-fest';
 import { type WaitUntilOptions } from '../guard-types/wait-until-function.js';
-/** Helper type for `hasKey`. */
-type ExtractValue<Key extends PropertyKey, Parent> = Key extends keyof Parent ? Key extends keyof SetRequired<Parent, Key> ? SetRequired<Parent, Key>[Key] : never : Key extends keyof Extract<Parent, Record<Key, any>> ? Key extends keyof SetRequired<Extract<Parent, Record<Key, any>>, Key> ? SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never : never;
-/** Helper type for `hasKey`. */
-type CombinedParentValue<Key extends PropertyKey, Parent> = ExtractValue<Key, Parent> extends never ? unknown : ExtractValue<Key, Parent>;
-/** Helper type for `hasKey`. */
-type CombineTypeWithKey<Key extends PropertyKey, Parent> = Parent & Record<Key, CombinedParentValue<Key, Parent>>;
+/**
+ * Helper type for `hasKey`.
+ *
+ * @category Assert : Util
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export type ExtractValue<Key extends PropertyKey, Parent> = Key extends keyof Parent ? Key extends keyof SetRequired<Parent, Key> ? SetRequired<Parent, Key>[Key] : never : Key extends keyof Extract<Parent, Record<Key, any>> ? Key extends keyof SetRequired<Extract<Parent, Record<Key, any>>, Key> ? SetRequired<Extract<Parent, Record<Key, any>>, Key>[Key] : never : never;
+/**
+ * Helper type for `hasKey`.
+ *
+ * @category Assert : Util
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export type CombinedParentValue<Key extends PropertyKey, Parent> = ExtractValue<Key, Parent> extends never ? unknown : ExtractValue<Key, Parent>;
+/**
+ * Helper type for `hasKey`.
+ *
+ * @category Assert : Util
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export type CombineTypeWithKey<Key extends PropertyKey, Parent> = Parent & Record<Key, CombinedParentValue<Key, Parent>>;
+/**
+ * Helper type for `hasDefinedProperty` and `hasDefinedProperties`.
+ *
+ * @category Assert : Util
+ * @category Package : @augment-vir/assert
+ * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
+ */
+export type WithDefinedProperties<Parent extends AnyObject, Keys extends keyof Parent> = Parent & SetRequiredAndNotNull<Parent, Keys>;
 declare function hasKey<const Key extends PropertyKey, const Parent>(this: void, parent: Parent, key: Key): parent is CombineTypeWithKey<Key, Parent>;
 export declare const keyGuards: {
     assert: {
@@ -140,6 +166,53 @@ export declare const keyGuards: {
          * - {@link assert.lacksKey} : the single-key assertion.
          */
         lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined): asserts parent is Exclude<Parent, Partial<Record<Key, any>>>;
+        /**
+         * Asserts that a parent object has the given property and that its value is defined (not `null`
+         * and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.hasDefinedProperty({a: 0, b: 1}, 'a'); // passes
+         * assert.hasDefinedProperty({a: undefined, b: 1}, 'a'); // fails
+         * assert.hasDefinedProperty({a: 0, b: 1}, 'c'); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If the property is missing or not defined.
+         * @see
+         * - {@link assert.hasDefinedProperties} : the multi-property assertion.
+         */
+        hasDefinedProperty<const Parent extends AnyObject, const Key extends keyof Parent>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): asserts parent is WithDefinedProperties<Parent, Key>;
+        /**
+         * Asserts that a parent object has all the given properties and that each of their values is
+         * defined (not `null` and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assert} from '@augment-vir/assert';
+         *
+         * assert.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // passes
+         * assert.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // fails
+         * ```
+         *
+         * @throws {@link AssertionError} If any of the properties are missing or not defined.
+         * @see
+         * - {@link assert.hasDefinedProperty} : the single-property assertion.
+         */
+        hasDefinedProperties<const Parent extends AnyObject, const Keys extends keyof Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined): asserts parent is WithDefinedProperties<Parent, Keys>;
     };
     check: {
         /**
@@ -266,6 +339,51 @@ export declare const keyGuards: {
          * - {@link check.lacksKey} : the single-key check.
          */
         lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>): parent is Exclude<Parent, Partial<Record<Key, any>>>;
+        /**
+         * Checks that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `true`
+         * check.hasDefinedProperty({a: undefined, b: 1}, 'a'); // returns `false`
+         * check.hasDefinedProperty({a: 0, b: 1}, 'c'); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.hasDefinedProperties} : the multi-property check.
+         */
+        hasDefinedProperty<const Parent extends AnyObject, const Key extends keyof Parent>(this: void, parent: Parent, key: Key): parent is WithDefinedProperties<Parent, Key>;
+        /**
+         * Checks that a parent object has all the given properties and that each of their values is
+         * defined (not `null` and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `true`
+         * check.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.hasDefinedProperty} : the single-property check.
+         */
+        hasDefinedProperties<const Parent extends AnyObject, const Keys extends keyof Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>): parent is WithDefinedProperties<Parent, Keys>;
     };
     assertWrap: {
         /**
@@ -407,6 +525,54 @@ export declare const keyGuards: {
          * - {@link assertWrap.lacksKey} : the single-key assertion.
          */
         lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>, failureMessage?: string | undefined): Exclude<Parent, Partial<Record<Key, any>>>;
+        /**
+         * Asserts that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`). Returns the parent if the assertion passes.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
+         * assertWrap.hasDefinedProperty({a: undefined, b: 1}, 'a'); // throws an error
+         * ```
+         *
+         * @returns The parent if the assertion passes.
+         * @throws {@link AssertionError} If the property is missing or not defined.
+         * @see
+         * - {@link assertWrap.hasDefinedProperties} : the multi-property assertion.
+         */
+        hasDefinedProperty<const Parent extends AnyObject, const Key extends keyof Parent>(this: void, parent: Parent, key: Key, failureMessage?: string | undefined): WithDefinedProperties<Parent, Key>;
+        /**
+         * Asserts that a parent object has all the given properties and that each of their values
+         * is defined (not `null` and not `undefined`). Returns the parent if the assertion passes.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `{a: 0, b: 1}`
+         * assertWrap.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
+         * ```
+         *
+         * @returns The parent if the assertion passes.
+         * @throws {@link AssertionError} If any of the properties are missing or not defined.
+         * @see
+         * - {@link assertWrap.hasDefinedProperty} : the single-property assertion.
+         */
+        hasDefinedProperties<const Parent extends AnyObject, const Keys extends keyof Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>, failureMessage?: string | undefined): WithDefinedProperties<Parent, Keys>;
     };
     checkWrap: {
         /**
@@ -545,6 +711,54 @@ export declare const keyGuards: {
          * - {@link checkWrap.lacksKey} : the single-key check.
          */
         lacksKeys<const Parent, const Key extends PropertyKey>(this: void, parent: Parent, keys: ReadonlyArray<Key>): Exclude<Parent, Partial<Record<Key, any>>> | undefined;
+        /**
+         * Checks that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`). Returns the parent value if the check passes, otherwise
+         * `undefined`.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
+         * checkWrap.hasDefinedProperty({a: undefined, b: 1}, 'a'); // returns `undefined`
+         * ```
+         *
+         * @returns The parent value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.hasDefinedProperties} : the multi-property check.
+         */
+        hasDefinedProperty<const Parent extends AnyObject, const Key extends keyof Parent>(this: void, parent: Parent, key: Key): WithDefinedProperties<Parent, Key> | undefined;
+        /**
+         * Checks that a parent object has all the given properties and that each of their values is
+         * defined (not `null` and not `undefined`). Returns the parent value if the check passes,
+         * otherwise `undefined`.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `{a: 0, b: 1}`
+         * checkWrap.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `undefined`
+         * ```
+         *
+         * @returns The parent value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.hasDefinedProperty} : the single-property check.
+         */
+        hasDefinedProperties<const Parent extends AnyObject, const Keys extends keyof Parent>(this: void, parent: Parent, keys: ReadonlyArray<Keys>): WithDefinedProperties<Parent, Keys> | undefined;
     };
     waitUntil: {
         /**
@@ -723,6 +937,70 @@ export declare const keyGuards: {
          * - {@link waitUntil.lacksKey} : the single-key assertion.
          */
         lacksKeys: <const Parent, const Keys extends PropertyKey>(this: void, keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Parent, Partial<Record<Keys, any>>>>;
+        /**
+         * Repeatedly calls a callback until its output is a parent object that has the first, key
+         * input defined (not `null` and not `undefined`). Once the callback output passes, it is
+         * returned. If the attempts time out, an error is thrown.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.hasDefinedProperty('a', () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasDefinedProperty('a', () => {
+         *     return {a: undefined, b: 1};
+         * }); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.hasDefinedProperties} : the multi-property assertion.
+         */
+        hasDefinedProperty: <const Parent extends AnyObject, const Key extends keyof Parent>(this: void, key: Key, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<WithDefinedProperties<Parent, Key>>;
+        /**
+         * Repeatedly calls a callback until its output is a parent object that has all of the
+         * first, keys input defined (not `null` and not `undefined`). Once the callback output
+         * passes, it is returned. If the attempts time out, an error is thrown.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.hasDefinedProperties(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     () => {
+         *         return {a: 0, b: 1};
+         *     },
+         * ); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasDefinedProperties(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     () => {
+         *         return {a: 0, b: undefined};
+         *     },
+         * ); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.hasDefinedProperty} : the single-property assertion.
+         */
+        hasDefinedProperties: <const Parent extends AnyObject, const Keys extends keyof Parent>(this: void, keys: ReadonlyArray<Keys>, callback: () => MaybePromise<Parent>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<WithDefinedProperties<Parent, Keys>>;
     };
 };
 export {};

package/dist/assertions/keys.js

@@ -177,6 +177,62 @@ const assertions = {
             throw new AssertionError(`'${stringify(parent)}' does not lack keys '${existingKeys.join(',')}'.`, failureMessage);
         }
     },
+    /**
+     * Asserts that a parent object has the given property and that its value is defined (not `null`
+     * and not `undefined`).
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.hasDefinedProperty({a: 0, b: 1}, 'a'); // passes
+     * assert.hasDefinedProperty({a: undefined, b: 1}, 'a'); // fails
+     * assert.hasDefinedProperty({a: 0, b: 1}, 'c'); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If the property is missing or not defined.
+     * @see
+     * - {@link assert.hasDefinedProperties} : the multi-property assertion.
+     */
+    hasDefinedProperty(parent, key, failureMessage) {
+        if (parent[key] == undefined) {
+            throw new AssertionError(`'${stringify(parent)}' does not have a defined property '${String(key)}'.`, failureMessage);
+        }
+    },
+    /**
+     * Asserts that a parent object has all the given properties and that each of their values is
+     * defined (not `null` and not `undefined`).
+     *
+     * Type guards the parent value.
+     *
+     * @example
+     *
+     * ```ts
+     * import {assert} from '@augment-vir/assert';
+     *
+     * assert.hasDefinedProperties({a: 0, b: 1}, [
+     *     'a',
+     *     'b',
+     * ]); // passes
+     * assert.hasDefinedProperties({a: 0, b: undefined}, [
+     *     'a',
+     *     'b',
+     * ]); // fails
+     * ```
+     *
+     * @throws {@link AssertionError} If any of the properties are missing or not defined.
+     * @see
+     * - {@link assert.hasDefinedProperty} : the single-property assertion.
+     */
+    hasDefinedProperties(parent, keys, failureMessage) {
+        const undefinedKeys = keys.filter((key) => parent[key] == undefined);
+        if (undefinedKeys.length) {
+            throw new AssertionError(`'${stringify(parent)}' does not have defined properties '${undefinedKeys.join(',')}'.`, failureMessage);
+        }
+    },
 };
 export const keyGuards = {
     assert: assertions,
@@ -315,6 +371,55 @@ export const keyGuards = {
         lacksKeys(parent, keys) {
             return keys.every((key) => !hasKey(parent, key));
         },
+        /**
+         * Checks that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `true`
+         * check.hasDefinedProperty({a: undefined, b: 1}, 'a'); // returns `false`
+         * check.hasDefinedProperty({a: 0, b: 1}, 'c'); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.hasDefinedProperties} : the multi-property check.
+         */
+        hasDefinedProperty(parent, key) {
+            return parent[key] != undefined;
+        },
+        /**
+         * Checks that a parent object has all the given properties and that each of their values is
+         * defined (not `null` and not `undefined`).
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {check} from '@augment-vir/assert';
+         *
+         * check.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `true`
+         * check.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `false`
+         * ```
+         *
+         * @see
+         * - {@link check.hasDefinedProperty} : the single-property check.
+         */
+        hasDefinedProperties(parent, keys) {
+            return keys.every((key) => parent[key] != undefined);
+        },
     },
     assertWrap: {
         /**
@@ -488,6 +593,65 @@ export const keyGuards = {
             }
             return parent;
         },
+        /**
+         * Asserts that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`). Returns the parent if the assertion passes.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
+         * assertWrap.hasDefinedProperty({a: undefined, b: 1}, 'a'); // throws an error
+         * ```
+         *
+         * @returns The parent if the assertion passes.
+         * @throws {@link AssertionError} If the property is missing or not defined.
+         * @see
+         * - {@link assertWrap.hasDefinedProperties} : the multi-property assertion.
+         */
+        hasDefinedProperty(parent, key, failureMessage) {
+            if (parent[key] == undefined) {
+                throw new AssertionError(`'${stringify(parent)}' does not have a defined property '${String(key)}'.`, failureMessage);
+            }
+            return parent;
+        },
+        /**
+         * Asserts that a parent object has all the given properties and that each of their values
+         * is defined (not `null` and not `undefined`). Returns the parent if the assertion passes.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {assertWrap} from '@augment-vir/assert';
+         *
+         * assertWrap.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `{a: 0, b: 1}`
+         * assertWrap.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // throws an error
+         * ```
+         *
+         * @returns The parent if the assertion passes.
+         * @throws {@link AssertionError} If any of the properties are missing or not defined.
+         * @see
+         * - {@link assertWrap.hasDefinedProperty} : the single-property assertion.
+         */
+        hasDefinedProperties(parent, keys, failureMessage) {
+            const undefinedKeys = keys.filter((key) => parent[key] == undefined);
+            if (undefinedKeys.length) {
+                throw new AssertionError(`'${stringify(parent)}' does not have defined properties '${undefinedKeys.join(',')}'.`, failureMessage);
+            }
+            return parent;
+        },
     },
     checkWrap: {
         /**
@@ -668,6 +832,68 @@ export const keyGuards = {
                 return undefined;
             }
         },
+        /**
+         * Checks that a parent object has the given property and that its value is defined (not
+         * `null` and not `undefined`). Returns the parent value if the check passes, otherwise
+         * `undefined`.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.hasDefinedProperty({a: 0, b: 1}, 'a'); // returns `{a: 0, b: 1}`
+         * checkWrap.hasDefinedProperty({a: undefined, b: 1}, 'a'); // returns `undefined`
+         * ```
+         *
+         * @returns The parent value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.hasDefinedProperties} : the multi-property check.
+         */
+        hasDefinedProperty(parent, key) {
+            if (parent[key] == undefined) {
+                return undefined;
+            }
+            else {
+                return parent;
+            }
+        },
+        /**
+         * Checks that a parent object has all the given properties and that each of their values is
+         * defined (not `null` and not `undefined`). Returns the parent value if the check passes,
+         * otherwise `undefined`.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {checkWrap} from '@augment-vir/assert';
+         *
+         * checkWrap.hasDefinedProperties({a: 0, b: 1}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `{a: 0, b: 1}`
+         * checkWrap.hasDefinedProperties({a: 0, b: undefined}, [
+         *     'a',
+         *     'b',
+         * ]); // returns `undefined`
+         * ```
+         *
+         * @returns The parent value if the check passes, otherwise `undefined`.
+         * @see
+         * - {@link checkWrap.hasDefinedProperty} : the single-property check.
+         */
+        hasDefinedProperties(parent, keys) {
+            if (keys.every((key) => parent[key] != undefined)) {
+                return parent;
+            }
+            else {
+                return undefined;
+            }
+        },
     },
     waitUntil: {
         /**
@@ -846,5 +1072,69 @@ export const keyGuards = {
          * - {@link waitUntil.lacksKey} : the single-key assertion.
          */
         lacksKeys: createWaitUntil(assertions.lacksKeys),
+        /**
+         * Repeatedly calls a callback until its output is a parent object that has the first, key
+         * input defined (not `null` and not `undefined`). Once the callback output passes, it is
+         * returned. If the attempts time out, an error is thrown.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.hasDefinedProperty('a', () => {
+         *     return {a: 0, b: 1};
+         * }); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasDefinedProperty('a', () => {
+         *     return {a: undefined, b: 1};
+         * }); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.hasDefinedProperties} : the multi-property assertion.
+         */
+        hasDefinedProperty: createWaitUntil(assertions.hasDefinedProperty),
+        /**
+         * Repeatedly calls a callback until its output is a parent object that has all of the
+         * first, keys input defined (not `null` and not `undefined`). Once the callback output
+         * passes, it is returned. If the attempts time out, an error is thrown.
+         *
+         * Type guards the parent value.
+         *
+         * @example
+         *
+         * ```ts
+         * import {waitUntil} from '@augment-vir/assert';
+         *
+         * await waitUntil.hasDefinedProperties(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     () => {
+         *         return {a: 0, b: 1};
+         *     },
+         * ); // returns `{a: 0, b: 1}`
+         * await waitUntil.hasDefinedProperties(
+         *     [
+         *         'a',
+         *         'b',
+         *     ],
+         *     () => {
+         *         return {a: 0, b: undefined};
+         *     },
+         * ); // throws an error
+         * ```
+         *
+         * @returns The callback output once it passes.
+         * @throws {@link AssertionError} On timeout.
+         * @see
+         * - {@link waitUntil.hasDefinedProperty} : the single-property assertion.
+         */
+        hasDefinedProperties: createWaitUntil(assertions.hasDefinedProperties),
     },
 };

package/dist/assertions/primitive.js

@@ -1,4 +1,4 @@
-import { stringify } from '@augment-vir/core';
+import { isPrimitive, stringify } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
 import { createWaitUntil } from '../guard-types/wait-until-function.js';
 const assertions = {
@@ -77,11 +77,7 @@ const assertions = {
      * - {@link assert.isNotPrimitive} : the opposite assertion.
      */
     isPrimitive(actual, failureMessage) {
-        /**
-         * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-         * `null` here.
-         */
-        if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
+        if (!isPrimitive(actual)) {
             throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
         }
     },
@@ -106,11 +102,7 @@ const assertions = {
      * - {@link assert.isPrimitive} : the opposite assertion.
      */
     isNotPrimitive(actual, failureMessage) {
-        /**
-         * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-         * `null` here.
-         */
-        if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+        if (isPrimitive(actual)) {
             throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
         }
     },
@@ -138,11 +130,7 @@ export const primitiveGuards = {
          * - {@link check.isPrimitive} : the opposite check.
          */
         isNotPrimitive(actual) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            return actual !== null && (typeof actual === 'object' || typeof actual === 'function');
+            return !isPrimitive(actual);
         },
         /**
          * Checks that a value is _not_ a valid `PropertyKey`. `PropertyKey` is a built-in
@@ -188,11 +176,7 @@ export const primitiveGuards = {
          * - {@link check.isNotPrimitive} : the opposite check.
          */
         isPrimitive(actual) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            return actual === null || (typeof actual !== 'object' && typeof actual !== 'function');
+            return isPrimitive(actual);
         },
         /**
          * Checks that a value is _not_ a JavaScript
@@ -243,11 +227,7 @@ export const primitiveGuards = {
          * - {@link assertWrap.isNotPropertyKey} : the opposite assertion.
          */
         isNotPrimitive(actual, failureMessage) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+            if (isPrimitive(actual)) {
                 throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
             }
             return actual;
@@ -305,11 +285,7 @@ export const primitiveGuards = {
          * - {@link assertWrap.isNotPrimitive} : the opposite assertion.
          */
         isPrimitive(actual, failureMessage) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
+            if (!isPrimitive(actual)) {
                 throw new AssertionError(`'${stringify(actual)}' is not a Primitive.`, failureMessage);
             }
             return actual;
@@ -368,15 +344,11 @@ export const primitiveGuards = {
          * - {@link checkWrap.isPrimitive} : the opposite check.
          */
         isNotPrimitive(actual) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            if (actual !== null && (typeof actual === 'object' || typeof actual === 'function')) {
-                return actual;
+            if (isPrimitive(actual)) {
+                return undefined;
             }
             else {
-                return undefined;
+                return actual;
             }
         },
         /**
@@ -432,11 +404,7 @@ export const primitiveGuards = {
          * - {@link checkWrap.isNotPrimitive} : the opposite check.
          */
         isPrimitive(actual) {
-            /**
-             * `null` is a primitive but `typeof null` gives `'object'` so we have to special case
-             * `null` here.
-             */
-            if (actual === null || (typeof actual !== 'object' && typeof actual !== 'function')) {
+            if (isPrimitive(actual)) {
                 return actual;
             }
             else {

package/dist/augments/assertion-exports.d.ts

@@ -1,4 +1,5 @@
 export type { Falsy, FalsyValue, Truthy } from '../assertions/boolean.js';
+export type { CombineTypeWithKey, CombinedParentValue, ExtractValue, WithDefinedProperties, } from '../assertions/keys.js';
 export type { CustomOutputAsserter } from '../assertions/output.js';
 export type { ErrorMatchOptions } from '../assertions/throws.js';
 export type { CanBeEmpty, Empty } from '../assertions/values.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/assert",
-    "version": "31.71.4",
+    "version": "31.72.0",
     "description": "A collection of assertions for test and production code alike.",
     "keywords": [
         "augment",
@@ -42,7 +42,7 @@
         "test:update": "npm test"
     },
     "dependencies": {
-        "@augment-vir/core": "^31.71.4",
+        "@augment-vir/core": "^31.72.0",
         "@date-vir/duration": "^8.3.2",
         "deep-eql": "^5.0.2",
         "expect-type": "^1.3.0",