https://github.com/toreda/types
Expressive type aliases and functional types commonly used in Toreda packages.
https://github.com/toreda/types
Last synced: 5 months ago
JSON representation
Expressive type aliases and functional types commonly used in Toreda packages.
- Host: GitHub
- URL: https://github.com/toreda/types
- Owner: toreda
- License: mit
- Created: 2021-06-01T22:41:50.000Z (almost 4 years ago)
- Default Branch: master
- Last Pushed: 2024-10-10T06:35:09.000Z (7 months ago)
- Last Synced: 2024-11-16T23:19:41.613Z (6 months ago)
- Language: TypeScript
- Homepage:
- Size: 1.37 MB
- Stars: 0
- Watchers: 2
- Forks: 0
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://www.toreda.com)
[](https://github.com/toreda/types/actions) [](https://sonarcloud.io/project/activity?graph=coverage&id=toreda_types) [](https://sonarcloud.io/summary/new_code?id=toreda_types)
[](https://github.com/toreda/types/releases/latest) [](https://github.com/toreda/types/releases/latest) [](https://github.com/toreda/types/issues)
[](https://github.com/toreda/types/blob/master/LICENSE)
# `@toreda/types`
Improve readability, reduce redundancy. Functional & Expressive Types used in [**Toreda**](https://www.toreda.com) packages.
# **Contents**
- [`@toreda/types`](#toredatypes)
- [**Contents**](#contents)
- [Object API](#object-api)
- [`Resettable`](#resettable)
- [Example](#example)
- [`Clearable`](#clearable)
- [Example](#example-1)
- [`Stringable`](#stringable)
- [Example](#example-2)
- [**Functional Types**](#functional-types)
- [`DeepRequired`](#deeprequiredt)
- [`Primitive`](#primitive)
- [Import](#import)
- [Use](#use)
- [`Stringable`](#stringable-1)
- [**Import**](#import-1)
- [**Use**](#use-1)
- [**Expressive Types**](#expressive-types)
- [**`BitMask`**](#bitmask)
- [**Import**](#import-2)
- [**Use**](#use-2)
- [Install](#install)
- [Yarn](#yarn)
- [NPM](#npm)
- [Legal](#legal)
- [License](#license)
- [Copyright](#copyright)
- [Website](#website)
# Object API
## `Resettable`
Interface indicating implementer provides a `reset` method.
### Example
```typescript
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
```typescript
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
```typescript
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`
Recursively require all properties on object & children.
## `Primitive`
Implementer's type is any JavaScript primitive.
### Import
```typescript
import {Primitive} from '@toreda/types'
```
### Use
```typescript
const myValue: Primitive = null;
```
## `Stringable`
Implementer's contents can be converted to a string by calling `toString()`.
### **Import**
```typescript
import {Stringable} from '@toreda/types'
```
### **Use**
```typescript
export class MyClass implements Stringable {
public toString(): string {
return 'stringified_contents_here';
}
}
```
**Example**
```typescript
// 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 = Record;
```
# **Expressive Types**
Express value intent & purpose with type definitions.
## **`BitMask`**
### **Import**
```typescript
import {BitMask} from '@toreda/types'
```
### **Use**
```typescript
// 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**
```typescript
// 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
```bash
$ yarn add @toreda/types --dev
```
## NPM
```bash
$ yarn add @toreda/types --D
```
# Legal
## License
[MIT](LICENSE) © Toreda, Inc.
## Copyright
Copyright © 2019 - 2022 Toreda, Inc. All Rights Reserved.
## Website
Toreda's company website can be found at [toreda.com](https://www.toreda.com)