3.2.x

packages/type/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-package/type",
-  "version": "3.1.2",
+  "version": "3.2.1",
   "description": "Common types, type guards and type checkers.",
   "author": "Angular Package <[email protected]> (https://wvvw.dev)",
   "homepage": "https://github.com/angular-package/type#readme",

packages/type/src/guard/index.ts

@@ -1,10 +1,18 @@
+// `guard` object.
 export { guard } from './lib/guard.object';
-
-export { guardArray } from './lib/guard-array.func.type';
+// `guard` prefix functions,
+export { guardArray } from './lib/guard-array.func';
+export { guardBigInt } from './lib/guard-big-int.func';
+export { guardBoolean } from './lib/guard-boolean.func';
 export { guardFunction } from './lib/guard-function.func';
+export { guardInstance } from './lib/guard-instance.func';
+export { guardKey } from './lib/guard-key.func';
 export { guardNumber } from './lib/guard-number.func';
-export { guardObjectKey } from './lib/guard-object-key.func';
+export { guardNull } from './lib/guard-null.func';
 export { guardObject } from './lib/guard-object.func';
+export { guardObjectKey } from './lib/guard-object-key.func';
 export { guardPrimitive } from './lib/guard-primitive.func';
 export { guardString } from './lib/guard-string.func';
+export { guardSymbol } from './lib/guard-symbol.func';
 export { guardType } from './lib/guard-type.func';
+export { guardUndefined } from './lib/guard-undefined.func';

packages/type/src/guard/interface/guard-is.interface.ts

@@ -1,22 +1,33 @@
-
 import { GuardArray } from '../type/guard-array.type';
+import { GuardBigInt } from '../type/guard-big-int.type';
+import { GuardBoolean } from '../type/guard-boolean.type';
 import { GuardFunction } from '../type/guard-function.type';
+import { GuardKey } from '../type/guard-key.type';
 import { GuardNumber } from '../type/guard-number.type';
+import { GuardObject } from '../type/guard-object.type';
 import { GuardObjectKey } from '../type/guard-object-key.type';
 import { GuardPrimitive } from '../type/guard-primitive.type';
 import { GuardString } from '../type/guard-string.type';
 import { GuardType } from '../type/guard-type.type';
-import { GuardObject } from '../type/guard-object.type';
+import { GuardInstance } from '../type/guard-instance.type';
+import { GuardNull } from '../type/guard-null.type';
+import { GuardSymbol } from '../type/guard-symbol.type';
+import { GuardUndefined } from '../type/guard-undefined.type';
 
 export interface GuardIs {
   array: GuardArray;
+  bigint: GuardBigInt;
+  boolean: GuardBoolean;
   function: GuardFunction;
-  // TODO: Guard not
-  // not: GuardNotIs;
+  instance: GuardInstance;
+  key: GuardKey;
+  null: GuardNull;
   number: GuardNumber;
   object: GuardObject;
   objectKey: GuardObjectKey;
   primitive: GuardPrimitive;
   string: GuardString;
+  symbol: GuardSymbol;
   type: GuardType;
+  undefined: GuardUndefined;
 }

