0
# is-type-of
1

2
is-type-of is a comprehensive type checking utility library for Node.js that provides complete type validation including primitive types, standard objects, and Node.js specific objects. It offers both ES Module and CommonJS compatibility with full TypeScript support including type guards for enhanced type safety in TypeScript applications.
3

4
## Package Information
5

6
- **Package Name**: is-type-of
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install is-type-of`
10

11
## Core Imports
12

13
```typescript
14
import is from "is-type-of";
15
import { isArray, isString, isNumber } from "is-type-of";
16
```
17

18
For CommonJS:
19

20
```javascript
21
const is = require("is-type-of");
22
const { isArray, isString } = require("is-type-of");
23
```
24

25
## Basic Usage
26

27
```typescript
28
import is from "is-type-of";
29
import { isArray, isString } from "is-type-of";
30

31
// Using the main is object
32
is.array([1, 2, 3]); // => true
33
is.string("hello"); // => true
34
is.primitive(42); // => true
35
is.primitive({}); // => false
36

37
// Using named imports
38
isArray([1, 2, 3]); // => true
39
isString("hello"); // => true
40

41
// Type guard usage in TypeScript
42
function processValue(value: string | number[]) {
43
  if (isArray(value)) {
44
    // value is now typed as number[]
45
    value.forEach(console.log);
46
  } else {
47
    // value is now typed as string
48
    console.log(value.toUpperCase());
49
  }
50
}
51
```
52

53
## Architecture
54

55
is-type-of is organized around several key concepts:
56

57
- **Central `is` Object**: Main namespace containing all type checking methods organized by category
58
- **Named Exports**: Individual functions for direct imports and tree-shaking
59
- **Type Guards**: All functions act as TypeScript type guards for compile-time type safety
60
- **Legacy Compatibility**: Deprecated exports maintain backward compatibility
61
- **Comprehensive Coverage**: Support for primitives, standard objects, Node.js objects, and external libraries
62

63
## Capabilities
64

65
### Primitive Type Checking
66

67
Complete type checking for JavaScript primitive types including strings, numbers, booleans, symbols, null, undefined, and bigint. Includes specialized number checkers for integers, safe integers, and doubles.
68

69
```typescript { .api }
70
// Core primitive checkers
71
function isString(val?: unknown): val is string;
72
function isNumber(val?: unknown): val is number;
73
function isBoolean(val?: unknown): val is boolean;
74
function isSymbol(val?: unknown): val is symbol;
75
function isUndefined(val?: unknown): val is undefined;
76
function isNull(val?: unknown): val is null;
77
function isBigInt(val?: unknown): val is bigint;
78

79
// Composite primitive checkers
80
function isNullable(val?: unknown): val is null | undefined;
81
function isPrimitive(val?: unknown): val is Primitive;
82

83
// Number specializations
84
function isInteger(val?: unknown): val is number;
85
function isInteger32(val?: unknown): val is number;
86
function isLong(val?: unknown): val is number;
87
function isSafeInteger(val?: unknown): val is number;
88
function isDouble(val?: unknown): val is number;
89
function isNaN(val?: unknown): boolean;
90
function isFinite(val?: unknown): val is number;
91
```
92

93
[Primitive Types](./primitive-types.md)
94

95
### Standard Object Type Checking
96

97
Type checking for standard JavaScript objects including arrays, functions, classes, dates, errors, regular expressions, generators, and promises.
98

99
```typescript { .api }
100
// Core object checkers
101
function isArray<T = any>(val?: unknown): val is Array<T>;
102
function isFunction<T extends Function>(val?: unknown): val is T;
103
function isObject(val?: unknown): val is object;
104
function isDate(val?: unknown): val is Date;
105
function isError(val?: unknown): val is Error;
106
function isRegExp(val?: unknown): val is RegExp;
107

108
// Function specializations
109
function isGeneratorFunction(val?: unknown): val is GeneratorFunction;
110
function isAsyncFunction(val?: unknown): val is Function;
111
function isAsyncGeneratorFunction(val?: unknown): val is AsyncGeneratorFunction;
112
function isClass<T extends Class>(val?: unknown): val is T;
113

