feat: creating assertAndGetNonNullish

src/asserts.ts

@@ -44,6 +44,15 @@ export function assert<T, R extends T>(
 	if (!check(v)) throwError(errorCallOrMessage ?? 'invalid type');
 }
 
+export function assertAndGet<T, R extends T>(
+	v: T,
+	check: (x: T) => x is R,
+	errorCallOrMessage?: AssertError,
+): R {
+	assert(v, check, errorCallOrMessage);
+	return v;
+}
+
 export function assertNot<T, R extends T>(
 	v: T,
 	check: (x: T) => x is R,

src/getters.ts

@@ -1,7 +1,10 @@
-import { assertAndGetProperty } from './asserts';
+import { assertAndGet, assertAndGetProperty } from './asserts';
 import { isNonNullish, isString } from './guards';
 import { KeysOfType, Nullable, ObjectKeyType } from './types';
 
+export function assertAndGetNonNullish<T>(value: Nullable<T>): NonNullable<T> {
+	return assertAndGet(value, isNonNullish);
+}
 export function getDefinedProperty<T extends object, K extends keyof T>(
 	obj: T,
 	prop: K,

test/unit/getters.spec.ts

@@ -1,4 +1,8 @@
-import { assertAndGetStringProperty, getDefinedProperty } from '../../src';
+import {
+	assertAndGetNonNullish,
+	assertAndGetStringProperty,
+	getDefinedProperty,
+} from '../../src';
 
 describe('getters.ts', () => {
 	describe(getDefinedProperty.name, () => {
@@ -40,4 +44,36 @@ describe('getters.ts', () => {
 			expect(thrownError).toBeDefined();
 		});
 	});
+
+	describe(assertAndGetNonNullish.name, () => {
+		it('should return value when non nullish', () => {
+			const result = assertAndGetNonNullish('abc');
+
+			expect(result).toBe('abc');
+		});
+
+		it('should throw an error when informed value is null', () => {
+			let thrownError: any;
+
+			try {
+				assertAndGetNonNullish(null);
+			} catch (err) {
+				thrownError = err;
+			}
+
+			expect(thrownError).toBeDefined();
+		});
+
+		it('should throw an error when informed value is undefined', () => {
+			let thrownError: any;
+
+			try {
+				assertAndGetNonNullish(undefined);
+			} catch (err) {
+				thrownError = err;
+			}
+
+			expect(thrownError).toBeDefined();
+		});
+	});
 });