1.1.0

CHANGELOG.md

@@ -0,0 +1,20 @@
+# 1.0.0
+
+- initial release
+
+### 1.0.1
+
+- update readme
+
+## 1.1.0
+
+- add isBigInt
+- isNotNullish
+- isNotNull
+- isDefined
+- assertIsBigInt
+- assertIsNotNullish
+- assertIsNotNull
+- assertIsDefined
+- renamed isNullOrUndefined to isNullish
+- renamed assertIsNullOrUndefined to assertIsNullish

README.md

@@ -24,7 +24,7 @@ yarn add @tool-belt/type-predicates
 This package includes the following:
 
 - a comprehensive collection of performant and flexible type-guards, that can function as a drop-in replacement for 
-  the type-guards included in the NodeJS builtin `utils/types` module - with better typing.
+  the type-guards included in the NodeJS builtin `utils/types` module - with better significantly typing.
 - a comprehensive collection of type assertions covering all type-guards included in the package.
 - `isUnion`, `createTypeGuard` and `createTypeAssertion` utilities for the composition of type-guards and assertions.
 - supports ES modules and tree shaking, i.e., works great with module bundlers such as Webpack for the browser.

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tool-belt/type-predicates",
-    "version": "1.0.1",
+    "version": "1.1.0",
     "description": "Collection of performant type-guard utilities",
     "repository": {
         "type": "git",
@@ -44,10 +44,9 @@
     "devDependencies": {
         "@rollup/plugin-typescript": "^8.2.5",
         "@sprylab/eslint-config": "^1.5.4",
-        "@types/jest": "^26.0.24",
-        "@types/node": "^16.4.7",
+        "@types/jest": "^27.0.1",
         "all-contributors-cli": "^6.20.0",
-        "eslint": "^7.31.0",
+        "eslint": "^7.32.0",
         "eslint-plugin-tsdoc": "^0.2.14",
         "expect-type": "^0.12.0",
         "husky": ">=7",
@@ -56,11 +55,10 @@
         "prettier": "^2.3.2",
         "prettier-plugin-jsdoc": "^0.3.23",
         "rimraf": "^3.0.2",
-        "rollup": "^2.56.0",
+        "rollup": "^2.56.2",
         "rollup-plugin-terser": "^7.0.2",
         "ts-jest": "^27.0.4",
-        "ts-node": "^10.1.0",
-        "type-fest": "^1.4.0",
+        "ts-node": "^10.2.0",
         "typedoc": "^0.21.5",
         "typescript": "^4.3.5"
     },

src/assertions/assertIsAnyArrayBuffer.ts

@@ -2,25 +2,8 @@ import { createTypeAssertion } from '../utils';
 import { isAnyArrayBuffer } from '../guards/isAnyArrayBuffer';
 
 /**
- * Asserts that input is either ArrayBuffer or SharedArrayBuffer object
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as ArrayBuffer | SharedArrayBuffer
- * assertIsAnyArrayBuffer(new SharedArrayBuffer());
- *
- * // does not throw, value is typed as ArrayBuffer | SharedArrayBuffer
- * assertIsAnyArrayBuffer(new ArrayBuffer());
- *
- * // throws
- * assertIsAnyArrayBuffer([]);
- *
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export const assertIsAnyArrayBuffer = createTypeAssertion<
     ArrayBuffer | SharedArrayBuffer

src/assertions/assertIsArray.ts

@@ -3,8 +3,6 @@ import { createTypeAssertion } from '../utils';
 import { isArray } from '../guards/isArray';
 
 /**
- * Asserts that input is Array<T> object
- *
  * @category Type Assertion
  * @example
  *
@@ -17,15 +15,8 @@ import { isArray } from '../guards/isArray';
  *
  * // throws
  * assertIsArray<string>(['xyz', 1], { valueValidator: isString });
- *
- * // throws
- * assertIsArray<string>('abc', { valueValidator: isString });
  * ```
  *
- * @typeParam T - Type of A value
- * @param input - Value to be tested
- * @param options - Optional valueValidator
- * @returns Void
  * @throws TypeError
  */
 export function assertIsArray(input: unknown): asserts input is any[];

src/assertions/assertIsArrayBuffer.ts

@@ -2,22 +2,8 @@ import { createTypeAssertion } from '../utils';
 import { isArrayBuffer } from '../guards/isArrayBuffer';
 
 /**
- * Asserts that input is ArrayBuffer object
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as ArrayBuffer
- * assertIsArrayBuffer(new ArrayBuffer());
- *
- * // throws
- * assertIsArrayBuffer([]);
- *
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export const assertIsArrayBuffer =
     createTypeAssertion<ArrayBuffer>(isArrayBuffer);

src/assertions/assertIsAsyncFunction.ts

@@ -2,29 +2,10 @@ import { AsyncFunction, isAsyncFunction } from '../guards/isAsyncFunction';
 import { createTypeAssertion } from '../utils';
 
 /**
- * Asserts that input is AsyncFunction<T> object
- *
  * @remarks
- * - This assertion works only in ES2018 and above
- *
+ * This assertion works only in ES2018 and above
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as AsyncFunction<unknown>
- * assertIsAsyncFunction(async () => await Promise.resolve())
- *
- * // does not throw, value is typed as AsyncFunction<boolean>
- * assertIsAsyncFunction<boolean>(async () => await Promise.resolve(true))
- *
- * // throws
- * assertIsAsyncFunction([]);
- *
- * @typeParam T - Type of Promise return value, defaults to unknown
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export function assertIsAsyncFunction<T = unknown>(
     input: unknown,

src/assertions/assertIsAsyncGenerator.ts

@@ -2,39 +2,10 @@ import { createTypeAssertion } from '../utils';
 import { isAsyncGenerator } from '../guards/isAsyncGenerator';
 
 /**
- * Asserts that input is AsyncGenerator<Y, R, N> object
- *
  * @remarks
- * - This assertion works only in ES2018 and above
- *
+ * This assertion works only in ES2018 and above
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as AsyncGenerator<unknown, unknown, unknown>
- * assertIsAsyncGenerator((async function* () {
- *     while (true) {
- *         yield await Promise.resolve(true);
- *     }
- * })());
- *
- * // does not throw, value is typed as AsyncGenerator<boolean, unknown, unknown>
- * assertIsAsyncGenerator<boolean>((async function* () {
- *     while (true) {
- *         yield await Promise.resolve(true);
- *     }
- * })());
- *
- * // throws
- * assertIsAsyncGenerator((function* () {})());
- *
- * @typeParam Y - Type of yield value, defaults to unknown
- * @typeParam R - Type of return value, defaults to unknown
- * @typeParam N - Type of .next() args, defaults to unknown
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export function assertIsAsyncGenerator<Y = unknown, R = unknown, N = unknown>(
     input: unknown,

src/assertions/assertIsAsyncGeneratorFunction.ts

@@ -5,39 +5,8 @@ import {
 import { createTypeAssertion } from '../utils';
 
 /**
- * Asserts that input is TypedAsyncGeneratorFunction<Y, R, N> object
- *
- * @remarks
- * - This assertion works only in ES2018 and above
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as TypedAsyncGeneratorFunction<unknown, unknown, unknown>
- * assertIsAsyncGeneratorFunction(async function* () {
- *     while (true) {
- *         yield await Promise.resolve(true);
- *     }
- * });
- *
- * // does not throw, value is typed as TypedAsyncGeneratorFunction<boolean, unknown, unknown>
- * assertIsAsyncGeneratorFunction(async function* () {
- *     while (true) {
- *         yield await Promise.resolve(true);
- *     }
- * });
- *
- * // throws
- * assertIsAsyncGeneratorFunction(function* () {});
- *
- * @typeParam Y - Type of yield value, defaults to unknown
- * @typeParam R - Type of return value, defaults to unknown
- * @typeParam N - Type of .next() args, defaults to unknown
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export function assertIsAsyncGeneratorFunction<
     Y = unknown,

src/assertions/assertIsAsyncIterable.ts

@@ -2,34 +2,11 @@ import { createTypeAssertion } from '../utils';
 import { isAsyncIterable } from '../guards/isAsyncIterable';
 
 /**
- * Asserts that input is AsyncIterable<T> object
- *
  * @remarks
- * - This guard tests for Symbol.asyncIterator. See:
- *   {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator}
- *
+ * This guard tests for Symbol.asyncIterator. See:
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator}
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as AsyncIterable<unknown>
- * assertIsAsyncIterable((async function* () {
- *   yield Promise.resolve(true);
- * }()))
- *
- * // does not throw, value is typed as AsyncIterable<boolean>
- * assertIsAsyncIterable<boolean>((async function* () {
- *   yield Promise.resolve(true);
- * }()))
- *
- * // throws
- * assertIsAsyncIterable({});
- *
- * @typeParam T - Type of AsyncIterable, defaults to unknown
- * @param input - Value to be tested
- * @returns void
  * @throws TypeError
- * ```
  */
 export function assertIsAsyncIterable<T = unknown>(
     input: unknown,

src/assertions/assertIsBigInt.ts

@@ -0,0 +1,18 @@
+import { createTypeAssertion } from '../utils';
+import { isBigInt } from '../guards/isBigInt';
+
+/**
+ * @category Type Assertion
+ * @example
+ *
+ * ```typescript
+ * // does not throw
+ * assertIsBigInt(BigInt(9007199254740991));
+ *
+ * // throws
+ * assertIsBigInt(9007199254740991n);
+ * ```
+ *
+ * @throws TypeError
+ */
+export const assertIsBigInt = createTypeAssertion<bigint>(isBigInt);

src/assertions/assertIsBoolean.ts

@@ -2,21 +2,7 @@ import { createTypeAssertion } from '../utils';
 import { isBoolean } from '../guards/isBoolean';
 
 /**
- * Asserts that input is boolean primitive
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as boolean
- * assertIsBoolean(false);
- *
- * // throws
- * assertIsBoolean(null);
- * ```
- *
- * @param input - Value to be tested
- * @returns Void
  * @throws TypeError
  */
 export const assertIsBoolean = createTypeAssertion<boolean>(isBoolean);

src/assertions/assertIsBooleanObject.ts

@@ -2,21 +2,7 @@ import { createTypeAssertion } from '../utils';
 import { isBooleanObject } from '../guards/isBooleanObject';
 
 /**
- * Asserts that input is Boolean object
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as Boolean
- * assertIsBooleanObject(new Boolean(false));
- *
- * // throws
- * assertIsBooleanObject(false);
- * ```
- *
- * @param input - Value to be tested
- * @returns Void
  * @throws TypeError
  */
 export const assertIsBooleanObject =

src/assertions/assertIsBuffer.ts

@@ -2,21 +2,7 @@ import { createTypeAssertion } from '../utils';
 import { isBuffer } from '../guards/isBuffer';
 
 /**
- * Asserts that input is Buffer object
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as Buffer
- * assertIsBuffer(Buffer.alloc(8);
- *
- * // throws
- * assertIsBuffer('abc');
- * ```
- *
- * @param input - Value to be tested
- * @returns Void
  * @throws TypeError
  */
 export const assertIsBuffer = createTypeAssertion<Buffer>(isBuffer);

src/assertions/assertIsDataView.ts

@@ -2,21 +2,7 @@ import { createTypeAssertion } from '../utils';
 import { isDataView } from '../guards/isDataView';
 
 /**
- * Asserts that input is DataView object
- *
  * @category Type Assertion
- * @example
- *
- * ```typescript
- * // does not throw, value is typed as DataView
- * assertIsDataView(new DateView(new ArrayBuffer(8));
- *
- * // throws
- * assertIsDataView('abc');
- * ```
- *
- * @param input - Value to be tested
- * @returns Void
  * @throws TypeError
  */
 export const assertIsDataView = createTypeAssertion<DataView>(isDataView);