@toreda/types

Common mappings, aliases, and types used in Toreda TypeScript packages.

Downloads in past

Stats

StarsIssuesVersionUpdatedCreatedSize
@toreda/types
002.14.04 months agoa year agoMinified + gzip package size for @toreda/types in KB

Readme

Toreda
CI Coverage Sonar Quality Gate
GitHub package.json version (branch) GitHub Release Date GitHub issues
license
 
@toreda/types
Improve readability, reduce redundancy. Functional & Expressive Types used in Toreda packages.
 
Contents
- [`Resettable`](#resettable)
	- [Example](#example)
- [`Clearable`](#clearable)
	- [Example](#example-1)
- [`Stringable`](#stringable)
	- [Example](#example-2)
- [`DeepRequired<T>`](#deeprequiredt)
- [`Primitive`](#primitive)
	- [Import](#import)
	- [Use](#use)
- [`Stringable`](#stringable-1)
	- [**Import**](#import-1)
	- [**Use**](#use-1)
- [**`BitMask`**](#bitmask)
	- [**Import**](#import-2)
	- [**Use**](#use-2)
- [Yarn](#yarn)
- [NPM](#npm)
- [License](#license)
- [Copyright](#copyright)
- [Website](#website)
 
Object API

Resettable

Interface indicating implementer provides a reset method.

Example

import type {Resettable} from '@toreda/types';

class MyObj implements Resettable {
	public reset(): void {
		console.log('boop');
	}
}

const o = new MyObj();
o.reset();

Clearable

Interface indicating implementer provides a clear() method. Callers expect true to be returned when clear call is successful and false when it was not successful, or there was nothing to clear.

Example

import type {Clearable} from '@toreda/types';

class MyObj implements Clearable {
	public clear(): boolean {
		console.log('boop');

		return true;
	}
}

const o = new MyObj();
const result = o.clear();

Stringable

Interface indicating implementer provides a toString() method which returns the object contents as a string. Typically used for serialization although usage may vary.

Example

import type {Stringable} from '@toreda/types';

class MyObj implements Stringable {
	public a: string;
	public b: string;

	constructor() {
		this.a = 'aaaa';
		this.b = 'bbbb';
	}

	public toString(): string | null {
		const o = {
			a: this.a,
			b: this.b
		};

		let result: string | null = null;
		try {
			result =  JSON.stringify(o);
		} catch (e){
			if (e instanceof Error) {
				console.log(`toString exception: ${e.message}.`);
			}
		}

		return result;
	}
}

const o = new MyObj();
const result = o.clear();
Functional Types
Types & aliases provide shorthand to reduce code duplication and simplify statements.
 

DeepRequired<T>

Recursively require all properties on object & children.
 

Primitive

Implementer's type is any JavaScript primitive.

Import

import {Primitive} from '@toreda/types'

Use

const myValue: Primitive = null;

 

Stringable

Implementer's contents can be converted to a string by calling toString().

Import

import {Stringable} from '@toreda/types'

Use

export class MyClass implements Stringable {
	public toString(): string {
		return 'stringified_contents_here';
	}
}

Example
// Simple generic mapping. When used only once, exporting a type is overkill, but when used repeatedly
// using a common definition reduces chances for mistakes and reduces line lengths.
export type Data<T> = Record<string, T | T[] | null>;

 
Expressive Types
Express value intent & purpose with type definitions.
 

BitMask

Import

import {BitMask} from '@toreda/types'

Use

// Declare and initialize number while also expressing the value's purpose.
let mask: BitMask = 0x1;

// Becomes more clear when expecting values:
function useValue(mask: BitMask): void {
	...
}
// versus:
function useValue(mask: number): void {
	...
}

Example
// Expressive Type alias.
export type BigId = string;

// BigId is an expressive alias replacing the use of 'string' for id's type. It makes no
// functional difference, however id types often impose character and length limitations meaning
// the value cannot be an arbitrary string. BigId gives the caller context for what string values
// are actually valid & accepted.
function validateId(id: BigId): void {
	...
}

 
Install

Yarn

$ yarn add @toreda/types --dev

NPM

$ yarn add @toreda/types --D

 
Legal

License

MIT © Toreda, Inc.

Copyright

Copyright © 2019 - 2022 Toreda, Inc. All Rights Reserved.

Website

Toreda's company website can be found at toreda.com