packages/type/src/guard/lib/guard-array.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isArray } from '../../is/lib/is-array.func';
+// Type.
+import { GuardArray } from '../type/guard-array.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be an `Array` of a generic `Type`.
+ * @param value A generic `Type` `Array` `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is an `Array` of a generic `Type`.
+ */
+export const guardArray: GuardArray = <Type>(value: Array<Type>, callback?: ResultCallback): value is Array<Type> =>
+  isArray<Type>(value, callback);

packages/type/src/guard/lib/guard-big-int.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isBigInt } from '../../is/lib/is-big-int.func';
+// Type.
+import { GuardBigInt } from '../type/guard-big-int.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be a `bigint`.
+ * @param value A `bigint` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `bigint`.
+ */
+export const guardBigInt: GuardBigInt = (value: bigint, callback?: ResultCallback): value is bigint =>
+  isBigInt(value, callback);

packages/type/src/guard/lib/guard-boolean.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isBoolean } from '../../is/lib/is-boolean.func';
+// Type.
+import { GuardBoolean } from '../type/guard-boolean.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be a `boolean`.
+ * @param value A `boolean` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `boolean`.
+ */
+export const guardBoolean: GuardBoolean = (value: boolean, callback?: ResultCallback): value is boolean =>
+  isBoolean(value, callback);

packages/type/src/guard/lib/guard-function.func.ts

@@ -1,9 +1,14 @@
-import { GuardFunction } from '../type/guard-function.type';
+// Function.
 import { isFunction } from '../../is/lib/is-function.func';
+// Type.
+import { GuardFunction } from '../type/guard-function.type';
 import { Func } from '../../type/func.type';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `func` value to be a `Func` type.
- * @param func `Func` type value to guard.
- * @returns boolean.
+ * Guard the `value` to be a `Func` type.
+ * @param value A `Func` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `Func`.
  */
-export const guardFunction: GuardFunction = (func: Func): func is Func => isFunction(func);
+export const guardFunction: GuardFunction = (value: Func, callback?: ResultCallback): value is Func =>
+  isFunction(value, callback);

packages/type/src/guard/lib/guard-instance.func.ts

@@ -0,0 +1,15 @@
+// Function.
+import { isInstance } from '../../is/lib/is-instance.func';
+// Type.
+import { Constructor } from '../../type/constructor.type';
+import { GuardInstance } from '../type/guard-instance.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to guard the `value` to be an `object` of a generic `Obj` type equal to an `instance`.
+ * @param value An `Obj` type `value` to compare with the `instance`.
+ * @param instance A generic `Obj` `Constructor` type to create an `instance` to compare with the `value`.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `symbol`.
+ */
+export const guardInstance: GuardInstance = <Obj>(value: Obj, instance: Constructor<Obj>, callback?: ResultCallback): value is Obj =>
+  isInstance<Obj>(value, instance, callback);

packages/type/src/guard/lib/guard-is.object.ts

@@ -1,21 +1,36 @@
-import { GuardIs } from '../interface/guard-is.interface';
-import { guardArray } from './guard-array.func.type';
+// Function.
+import { guardArray } from './guard-array.func';
+import { guardBigInt } from './guard-big-int.func';
+import { guardBoolean } from './guard-boolean.func';
 import { guardFunction } from './guard-function.func';
+import { guardInstance } from './guard-instance.func';
+import { guardKey } from './guard-key.func';
+import { guardNull } from './guard-null.func';
 import { guardNumber } from './guard-number.func';
 import { guardObject } from './guard-object.func';
 import { guardObjectKey } from './guard-object-key.func';
 import { guardPrimitive } from './guard-primitive.func';
 import { guardString } from './guard-string.func';
+import { guardSymbol } from './guard-symbol.func';
 import { guardType } from './guard-type.func';
-
+import { guardUndefined } from './guard-undefined.func';
+// Interface.
+import { GuardIs } from '../interface/guard-is.interface';
+// `guardIs`.
 export const guardIs: GuardIs = {
-  // TODO: add other guards etc. boolean, null, undefined
   array: guardArray,
+  bigint: guardBigInt,
+  boolean: guardBoolean,
   function: guardFunction,
+  instance: guardInstance,
+  key: guardKey,
   number: guardNumber,
-  objectKey: guardObjectKey,
+  null: guardNull,
   object: guardObject,
+  objectKey: guardObjectKey,
   primitive: guardPrimitive,
   string: guardString,
-  type: guardType
+  symbol: guardSymbol,
+  type: guardType,
+  undefined: guardUndefined
 };

packages/type/src/guard/lib/guard-key.func.ts

@@ -0,0 +1,14 @@
+// Function.
+import { isKey } from '../../is/lib/is-key.func';
+// Type.
+import { GuardKey } from '../type/guard-key.type';
+import { Key } from '../../type/key.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be one of the `string`, `number`, or `symbol`.
+ * @param value A `Key` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `Key`.
+ */
+export const guardKey: GuardKey = (value: Key, callback?: ResultCallback): value is Key =>
+  isKey(value, callback);

packages/type/src/guard/lib/guard-null.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isNull } from '../../is/lib/is-null.func';
+// Type.
+import { GuardNull } from '../type/guard-null.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be a `null`.
+ * @param value A `null` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `null`.
+ */
+export const guardNull: GuardNull = (value: null, callback?: ResultCallback): value is null =>
+  isNull(value, callback);

packages/type/src/guard/lib/guard-number.func.ts

@@ -1,9 +1,13 @@
+// Function.
 import { isNumber } from '../../is/lib/is-number.func';
+// Type.
 import { GuardNumber } from '../type/guard-number.type';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `number` type.
- * Use `isNumber()` function for check ONLY.
- * @param value Type `number` value to guard.
- * @returns boolean
+ * Guard the `value` to be a `number`.
+ * @param value A `number` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `number`.
  */
-export const guardNumber: GuardNumber = (value: number): value is number => isNumber(value);
+export const guardNumber: GuardNumber = (value: number, callback?: ResultCallback): value is number =>
+  isNumber(value, callback);

packages/type/src/guard/lib/guard-object-key.func.ts

@@ -1,12 +1,13 @@
+// Function.
 import { guardObject } from './guard-object.func';
+import { isKey } from '../../is/lib/is-key.func';
+// Type.
 import { GuardObjectKey } from '../type/guard-object-key.type';
-import { isString } from '../../is/lib/is-string.func';
 /**
- * Guard the `object` to be a generic `Obj` type and to contains the `key` property.
- * Use `isObject()` function for check ONLY.
- * @param object Generic `Obj` type `value` that contains the `key` property to guard.
- * @param key Name of the property that the `object` contains.
- * @returns boolean
+ * Guard the `value` to be an `object` of a generic `Obj` type that contains the `key` property of the `Key` type.
+ * @param value A generic `Obj` type `value` that contains the `key` to guard.
+ * @param key A `Key` type name of the property that the `value` contains.
+ * @returns A `boolean` indicating whether or not the `value` is an `object` of a generic `Obj` containing the `Key`.
  */
-export const guardObjectKey: GuardObjectKey = <Obj, Key extends keyof Obj>(object: Obj, key: Key): object is Obj =>
-  guardObject<Obj>(object) ? isString(key) ? key in object : true : false;
+export const guardObjectKey: GuardObjectKey = <Obj extends object, Key extends keyof Obj>(value: Obj, key: Key): value is Obj =>
+  guardObject<Obj>(value) ? isKey(key) ? key in value : true : false;

packages/type/src/guard/lib/guard-object.func.ts

@@ -1,9 +1,13 @@
-import { GuardObject } from '../type/guard-object.type';
+// Function.
 import { isObject } from '../../is/lib/is-object.func';
+// Type.
+import { GuardObject } from '../type/guard-object.type';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `obj` value to be a generic object `Obj`.
- * Use `isObject()` function for check ONLY.
- * @param object Generic `Obj` type value to guard.
- * @returns boolean
+ * Guard the `value` to be an `object` of a generic `Obj` type.
+ * @param value A generic `Obj` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is an `object` of a generic `Obj`.
  */
-export const guardObject: GuardObject = <Obj>(object: Obj): object is Obj => isObject<Obj>(object);
+export const guardObject: GuardObject = <Obj extends object>(value: Obj, callback?: ResultCallback): value is Obj =>
+  isObject<Obj>(value);

packages/type/src/guard/lib/guard-primitive.func.ts

@@ -1,10 +1,17 @@
+// Function.
+import { isPrimitive } from '../../is/lib/is-primitive.func';
+// Type.
 import { GuardPrimitive } from '../type/guard-primitive.type';
+import { Primitive } from '../../type/primitive.type';
 import { Primitives } from '../../type/primitives.type';
-import { isPrimitive } from '../../is/lib/is-primitive.func';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a generic `Type` from one of the `Primitives`.
- * Use `isPrimitive()` function for check ONLY.
- * @param value A generic `Type` type value to guard.
- * @param type One of the `Primitives` `'boolean'`, `'bigint'`, `'number'`, `'string'`, `'symbol'`, `'undefined'` to check `value`.
+ * Guard the `value` to be the `Primitive` from a `type` of the `Primitives`.
+ * @param value A `Primitive` type `value` to guard.
+ * @param type A `string` type from the `Primitives` to check the `value`.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is the `Primitive` from the `type`.
  */
-export const guardPrimitive: GuardPrimitive = <Type>(value: Type, type: Primitives): value is Type => isPrimitive(value, type);
+export const guardPrimitive: GuardPrimitive =
+  <Type extends Primitive>(value: Type, type: Primitives, callback?: ResultCallback): value is Type => 
+    isPrimitive<Type>(value, type, callback);

packages/type/src/guard/lib/guard-string.func.ts

@@ -1,8 +1,13 @@
-import { GuardString } from '../type/guard-string.type';
+// Function.
 import { isString } from '../../is/lib/is-string.func';
+// Type.
+import { GuardString } from '../type/guard-string.type';
+import { ResultCallback } from '../../type/result-callback.type';
 /**
- * Guard the `value` to be a `string` type.
- * Use `isString()` function for check ONLY.
- * @param value String type value to guard.
+ * Guard the `value` to be a `string`.
+ * @param value A `string` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `string`.
  */
-export const guardString: GuardString = (value: string): value is string => isString(value);
+export const guardString: GuardString = (value: string, callback?: ResultCallback): value is string =>
+  isString(value, callback);

packages/type/src/guard/lib/guard-symbol.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isSymbol } from '../../is/lib/is-symbol.func';
+// Type.
+import { GuardSymbol } from '../type/guard-symbol.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be a `symbol`.
+ * @param value A `symbol` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a `symbol`.
+ */
+export const guardSymbol: GuardSymbol = (value: symbol, callback?: ResultCallback): value is symbol =>
+  isSymbol(value, callback);

packages/type/src/guard/lib/guard-type.func.ts

@@ -1,10 +1,16 @@
+// Function.
 import { isType } from '../../is/lib/is-type.func';
+// Type.
 import { GuardType } from '../type/guard-type.type';
+import { ResultCallback } from '../../type/result-callback.type';
+import { Type } from '../../type/type.type';
 import { Types } from '../../type/types.type';
 /**
- * Guard the `value` to be a generic `Type` type from one of the `Types` type.
- * Use `isType()` function for check ONLY.
- * @param value A generic `Type` value to guard.
- * @param type Constructor generic `Type`, `'function'`, `'object'` or one of the `Primitives` `'boolean'`, `'bigint'`, `'number'`, `'string'`, `'symbol'`, `'undefined'` to check `value`.
+ * Guard the `value` to be the `Type` from a `type` of the `Types`.
+ * @param value A `Type` `value` to guard with the `type`.
+ * @param type A `string` or generic `Constructor` type from the `Types` to check the `value`.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is a type from the `Types`.
  */
-export const guardType: GuardType = <Type>(value: Type, type: Types<Type>): value is Type => isType<Type>(value, type);
+export const guardType: GuardType = <T extends Type>(value: T, type: Types<T>, callback?: ResultCallback): value is T  =>
+  isType<T>(value, type, callback);

packages/type/src/guard/lib/guard-undefined.func.ts

@@ -0,0 +1,13 @@
+// Function.
+import { isUndefined } from '../../is/lib/is-undefined.func';
+// Type.
+import { GuardUndefined } from '../type/guard-undefined.type';
+import { ResultCallback } from '../../type/result-callback.type';
+/**
+ * Guard the `value` to be `undefined`.
+ * @param value A `undefined` type `value` to guard.
+ * @param callback Optional `ResultCallback` function to handle result before returns.
+ * @returns A `boolean` indicating whether or not the `value` is `undefined`.
+ */
+export const guardUndefined: GuardUndefined = (value: undefined, callback?: ResultCallback): value is undefined =>
+  isUndefined(value, callback);