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

assert

assert(value: any, expectedType: string | string[]): void
Assert that a value is of a specific type. Logs a warning if incorrect.
Parameters
- value: any
  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:810

checkStructure

checkStructure(
    schema: Record<string, any>,
    obj: Record<string, any>,
    path?: string,
): StructureValidationReturn
Recursively validates an object against a nested schema.
Parameters
- schema: Record<string, any>
  The expected structure.
- obj: Record<string, any>
  The object to validate.
- path: string = ''
Returns StructureValidationReturn
- List of errors, or an empty array if valid.
Example
```
const schema = {
   name: "string",
   age: "number",
};
const obj = { name: "John", age: 25 };
console.log(Typer.checkStructure(schema, obj)); // { isValid: true, errors: [] }
```
- Defined in Typer.ts:751

expect

expect(funct: Function, types: TyperExpectTypes): (...args: any) => 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.
  - paramTypes: string[]
    The expected type(s) of the function's parameters
  - returnType: string[]
    The expected return type(s) of the function
Returns (...args: any) => 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:833

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:133

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:143

is

is(value: any, types: string | string[]): boolean
Checks if the provided value matches one or more specified types.
Parameters
- value: any
  The value to check.
- types: string | string[]
  One or more types to check against.
Returns boolean
Returns true if the value matches any type, false otherwise.
Example
```
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:719

isArrayOf

isArrayOf(elementType: string, p: any): TyperReturn<any[]>
Checks if the provided parameter is an array of a specified type.
Parameters
- elementType: string
  The type of elements that the array should contain.
- p: any
  The parameter to check.
Returns TyperReturn<any[]>
Throws
Throws if the parameter is not an array of the specified type.
Example
```
console.log(Typer.isArrayOf("number", [1, 2, 3])); // true
console.log(Typer.isArrayOf("string", [1, 2, "hello"])); // false
```
- Defined in Typer.ts:442

isEmail

isEmail(p: any): TyperReturn<string>
Checks if the provided parameter is a valid email address.
Parameters
- p: any
  The parameter to check.
Returns TyperReturn<string>
Throws
Throws if the parameter is not a valid email address.
Example
```
console.log(Typer.isEmail("test@example.com")); // true
console.log(Typer.isEmail("invalid-email")); // false
```
- Defined in Typer.ts:458

isInRange

isInRange(min: number, max: number, p: any): TyperReturn<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: any
  The parameter to check.
Returns TyperReturn<number>
Throws
Throws if the parameter is not a number within the specified range.
Example
```
console.log(Typer.isInRange(1, 10, 5)); // true
console.log(Typer.isInRange(1, 10, 20)); // false
```
- Defined in Typer.ts:479

isInteger

isInteger(p: any): any
Checks if the provided parameter is an integer.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not an integer.
Example
```
console.log(Typer.isInteger(42)); // true
console.log(Typer.isInteger(42.5)); // false
```
- Defined in Typer.ts:497

isNegativeInteger

isNegativeInteger(p: any): any
Checks if the provided parameter is a positive integer.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a positive integer.
Example
```
console.log(Typer.isNegativeInteger(-42)); // true
console.log(Typer.isNegativeInteger(10)); // Throws TypeError
```
- Defined in Typer.ts:642

isNegativeNumber

isNegativeNumber(p: any): any
Checks if the provided parameter is a positive number.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a positive number.
Example
```
console.log(Typer.isNegativeNumber(-10)); // true
console.log(Typer.isNegativeNumber(5)); // Throws TypeError
```
- Defined in Typer.ts:624

isNonEmptyArray

isNonEmptyArray(p: any): any
Checks if the provided parameter is a non-empty array.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a non-empty array.
Example
```
console.log(Typer.isNonEmptyArray([1, 2, 3])); // true
console.log(Typer.isNonEmptyArray([])); // Throws TypeError
```
- Defined in Typer.ts:515

isNonEmptyString

isNonEmptyString(p: any): any
Checks if the provided parameter is a non-empty string.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a non-empty string.
Example
```
console.log(Typer.isNonEmptyString("Hello")); // true
console.log(Typer.isNonEmptyString("")); // Throws TypeError
```
- Defined in Typer.ts:533

isOneOf

isOneOf(values: any[], p: any): any
Checks if the provided parameter is one of the specified values.
Parameters
- values: any[]
  The values to check against.
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not one of the specified values.
Example
```
console.log(Typer.isOneOf(["red", "blue"], "blue")); // true
console.log(Typer.isOneOf(["red", "blue"], "green")); // false
```
- Defined in Typer.ts:552

isPhoneNumber

isPhoneNumber(p: any): any
Checks if the provided parameter is a valid phone number.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a valid phone number.
Example
```
console.log(Typer.isPhoneNumber("+1234567890")); // true
console.log(Typer.isPhoneNumber("abc123")); // Throws TypeError
```
- Defined in Typer.ts:569

isPositiveInteger

isPositiveInteger(p: any): any
Checks if the provided parameter is a positive integer.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a positive integer.
Example
```
console.log(Typer.isPositiveInteger(42)); // true
console.log(Typer.isPositiveInteger(-10)); // Throws TypeError
```
- Defined in Typer.ts:606

isPositiveNumber

isPositiveNumber(p: any): any
Checks if the provided parameter is a positive number.
Parameters
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter is not a positive number.
Example
```
console.log(Typer.isPositiveNumber(10)); // true
console.log(Typer.isPositiveNumber(-5)); // Throws TypeError
```
- Defined in Typer.ts:588

isType

isType(types: string | string[], p: any): any
Check if the parameter matches one of the specified types.
Parameters
- types: string | string[]
  The types to check against.
- p: any
  The parameter to check.
Returns any
Throws
Throws if the parameter does not match any of the specified types.
Example
```
console.log(Typer.isType("string", "Hello")); // true
console.log(Typer.isType(["number", "boolean"], 42)); // true
console.log(Typer.isType(["number", "boolean"], "text")); // Throws TypeError
```
- Defined in Typer.ts:681

isURL

isURL(p: any): any
Checks if the provided parameter is a valid URL.
Parameters
- p: any
  The parameter to check.
Returns any
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:660

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:123

registerType

registerType(
    name: string,
    validator: (value: any) => any,
    override?: boolean,
): void
Register a new type in the typesMap.
Parameters
- name: string
  The name of the new type.
- validator: (value: any) => any
  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
```
Typer.registerType("positive", (value) => {
   if (typeof value !== "number" || value <= 0) throw new TypeError("Must be positive");
   return value;
});
```
- Defined in Typer.ts:94

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:109

validate

validate(
schema: Record<string, string | string[]>,
obj: Record<string, any>,
): string[]
Validates an object against a schema.
Parameters
- schema: Record<string, string | string[]>
  The expected types for each key.
- obj: Record<string, any>
  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:787

Class Typer

Author

Since

Index

Constructors

Methods

Constructors

constructor

Returns Typer

Methods

assert

Parameters

Returns void

Example

checkStructure

Parameters

Returns StructureValidationReturn

Example

expect

Parameters

paramTypes: string[]

returnType: string[]

Returns (...args: any) => any

Throws

Throws

Example

exportTypes

Returns string

Example

importTypes

Parameters

Returns void

Example

is

Parameters

Returns boolean

Example

isArrayOf

Parameters

Returns TyperReturn<any[]>

Throws

Example

isEmail

Parameters

Returns TyperReturn<string>

Throws

Example

isInRange

Parameters

Returns TyperReturn<number>

Throws

Example

isInteger

Parameters

Returns any

Throws

Example

isNegativeInteger

Parameters

Returns any

Throws

Example

isNegativeNumber

Parameters

Returns any

Throws

Example

isNonEmptyArray

Parameters

Returns any

Throws

Example

isNonEmptyString

Parameters

Returns any

Throws

Example

isOneOf

Parameters

Returns any