Class Typer

Class representing a type checker. Version: 2.4.1

Author

Michael Lavigna

Since

2.4.1

Constructors

constructor

new Typer(): Typer
creates the types mapping type-->function

Returns Typer
- Defined in Typer.ts:24

Methods

asArray

asArray<T = unknown>(value: unknown): T[]
Validates and returns an array
Type Parameters
- T = unknown
  The expected element type
Parameters
- value: unknown
  The value to validate
Returns T[]
The validated array

Throws
If not an array
- Defined in Typer.ts:799

asBoolean

asBoolean(value: unknown): boolean
Validates and returns a boolean
Parameters
- value: unknown
  The value to validate
Returns boolean
The validated boolean

Throws
If not a boolean
- Defined in Typer.ts:788

asNumber

asNumber(value: unknown): number
Validates and returns a number
Parameters
- value: unknown
  The value to validate
Returns number
The validated number

Throws
If not a number
- Defined in Typer.ts:778

asObject

asObject<T extends Record<string, unknown> = Record<string, unknown>>(
value: unknown,
): T
Validates and returns an object
Type Parameters
- T extends Record<string, unknown> = Record<string, unknown>
  The expected object type
Parameters
- value: unknown
  The value to validate
Returns T
The validated object

Throws
If not an object
- Defined in Typer.ts:810

assert

assert(value: unknown, expectedType: string | string[]): void
Assert that a value is of a specific type. Logs a warning if incorrect.
Parameters
- value: unknown
  The value to check.
- expectedType: string | string[]
  The expected type(s).
Returns void
Example
```
Typer.assert(42, "number"); // No output
Typer.assert("hello", "number"); // Warning in console
```
- Defined in Typer.ts:1111

asString

asString(value: unknown): string
Validates and returns a string
Parameters
- value: unknown
  The value to validate
Returns string
The validated string

Throws
If not a string
- Defined in Typer.ts:768

checkStructure

checkStructure(
    schema: Record<string, unknown>,
    obj: Record<string, unknown>,
    path?: string,
    strictMode?: boolean,
): StructureValidationReturn
Recursively validates an object against a nested schema.
Parameters
- schema: Record<string, unknown>
  The expected structure definition.
- obj: Record<string, unknown>
  The object to validate.
- path: string = ''
  The current path for error reporting (internal use).
- strictMode: boolean = false
  Whether to reject extra keys not in schema.
Returns StructureValidationReturn
- Validation result with errors array.
Example
```
const schema = {
   name: "string",
   age: "number",
   hobbies: ["string"],
   address: {
     street: "string",
     city: "string?"
   }
};
const obj = { name: "John", age: 25, hobbies: ["reading"] };
console.log(Typer.checkStructure(schema, obj)); // { isValid: true, errors: [] }
```
- Defined in Typer.ts:929

expect

expect(funct: Function, types: TyperExpectTypes): (...args: unknown[]) => any
Expects a function to conform to specified input and output types.
Parameters
- funct: Function
  The function to type-check.
- types: TyperExpectTypes
  The expected types for the function's parameters and return value.
  
  Defines the expected input and output types for a function.
  - paramTypes: string[]
    The expected type(s) of the function's parameters
  - returnType: string[]
    The expected return type(s) of the function
Returns (...args: unknown[]) => any
A new function that type-checks its arguments and return value.
Throws
If the types object does not contain exactly 3 keys or the required type properties.

Throws
If the function or types object does not conform to the expected types.
Example
```
const typedFunction = Typer.expect(
   (x: number) => x * 2, 
   { paramTypes: ["number"], returnType: ["number"] }
);
console.log(typedFunction(3)); // 6
```
- Defined in Typer.ts:1151

exportTypes

exportTypes(): string
Exports all registered types as a JSON string.

Returns string
The serialized types.
Example
```
console.log(Typer.exportTypes()); // '["array","number","string","boolean"]'
```
- Defined in Typer.ts:143

importTypes

importTypes(json: string): void
Imports types from a JSON string.
Parameters
- json: string
  The JSON string containing type names.
Returns void
Example
```
Typer.importTypes('["customType"]');
```
- Defined in Typer.ts:153

is

is<T = unknown>(value: unknown, types: string | string[]): value is T
Checks if the provided value matches one or more specified types.
Type Parameters
- T = unknown
  The expected type for better TypeScript inference
Parameters
- value: unknown
  The value to check.
- types: string | string[]
  One or more types to check against.
Returns value is T
Returns true if the value matches any type, false otherwise.
Example
```
if (typer.is<string>("hello", "string")) {
  // value is now typed as string
  console.log(value.toUpperCase());
}
console.log(Typer.is(42, "number")); // true
console.log(Typer.is("hello", ["string", "number"])); // true
console.log(Typer.is([], "string")); // false
```
- Defined in Typer.ts:890

isArray

