@augment-vir/assert 30.8.4 → 31.0.0

package/dist/assertions/keys.js

@@ -30,7 +30,6 @@ const hasKeyAttempts = [
 ];
 /** Check if an object has the given property. */
 function hasKey(parent, key, failureMessage) {
-    const message = `'${stringify(parent)}' does not have key '${String(key)}'.`;
     const doesHaveKey = hasKeyAttempts.some((attemptCallback) => {
         try {
             return attemptCallback(parent, key);
@@ -40,7 +39,7 @@ function hasKey(parent, key, failureMessage) {
         }
     });
     if (!doesHaveKey) {
-        throw new AssertionError(message, failureMessage);
+        throw new AssertionError(`'${stringify(parent)}' does not have key '${String(key)}'.`, failureMessage);
     }
 }
 function lacksKey(parent, key, failureMessage) {

package/dist/assertions/runtime-type.d.ts

@@ -1996,61 +1996,4 @@ export declare const runtimeTypeGuards: {
         isNotUndefined: <const Actual>(callback: () => MaybePromise<Actual>, options?: WaitUntilOptions | undefined, failureMessage?: string | undefined) => Promise<Exclude<Actual, undefined>>;
     };
 };
-/**
- * An enum representing the possible values returned by {@link getRuntimeType}. These values are
- * similar to the output of the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except that this includes new types `array` and `null`, that `typeof` does not have, which are
- * both distinct from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export declare enum RuntimeType {
-    String = "string",
-    Number = "number",
-    Bigint = "bigint",
-    Boolean = "boolean",
-    Symbol = "symbol",
-    Undefined = "undefined",
-    Object = "object",
-    Function = "function",
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    Array = "array",
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    Null = "null"
-}
-/**
- * Determines the {@link RuntimeType} of a variable. This is similar to the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except in the following ways:
- *
- * - This returns an enum value ({@link RuntimeType}) rather than just a string (though the enum values
- *   are strings anyway).
- * - This includes new types `array` and `null`, that `typeof` does not have, which are both distinct
- *   from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @example
- *
- * ```ts
- * import {getRuntimeType} from '@augment-vir/assert';
- *
- * getRuntimeType(['a']); // RuntimeType.Array
- * getRuntimeType({a: 'a'}); // RuntimeType.Object
- * ```
- *
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export declare function getRuntimeType(actual: unknown): RuntimeType;
 export {};

package/dist/assertions/runtime-type.js

@@ -2,67 +2,104 @@ import { stringify, } from '@augment-vir/core';
 import { AssertionError } from '../augments/assertion.error.js';
 import { autoGuard, autoGuardSymbol } from '../guard-types/guard-override.js';
 function isNotArray(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'array', failureMessage);
+    if (Array.isArray(actual)) {
+        throw new AssertionError(`'${stringify(actual)}' is an array.`, failureMessage);
+    }
 }
 function isNotBigInt(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'bigint', failureMessage);
+    if (typeof actual === 'bigint') {
+        throw new AssertionError(`'${stringify(actual)}' is a bigint.`, failureMessage);
+    }
 }
 function isNotBoolean(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'boolean', failureMessage);
+    if (typeof actual === 'boolean') {
+        throw new AssertionError(`'${stringify(actual)}' is a boolean.`, failureMessage);
+    }
 }
 function isNotFunction(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'function', failureMessage);
+    if (typeof actual === 'function') {
+        throw new AssertionError(`'${stringify(actual)}' is a function.`, failureMessage);
+    }
 }
 function isNotNumber(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'number', failureMessage);
+    if (typeof actual === 'number') {
+        throw new AssertionError(`'${stringify(actual)}' is a number.`, failureMessage);
+    }
 }
 function isNotObject(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'object', failureMessage);
+    if (!Array.isArray(actual) && typeof actual === 'object' && !!actual) {
+        throw new AssertionError(`'${stringify(actual)}' is a non-null object.`, failureMessage);
+    }
 }
 function isNotString(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'string', failureMessage);
+    if (typeof actual === 'string') {
+        throw new AssertionError(`'${stringify(actual)}' is a string.`, failureMessage);
+    }
 }
 function isNotSymbol(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'symbol', failureMessage);
+    if (typeof actual === 'symbol') {
+        throw new AssertionError(`'${stringify(actual)}' is a symbol.`, failureMessage);
+    }
 }
 function isNotUndefined(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'undefined', failureMessage);
+    if (typeof actual === 'undefined') {
+        throw new AssertionError(`'${stringify(actual)}' is a undefined.`, failureMessage);
+    }
 }
 function isNotNull(actual, failureMessage) {
-    assertNotRuntimeType(actual, 'null', failureMessage);
+    if (actual === null) {
+        throw new AssertionError(`'${stringify(actual)}' is a null.`, failureMessage);
+    }
 }
 function isArray(actual, failureMessage) {
-    assertRuntimeType(actual, 'array', failureMessage);
+    if (!Array.isArray(actual)) {
+        throw new AssertionError(`'${stringify(actual)}' is not an array.`, failureMessage);
+    }
 }
 function isBigInt(actual, failureMessage) {
-    assertRuntimeType(actual, 'bigint', failureMessage);
+    if (typeof actual !== 'bigint') {
+        throw new AssertionError(`'${stringify(actual)}' is not a bigint.`, failureMessage);
+    }
 }
 function isBoolean(actual, failureMessage) {
-    assertRuntimeType(actual, 'boolean', failureMessage);
+    if (typeof actual !== 'boolean') {
+        throw new AssertionError(`'${stringify(actual)}' is not a boolean.`, failureMessage);
+    }
 }
 function isFunction(actual, failureMessage) {
-    assertRuntimeType(actual, 'function', failureMessage);
+    if (typeof actual !== 'function') {
+        throw new AssertionError(`'${stringify(actual)}' is not a function.`, failureMessage);
+    }
 }
 export function isNumber(actual, failureMessage) {
-    assertRuntimeType(actual, 'number', failureMessage);
-    if (isNaN(actual)) {
-        throw new AssertionError('Value is NaN.', failureMessage);
+    if (typeof actual !== 'number' || isNaN(actual)) {
+        throw new AssertionError(`'${stringify(actual)}' is not a number.`, failureMessage);
     }
 }
 function isObject(actual, failureMessage) {
-    assertRuntimeType(actual, 'object', failureMessage);
+    if (Array.isArray(actual) || typeof actual !== 'object' || !actual) {
+        throw new AssertionError(`'${stringify(actual)}' is not a non-null object.`, failureMessage);
+    }
 }
 function isString(actual, failureMessage) {
-    assertRuntimeType(actual, 'string', failureMessage);
+    if (typeof actual !== 'string') {
+        throw new AssertionError(`'${stringify(actual)}' is not a string.`, failureMessage);
+    }
 }
 function isSymbol(actual, failureMessage) {
-    assertRuntimeType(actual, 'symbol', failureMessage);
+    if (typeof actual !== 'symbol') {
+        throw new AssertionError(`'${stringify(actual)}' is not a symbol.`, failureMessage);
+    }
 }
 function isUndefined(actual, failureMessage) {
-    assertRuntimeType(actual, 'undefined', failureMessage);
+    if (typeof actual !== 'undefined') {
+        throw new AssertionError(`'${stringify(actual)}' is not a undefined.`, failureMessage);
+    }
 }
 function isNull(actual, failureMessage) {
-    assertRuntimeType(actual, 'null', failureMessage);
+    if (actual !== null) {
+        throw new AssertionError(`'${stringify(actual)}' is not nul.`, failureMessage);
+    }
 }
 const assertions = {
     isArray,
@@ -1679,87 +1716,3 @@ export const runtimeTypeGuards = {
         isNotUndefined: autoGuard(),
     },
 };
-/**
- * An enum representing the possible values returned by {@link getRuntimeType}. These values are
- * similar to the output of the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except that this includes new types `array` and `null`, that `typeof` does not have, which are
- * both distinct from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export var RuntimeType;
-(function (RuntimeType) {
-    RuntimeType["String"] = "string";
-    RuntimeType["Number"] = "number";
-    RuntimeType["Bigint"] = "bigint";
-    RuntimeType["Boolean"] = "boolean";
-    RuntimeType["Symbol"] = "symbol";
-    RuntimeType["Undefined"] = "undefined";
-    RuntimeType["Object"] = "object";
-    RuntimeType["Function"] = "function";
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    RuntimeType["Array"] = "array";
-    /**
-     * This is not included in {@link RuntimeType.Object}. (Compared to
-     * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof)
-     * which _does_ include `null` in the `'object'` type.)
-     */
-    RuntimeType["Null"] = "null";
-})(RuntimeType || (RuntimeType = {}));
-/**
- * Determines the {@link RuntimeType} of a variable. This is similar to the built-in
- * [`typeof`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators/typeof) operator
- * except in the following ways:
- *
- * - This returns an enum value ({@link RuntimeType}) rather than just a string (though the enum values
- *   are strings anyway).
- * - This includes new types `array` and `null`, that `typeof` does not have, which are both distinct
- *   from `object`.
- *
- * @category Assert : Util
- * @category Package : @augment-vir/assert
- * @example
- *
- * ```ts
- * import {getRuntimeType} from '@augment-vir/assert';
- *
- * getRuntimeType(['a']); // RuntimeType.Array
- * getRuntimeType({a: 'a'}); // RuntimeType.Object
- * ```
- *
- * @package [`@augment-vir/assert`](https://www.npmjs.com/package/@augment-vir/assert)
- */
-export function getRuntimeType(actual) {
-    if (actual === null) {
-        return RuntimeType.Null;
-    }
-    else if (Array.isArray(actual)) {
-        return RuntimeType.Array;
-    }
-    else {
-        return typeof actual;
-    }
-}
-/**
- * Asserts that the given actual matches the given test type. Note that an name for the actual must
- * be provided for error messaging purposes.
- */
-function assertRuntimeType(actual, testType, failureMessage) {
-    const actualType = getRuntimeType(actual);
-    if (actualType !== testType) {
-        throw new AssertionError(`'${stringify(actual)}' is '${actualType}', not '${testType}'.`, failureMessage);
-    }
-}
-function assertNotRuntimeType(actual, testType, failureMessage) {
-    const actualType = getRuntimeType(actual);
-    if (actualType === testType) {
-        throw new AssertionError(`'${stringify(actual)}' is '${actualType}'.`, failureMessage);
-    }
-}

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

@@ -1,5 +1,4 @@
 export type { Falsy, FalsyValue, Truthy } from '../assertions/boolean.js';
 export type { CustomOutputAsserter } from '../assertions/output.js';
-export { RuntimeType, getRuntimeType } from '../assertions/runtime-type.js';
 export type { ErrorMatchOptions } from '../assertions/throws.js';
 export type { CanBeEmpty, Empty } from '../assertions/values.js';

package/dist/augments/assertion-exports.js

@@ -1 +1 @@
-export { RuntimeType, getRuntimeType } from '../assertions/runtime-type.js';
+export {};

package/package.json

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