114
// Advanced objects
115
function isGenerator(val?: unknown): val is Generator;
116
function isPromise<T = any>(val?: unknown): val is Promise<T>;
117
function isPromiseLike<T = any>(val?: unknown): val is PromiseLike<T>;
118
```
119

120
[Standard Objects](./standard-objects.md)
121

122
### Node.js Object Type Checking
123

124
Specialized type checking for Node.js specific objects including buffers and streams with support for readable, writable, and duplex streams.
125

126
```typescript { .api }
127
function isBuffer(val: unknown): val is Buffer;
128
function isStream(val?: unknown): val is Stream;
129
function isReadable(val?: unknown): val is Readable;
130
function isWritable(val?: unknown): val is Writable;
131
function isDuplex(val?: unknown): val is Duplex;
132
```
133

134
[Node.js Objects](./node-objects.md)
135

136
### External Object Type Checking
137

138
Type checking for objects from external libraries, currently supporting Long objects from the 'long' npm package.
139

140
```typescript { .api }
141
function isLongObject(obj?: unknown): obj is LongObject;
142

143
interface LongObject {
144
  high: number;
145
  low: number;
146
}
147
```
148

149
[External Objects](./external-objects.md)
150

151
### Utility Functions
152

153
Type-safe utility functions for advanced type checking scenarios.
154

155
```typescript { .api }
156
/**
157
 * Returns true if val is an instance of the given class constructor
158
 * @param val - Value to check
159
 * @param Clazz - Constructor function to check against
160
 * @returns Type guard indicating if value is instance of Clazz
161
 */
162
function isInstanceOf<T extends Class>(val: unknown, Clazz: T): val is InstanceType<T>;
163
```
164

165
**Usage Example:**
166

167
```typescript
168
import { isInstanceOf } from "is-type-of";
169

170
class MyClass {
171
  value: number;
172
  constructor(value: number) {
173
    this.value = value;
174
  }
175
}
176

177
const instance = new MyClass(42);
178
const obj = { value: 42 };
179

180
isInstanceOf(instance, MyClass); // => true
181
isInstanceOf(obj, MyClass);      // => false
182

183
// Type guard usage
184
function processValue(val: unknown) {
185
  if (isInstanceOf(val, MyClass)) {
186
    // val is now typed as MyClass
187
    console.log(val.value);
188
  }
189
}
190
```
191

192
## Central `is` Object
193

194
All type checking functions are available through the central `is` object:
195

196
```typescript { .api }
197
const is: {
198
  // Primitive types
199
  boolean: typeof isBoolean;
200
  number: typeof isNumber;
201
  string: typeof isString;
202
  symbol: typeof isSymbol;
203
  undefined: typeof isUndefined;
204
  null: typeof isNull;
205
  nullable: typeof isNullable;
206
  bigInt: typeof isBigInt;
207
  primitive: typeof isPrimitive;
208
  integer: typeof isInteger;
209
  integer32: typeof isInteger32;
210
  long: typeof isLong;
211
  double: typeof isDouble;
212
  finite: typeof isFinite;
213
  NaN: typeof isNaN;
214
  safeInteger: typeof isSafeInteger;
215

216
  // Standard objects
217
  function: typeof isFunction;
218
  generatorFunction: typeof isGeneratorFunction;
219
  asyncFunction: typeof isAsyncFunction;
220
  asyncGeneratorFunction: typeof isAsyncGeneratorFunction;
221
  class: typeof isClass;
222
  array: typeof isArray;
223
  object: typeof isObject;
224
  date: typeof isDate;
225
  error: typeof isError;
226
  regExp: typeof isRegExp;
227
  generator: typeof isGenerator;
228
  promise: typeof isPromise;
229
  promiseLike: typeof isPromiseLike;
230

231
  // Node.js objects
232
  buffer: typeof isBuffer;
233
  stream: typeof isStream;
234
  readable: typeof isReadable;
235
  writable: typeof isWritable;
236
  duplex: typeof isDuplex;
237

238
  // External objects
239
  longObject: typeof isLongObject;
240
};
241
```
242

243
## Type Definitions
244

245
```typescript { .api }
246
type Primitive = string | number | bigint | boolean | symbol | null | undefined;
247
type Nullable = null | undefined;
248
type Class = new (...args: any[]) => any;
249

250
interface LongObject {
251
  high: number;
252
  low: number;
253
}
254
```