isArray<T = unknown>(value: unknown): value is T[]
Type-safe array validation
Type Parameters
- T = unknown
  The expected element type
Parameters
- value: unknown
  The value to check
Returns value is T[]
Type guard for array
- Defined in Typer.ts:738

isArrayOf

isArrayOf<T = unknown>(elementType: string, p: unknown): T[]
Checks if the provided parameter is an array of a specified type.
Type Parameters
- T = unknown
  The expected element type
Parameters
- elementType: string
  The type of elements that the array should contain.
- p: unknown
  The parameter to check.
Returns T[]
Typed array of elements
Throws
Throws if the parameter is not an array of the specified type.
Example
```
const numbers = typer.isArrayOf<number>("number", [1, 2, 3]); // numbers: number[]
const strings = typer.isArrayOf<string>("string", ["a", "b"]); // strings: string[]
```
- Defined in Typer.ts:463

isBoolean

isBoolean(value: unknown): value is boolean
Type-safe boolean validation
Parameters
- value: unknown
  The value to check
Returns value is boolean
Type guard for boolean
- Defined in Typer.ts:723

isEmail

isEmail(p: unknown): string
Checks if the provided parameter is a valid email address.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated email string
Throws
Throws if the parameter is not a valid email address.
Example
```
const email = typer.isEmail("test@example.com"); // email: string
```
- Defined in Typer.ts:478

isInRange

isInRange(min: number, max: number, p: unknown): number
Checks if the provided parameter is a number within a specified range.
Parameters
- min: number
  The minimum value.
- max: number
  The maximum value.
- p: unknown
  The parameter to check.
Returns number
The validated number
Throws
Throws if the parameter is not a number within the specified range.
Example
```
const age = typer.isInRange(18, 65, 25); // age: number
```
- Defined in Typer.ts:498

isInteger

isInteger(p: unknown): number
Checks if the provided parameter is an integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated integer
Throws
Throws if the parameter is not an integer.
Example
```
const count = typer.isInteger(42); // count: number
```
- Defined in Typer.ts:515

isNegativeInteger

isNegativeInteger(p: unknown): number
Checks if the provided parameter is a negative integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated negative integer
Throws
Throws if the parameter is not a negative integer.
Example
```
const count = typer.isNegativeInteger(-42); // count: number
```
- Defined in Typer.ts:682

isNegativeNumber

isNegativeNumber(p: unknown): number
Checks if the provided parameter is a negative number.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated negative number
Throws
Throws if the parameter is not a negative number.
Example
```
const value = typer.isNegativeNumber(-10); // value: number
```
- Defined in Typer.ts:665

isNonEmptyArray

isNonEmptyArray<T = unknown>(p: unknown): T[]
Checks if the provided parameter is a non-empty array.
Type Parameters
- T = unknown
  The expected element type
Parameters
- p: unknown
  The parameter to check.
Returns T[]
The validated non-empty array
Throws
Throws if the parameter is not a non-empty array.
Example
```
const items = typer.isNonEmptyArray<string>(["a", "b"]); // items: string[]
```
- Defined in Typer.ts:533

isNonEmptyString

isNonEmptyString(p: unknown): string
Checks if the provided parameter is a non-empty string.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated non-empty string
Throws
Throws if the parameter is not a non-empty string.
Example
```
const name = typer.isNonEmptyString("Hello"); // name: string
```
- Defined in Typer.ts:550

isNumber

isNumber(value: unknown): value is number
Type-safe number validation
Parameters
- value: unknown
  The value to check
Returns value is number
Type guard for number
- Defined in Typer.ts:709

isObject

isObject<T extends Record<string, unknown> = Record<string, unknown>>(
value: unknown,
): value is T
Type-safe object validation
Type Parameters
- T extends Record<string, unknown> = Record<string, unknown>
  The expected object type
Parameters
- value: unknown
  The value to check
Returns value is T
Type guard for object
- Defined in Typer.ts:753

isOneOf

isOneOf<T>(values: readonly T[], p: unknown): T
Checks if the provided parameter is one of the specified values.
Type Parameters
- T
  The expected type of the values
Parameters
- values: readonly T[]
  The values to check against.
- p: unknown
  The parameter to check.
Returns T
The validated value
Throws
Throws if the parameter is not one of the specified values.
Example
```
const color = typer.isOneOf(["red", "blue", "green"] as const, "blue"); // color: "red" | "blue" | "green"
```
- Defined in Typer.ts:569

isPhoneNumber

isPhoneNumber(p: unknown): string
Checks if the provided parameter is a valid phone number.
Parameters
- p: unknown
  The parameter to check.
Returns string
The validated phone number string
Throws
Throws if the parameter is not a valid phone number.
Example
```
const phone = typer.isPhoneNumber("+1234567890"); // phone: string
const phone2 = typer.isPhoneNumber("(555) 123-4567"); // phone2: string
```
- Defined in Typer.ts:586

isPositiveInteger

