0
# Type Checking Utilities
1

2
Comprehensive runtime type validation utilities for JavaScript/TypeScript applications, providing 28 functions to check data types, formats, and object characteristics with full type guard support.
3

4
## Capabilities
5

6
### Basic Type Checking
7

8
Core type validation functions with TypeScript type guards.
9

10
```typescript { .api }
11
/**
12
 * Checks if value is a string
13
 */
14
function isString(value: unknown): value is string;
15

16
/**
17
 * Checks if value is a number (excluding NaN)
18
 */
19
function isNumber(value: unknown): value is number;
20

21
/**
22
 * Checks if value is a boolean
23
 */
24
function isBoolean(value: unknown): value is boolean;
25

26
/**
27
 * Checks if value is an array
28
 */
29
function isArray(value: unknown): value is unknown[];
30

31
/**
32
 * Checks if value is an object (excluding null and arrays)
33
 */
34
function isObject(value: unknown): value is Record<string, unknown>;
35

36
/**
37
 * Checks if value is a function
38
 */
39
function isFunction(value: unknown): value is Function;
40

41
/**
42
 * Checks if value is null
43
 */
44
function isNull(value: unknown): value is null;
45

46
/**
47
 * Checks if value is undefined
48
 */
49
function isUndefined(value: unknown): value is undefined;
50

51
/**
52
 * Checks if value is an Error instance
53
 */
54
function isError(value: unknown): value is Error;
55
```
56

57
### Specialized Type Checking
58

59
Advanced type checking for specific data types and formats.
60

61
```typescript { .api }
62
/**
63
 * Checks if value is a BigInt
64
 */
65
function isBigInt(value: unknown): value is bigint;
66

67
/**
68
 * Checks if value is a BN (big number) instance
69
 */
70
function isBn(value: unknown): value is BN;
71

72
/**
73
 * Checks if value is a Uint8Array
74
 */
75
function isU8a(value: unknown): value is Uint8Array;
76

77
/**
78
 * Checks if value is a Buffer
79
 */
80
function isBuffer(value: unknown): value is Buffer;
81

82
/**
83
 * Checks if value is a Promise
84
 */
85
function isPromise(value: unknown): value is Promise<unknown>;
86

87
/**
88
 * Checks if value is an Observable (RxJS-like)
89
 */
90
function isObservable(value: unknown): value is Observable;
91
```
92

93
### Format Validation
94

95
Functions for validating string formats and data structures.
96

97
```typescript { .api }
98
/**
99
 * Checks if string is valid hexadecimal
100
 * @param value - String to check
101
 * @param bitLength - Expected bit length (optional)
102
 * @param ignoreLength - Whether to ignore length validation
103
 */
104
function isHex(value: unknown, bitLength?: number, ignoreLength?: boolean): value is HexString;
105

106
/**
107
 * Checks if string contains only ASCII characters
108
 */
109
function isAscii(value: unknown): value is string;
110

111
/**
112
 * Checks if Uint8Array contains valid UTF-8 data
113
 */
114
function isUtf8(value: Uint8Array): boolean;
115

116
/**
117
 * Checks if string is a valid IP address (IPv4 or IPv6)
118
 */
119
function isIp(value: unknown): value is string;
120

121
/**
122
 * Checks if value is a valid JSON object
123
 */
124
function isJsonObject(value: unknown): value is Record<string, unknown>;
125

126
/**
127
 * Checks if value is compact encoded (SCALE)
128
 */
129
function isCompact(value: unknown): boolean;
130
```
131

132
### Class and Instance Checking
133

134
Utilities for checking class relationships and instances.
135

136
```typescript { .api }
137
/**
138
 * Checks if value is a class constructor
139
 */
140
function isClass(value: unknown): value is Class;
141

142
/**
143
 * Checks if value is an instance of specified constructor
144
 * @param value - Value to check
145
 * @param clazz - Constructor function
146
 */
147
function isInstanceOf(value: unknown, clazz: Class): boolean;
148

149
/**
150
 * Checks if child class extends parent class
151
 * @param Child - Child class constructor
152
 * @param Parent - Parent class constructor
153
 */
154
function isChildClass(Child: Class, Parent: Class): boolean;
155
```
156

157
### Method Interface Checking
158

159
Functions to check if objects implement specific method interfaces.
160

161
```typescript { .api }
162
/**
163
 * Checks if object has toBn method
164
 */
165
function isToBn(value: unknown): value is ToBn;
166

167
/**
168
 * Checks if object has toBigInt method
169
 */
170
function isToBigInt(value: unknown): value is ToBigInt;
171

172
/**
173
 * Checks if object has codec methods (toHex, toU8a, etc.)
174
 */
175
function isCodec(value: unknown): boolean;
176
```
177

178
### Environment and System Checking
179

180
Platform and environment detection utilities.
181

182
```typescript { .api }
183
/**
184
 * Checks if running on RISC-V architecture
185
 */
186
function isRiscV(): boolean;
187

188
/**
189
 * Checks if chain is a test chain (based on genesis hash)
190
 */
191
function isTestChain(genesisHash: string | Uint8Array): boolean;
192

193
/**
194
 * Checks if value is a WebAssembly module
195
 */
196
function isWasm(value: unknown): value is WebAssembly.Module;
197
```
198

199
## Usage Examples
200

201
**Basic Type Validation:**
202

203
```typescript
204
import { isString, isNumber, isHex, isU8a } from "@polkadot/util";
205

206
function processData(input: unknown) {
207
  if (isString(input)) {
208
    // TypeScript knows input is string here
209
    return input.toUpperCase();
210
  }
211
  
212
  if (isNumber(input)) {
213
    // TypeScript knows input is number here
214
    return input * 2;
215
  }
216
  
217
  throw new Error("Invalid input type");
218
}
219
```
220

221
**Format Validation:**
222

223
```typescript
224
import { isHex, isU8a, hexToU8a } from "@polkadot/util";
225

226
function convertToBytes(input: string | Uint8Array): Uint8Array {
227
  if (isU8a(input)) {
228
    return input;
229
  }
230
  
231
  if (isHex(input)) {
232
    return hexToU8a(input);
233
  }
234
  
235
  throw new Error("Input must be hex string or Uint8Array");
236
}
237
```
238

239
**Interface Checking:**
240

241
```typescript
242
import { isToBn, bnToBn } from "@polkadot/util";
243

244
function convertToBn(value: unknown) {
245
  if (isToBn(value)) {
246
    // Value has toBn() method
247
    return value.toBn();
248
  }
249
  
250
  // Fallback to general conversion
251
  return bnToBn(value);
252
}
253
```
254

255
## Types
256

257
```typescript { .api }
258
interface Observable {
259
  next(value?: unknown): unknown;
260
}
261

262
interface Class<T = unknown> {
263
  new (...args: unknown[]): T;
264
}
265

266
interface ToBn {
267
  toBn(): BN;
268
}
269

270
interface ToBigInt {
271
  toBigInt(): bigint;
272
}
273

274
type HexString = `0x${string}`;
275
```