isPositiveInteger(p: unknown): number
Checks if the provided parameter is a positive integer.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated positive integer
Throws
Throws if the parameter is not a positive integer.
Example
```
const count = typer.isPositiveInteger(42); // count: number
```
- Defined in Typer.ts:648

isPositiveNumber

isPositiveNumber(p: unknown): number
Checks if the provided parameter is a positive number.
Parameters
- p: unknown
  The parameter to check.
Returns number
The validated positive number
Throws
Throws if the parameter is not a positive number.
Example
```
const value = typer.isPositiveNumber(10); // value: number
```
- Defined in Typer.ts:631

isString

isString(value: unknown): value is string
Type-safe string validation
Parameters
- value: unknown
  The value to check
Returns value is string
Type guard for string
- Defined in Typer.ts:695

isType

isType<T = unknown>(types: string | string[], p: unknown): T
Check if the parameter matches one of the specified types.
Type Parameters
- T = unknown
  The expected type for better TypeScript inference
Parameters
- types: string | string[]
  The types to check against.
- p: unknown
  The parameter to check.
Returns T
Returns the value cast to the expected type
Throws
Throws if the parameter does not match any of the specified types.
Example
```
const value = typer.isType<string>("string", "Hello"); // value is typed as string
console.log(Typer.isType("string", "Hello")); // "Hello"
console.log(Typer.isType(["number", "boolean"], 42)); // 42
console.log(Typer.isType(["number", "boolean"], "text")); // Throws TypeError
```
- Defined in Typer.ts:847

isURL

isURL(p: unknown): string
Checks if the provided parameter is a valid URL.
Parameters
- p: unknown
  The parameter to check.
Returns string
Throws
Throws if the parameter is not a valid URL.
Example
```
console.log(Typer.isURL("https://example.com")); // true
console.log(Typer.isURL("invalid-url")); // false
```
- Defined in Typer.ts:824

listTypes

listTypes(): string[]
Get all registered types.

Returns string[]
An array of registered type names.
Example
```
console.log(Typer.listTypes()); // ["array", "number", "string", "boolean"]
```
- Defined in Typer.ts:133

registerType

registerType<T = unknown, R = T>(
    name: string,
    validator: (value: T) => R,
    override?: boolean,
): void
Register a new type in the typesMap.
Type Parameters
- T = unknown
  The input type that the validator expects
- R = T
  The return type that the validator produces
Parameters
- name: string
  The name of the new type.
- validator: (value: T) => R
  The function to validate the type.
- override: boolean = false
  Whether to override the original configuration
Returns void
Throws
If the type name is already registered.
Example
```
// Register a positive number validator
typer.registerType<unknown, number>("positive", (value) => {
   if (typeof value !== "number" || value <= 0) throw new TypeError("Must be positive");
   return value;
});

// Register a string length validator
typer.registerType<unknown, string>("longString", (value) => {
   if (typeof value !== "string" || value.length < 10) throw new TypeError("Must be long string");
   return value;
});
```
- Defined in Typer.ts:103

unregisterType

unregisterType(name: string): void
Unregister a type from the typesMap.
Parameters
- name: string
  The name of the type to remove.
Returns void
Throws
If the type does not exist.
Example
```
Typer.unregisterType("positive");
```
- Defined in Typer.ts:119

validate

validate(
schema: Record<string, string | string[]>,
obj: Record<string, unknown>,
): string[]
Validates an object against a schema.
Parameters
- schema: Record<string, string | string[]>
  The expected types for each key.
- obj: Record<string, unknown>
  The object to validate.
Returns string[]
- An array of validation errors, or an empty array if valid.
Example
```
const schema = { name: "string", age: "number" };
const obj = { name: "John", age: "25" };
console.log(Typer.validate(schema, obj)); // ["Expected 'age' to be of type number, got string"]
```
- Defined in Typer.ts:1088

Class Typer

Author

Since

Index

Constructors

Methods

Constructors

constructor

Returns Typer

Methods

asArray

Type Parameters

Parameters

Returns T[]

Throws

asBoolean

Parameters

Returns boolean

Throws

asNumber

Parameters

Returns number

Throws

asObject

Type Parameters

Parameters

Returns T

Throws

assert

Parameters

Returns void

Example

asString

Parameters

Returns string

Throws

checkStructure

Parameters

Returns StructureValidationReturn

Example

expect

Parameters

paramTypes: string[]

returnType: string[]

Returns (...args: unknown[]) => any

Throws

Throws

Example

exportTypes

Returns string

Example

importTypes

Parameters

Returns void

Example

is

Type Parameters

Parameters

Returns value is T

Example

isArray

Type Parameters

Parameters

Returns value is T[]

isArrayOf

Type Parameters

Parameters

Returns T[]

Throws

Example

isBoolean

Parameters

Returns value is boolean

isEmail

Parameters

Returns string

Throws

Example

isInRange

Parameters