typesafe-utils
v1.16.2
Published
A few small typesafe utilities
Downloads
10,716
Maintainers
ivanhoferReadme
A collection of a few small lightweight typesafe utilities.
Motivation
Sometimes you will encounter situations were the types will not match what you expect from a function. This means you need to explicitly specify a type by yourself to gain the full power of TypeScript.
In this collection you will find some useful functions that are fully typed.
Install
$ npm install --save-dev typesafe-utilsOverview
- is
- isTruthy
- isUndefined
- isNull
- boolean
- number
- string
- array
- object
- duplicates
- logical operators
- typeguards
| * not automatically 100% typesafe. It's better than nothing but to be 100% typesafe you need to pass generics yourself.
filter functions
A bunch of utilities that return true or false. Useful for array filter functions.
Motivation: When you filter an Array, the return type is not always what you expect. Typescript will tell you the result of a filter function is the exact type you pass to the filter function. But that is not always true. If you filter out falsy values, the return type should should not contain.
// BASIC example --------------------------------------------------------------
const result = [true, false].filter(bool => !!bool)
// => result: boolean[] => [true]
import { isTruthy } from 'typesafe-utils'
const typesafeResult = [true, false].filter(isTruthy)
// => typesafeResult: true[] => [true]
// ADVANCED example -----------------------------------------------------------
const result = ['text', null, 'another text', undefined].filter(value => value !== '')
// => result: (string | null | undefined)[] => ['text', 'another text']
import { isNotEmpty } from 'typesafe-utils'
const typesafeResult = ['text', null, 'another text', undefined].filter(isNotEmpty)
// => typesafeResult: string[] => ['text', 'another text']is
returns true iff value is equals to the property you pass to the function
Usage
import { is } from 'typesafe-utils'
const result = [1, 15, 10, 43].filter(is(10))
// result: number[] => [10]isNot
returns true iff value is not equal to the property you pass to the function
Usage
import { isNot } from 'typesafe-utils'
const result = ['text', 'forbidden', 'blabla'].filter(isNot('forbidden'))
// result: string[] => ['text', 'blabla']isProperty
returns true iff the attribute of the object equals the property you pass to the function
Usage
import { isProperty } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 1 },
{ id: 3 }
]
const result = items.filter(isProperty('id', 3))
// result: Product[] => [{ id: 3 }]isPropertyNot
returns true iff the attribute of the object is not equal to the property you pass to the function
Usage
import { isPropertyNot } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 156 },
{ id: 123 }
]
const result = items.filter(isPropertyNot('id', 123))
// result: Product[] => [{ id: 156 }]isTruthy
returns true iff value is not false | '' | 0 | null | undefined
Usage
import { isTruthy } from 'typesafe-utils'
const result = [true, false, undefined, null].filter(isTruthy)
// result: true[] => [true]isFalsy
returns true iff value is false | '' | 0 | null | undefined
Usage
import { isFalsy } from 'typesafe-utils'
const result = [true, false, 'text', 123, null].filter(isFalsy)
// result: (false | null)[] => [false, null]isPropertyTruthy
returns true iff the attribute of the object is truthy
Usage
import { isPropertyTruthy } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 1 },
{ id: null },
{ id: undefined }
]
const result = items.filter(isPropertyTruthy('id'))
// result: Product[] => [{ id: 1 }]isPropertyFalsy
returns true iff the attribute of the object is falsy
Usage
import { isPropertyFalsy } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 5 },
{ id: null }
]
const result = items.filter(isPropertyFalsy('id'))
// result: Product[] => [{ id: null }]arePropertiesTruthy
returns true iff all attributes of the object are truthy
Usage
import { arePropertiesTruthy } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesTruthy('id', 'name'))arePropertiesFalsy
returns true iff all attributes of the object are falsy
Usage
import { arePropertiesFalsy } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesFalsy('id', 'name'))isUndefined
returns true iff value is undefined
Usage
import { isUndefined } from 'typesafe-utils'
const result = [undefined, null, true].filter(isUndefined)
// result: undefined[] => [undefined]isNotUndefined
returns true iff value is not undefined
Usage
import { isNotUndefined } from 'typesafe-utils'
const result = [null, undefined].filter(isNotUndefined)
// result: null[] => [null]isPropertyUndefined
returns true iff the attribute of the object is undefined
Usage
import { isPropertyUndefined } from 'typesafe-utils'
type Product = {
id: number | undefined
}
const items: Product[] = [
{ id: 1 },
{ id: undefined }
]
const result = items.filter(isPropertyUndefined('id'))
// result: Product[] => [{ id: undefined }]isPropertyNotUndefined
returns true iff the attribute of the object is not undefined
Usage
import { isPropertyNotUndefined } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 5 },
{ id: undefined }
]
const result = items.filter(isPropertyNotUndefined('id'))
// result: Product[] => [{ id: 5 }]arePropertiesUndefined
returns true iff all attributes of the object are undefined
Usage
import { arePropertiesUndefined } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesUndefined('id', 'name'))arePropertiesNotUndefined
returns true iff all attributes of the object are not undefined
Usage
import { arePropertiesNotUndefined } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNotUndefined('id', 'name'))isNull
returns true iff value is null
Usage
import { isNull } from 'typesafe-utils'
const result = [null, undefined].filter(isNull)
// result: null[] => [null]isNotNull
returns true iff value is not null
Usage
import { isNotNull } from 'typesafe-utils'
const result = [false, null].filter(isNotNull)
// result: boolean[] => [false]isPropertyNull
returns true iff the attribute of the object is null
Usage
import { isPropertyNull } from 'typesafe-utils'
type Product = {
id: number | null
}
const items: Product[] = [
{ id: 0 },
{ id: null }
]
const result = items.filter(isPropertyNull('id'))
// result: Product[] => [{ id: null }]isPropertyNotNull
returns true iff the attribute of the object is not null
Usage
import { isPropertyNotNull } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ id: 5 },
{ id: null }
]
const result = items.filter(isPropertyNotNull('id'))
// result: Product[] => [{ id: 5 }]arePropertiesNull
returns true iff all attributes of the object are null
Usage
import { arePropertiesNull } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNull('id', 'name'))arePropertiesNotNull
returns true iff all attributes of the object are not null
Usage
import { arePropertiesNotNull } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNotNull('id', 'name'))isBoolean
returns true iff value is of type boolean
Usage
import { isBoolean } from 'typesafe-utils'
const result = [true, 'some text', 1, false].filter(isBoolean)
// result: boolean[] => [true, false]isTrue
returns true iff value is true
Usage
import { isTrue } from 'typesafe-utils'
const result = [true, 'some text', 1].filter(isTrue)
// result: true[] => [true]isNotTrue
returns true iff value is not true
Note: it is currently not possible to make this function fully typesafe.
[true, 123].filter(isNotTrue)will have the type(false | number)[]
Usage
import { isNotTrue } from 'typesafe-utils'
const result = [true, false].filter(isNotTrue)
// result: false[] => [false]isPropertyTrue
returns true iff the attribute of the object is true
Usage
import { isPropertyTrue } from 'typesafe-utils'
type Product = {
available: boolean | null
}
const items: Product[] = [
{ available: true },
{ available: null }
]
const result = items.filter(isPropertyTrue('available'))
// result: Product[] => [{ available: true }]isPropertyNotTrue
returns true iff the attribute of the object is not true
Usage
import { isPropertyNotTrue } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ available: true },
{ available: false }
]
const result = items.filter(isPropertyNotTrue('available'))
// result: Product[] => [{ available: false }]arePropertiesTrue
returns true iff all attributes of the object are true
Usage
import { arePropertiesTrue } from 'typesafe-utils'
type Product = {
count: number
available: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesTrue('count', 'available'))arePropertiesNotTrue
returns true iff all attributes of the object are not true
Usage
import { arePropertiesNotTrue } from 'typesafe-utils'
type Product = {
count: number
available: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNotTrue('count', 'available'))isFalse
returns true iff value is false
Usage
import { isFalse } from 'typesafe-utils'
const result = [0, false, undefined].filter(isFalse)
// result: false[] => [false]isNotFalse
returns true iff value is not false
Note: it is currently not possible to make this function fully typesafe.
[false, 123].filter(isNotFalse)will have the type(true | number)[]
Usage
import { isNotFalse } from 'typesafe-utils'
const result = [false, null].filter(isNotFalse)
// result: null[] => [null]isPropertyFalse
returns true iff the attribute of the object is false
Usage
import { isPropertyFalse } from 'typesafe-utils'
type Product = {
available: boolean | null
}
const items: Product[] = [
{ available: false },
{ available: true },
{ available: null }
]
const result = items.filter(isPropertyFalse('available'))
// result: Product[] => [{ available: false }]isPropertyNotFalse
returns true iff the attribute of the object is not false
Usage
import { isPropertyNotFalse } from 'typesafe-utils'
type Product = {
id: number
}
const items: Product[] = [
{ available: true },
{ available: false }
]
const result = items.filter(isPropertyNotFalse('available'))
// result: Product[] => [{ available: true }]arePropertiesFalse
returns true iff all attributes of the object are false
Usage
import { arePropertiesFalse } from 'typesafe-utils'
type Product = {
count: number
available: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesFalse('count', 'available'))arePropertiesNotFalse
returns true iff all attributes of the object are not false
Usage
import { arePropertiesNotFalse } from 'typesafe-utils'
type Product = {
count: number
available: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNotFalse('count', 'available'))isNumber
returns true iff value is of type number
Usage
import { isNumber } from 'typesafe-utils'
const result = [0, false, undefined, 5].filter(isNumber)
// result: number[] => [0, 5]isZero
returns true iff value is 0
Usage
import { isZero } from 'typesafe-utils'
const result = [0, false, undefined, 5].filter(isZero)
// result: 0[] => [0]isNotZero
returns true iff value is not 0
Note: it is currently not possible to make this function fully typesafe.
[0, null].filter(isNotTrue)will have the type(number | null)[]
Usage
import { isNotZero } from 'typesafe-utils'
const result = [0, 123].filter(isNotZero)
// result: number[] => [123]isPropertyZero
returns true iff the attribute of the object is 0
Usage
import { isPropertyZero } from 'typesafe-utils'
type Product = {
price: number
}
const items: Product[] = [
{ price: 0 },
{ price: 4 },
{ price: 15 }
]
const result = items.filter(isPropertyZero('price'))
// result: Product[] => [{ price: 0 }]isPropertyNotZero
returns true iff the attribute of the object is not 0
Usage
import { isPropertyNotZero } from 'typesafe-utils'
type Product = {
price: number
}
const items: Product[] = [
{ price: 0 },
{ price: 12 }
]
const result = items.filter(isPropertyNotZero('price'))
// result: Product[] => [{ price: 23 }]arePropertiesZero
returns true iff all attributes of the object are 0
Usage
import { arePropertiesZero } from 'typesafe-utils'
type Product = {
count: number
speed: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesZero('count', 'speed'))arePropertiesNotZero
returns true iff all attributes of the object are not 0
Usage
import { arePropertiesNotZero } from 'typesafe-utils'
type Product = {
count: number
speed: string
}
const items: Product[] = [ ... ]
const result = items.filter(arePropertiesNotZero('count', 'speed'))isString
returns true iff value is of type string
Usage
import { isString } from 'typesafe-utils'
const result = ['', false, null, 'text'].filter(isString)
// result: string[] => ['', 'text]isEmpty
returns true iff value is ''
Usage
import { isEmpty } from 'typesafe-utils'
const result = ['', false, null, 'text'].filter(isEmpty)
// result: ''[] => ['']isNotEmpty
returns true iff value is not ''
Usage
import { isNotEmpty } from 'typesafe-utils'
const result = ['', 5].filter(isNotEmpty)
// result: number[] => [5]isPropertyEmpty
returns true iff the attribute of the object is ''
Usage
import { isPropertyEmpty } from 'typesafe-utils'
type Product = {
label: string
}
const items: Product[] = [
{ label: '' },
{ label: 'label-1' }
]
const result = items.filter(isPropertyEmpty('label'))
// result: Product[] => [{ label: '' }]isPropertyNotEmpty
returns true iff the attribute of the object is not ''
Usage
import { isPropertyNotEmpty } from 'typesafe-utils'
type Product = {
label: string
}
const items: Product[] = [
{ label: 'label-123' },
{ label: '' }
]
const result = items.filter(isPropertyNotEmpty('label'))
// result: Product[] => [{ label: 'label-123' }]arePropertiesEmpty
returns true iff all attributes of the object are ''
Usage
import { arePropertiesEmpty } from 'typesafe-utils'
type Person = {
name: number
firstName: string
}
const items: Person[] = [ ... ]
const result = items.filter(arePropertiesEmpty('name', 'firstName'))arePropertiesNotEmpty
returns true iff all attributes of the object are not ''
Usage
import { arePropertiesNotEmpty } from 'typesafe-utils'
type Person = {
name: number
firstName: string
}
const items: Person[] = [ ... ]
const result = items.filter(arePropertiesNotEmpty('name', 'firstName'))isArray
returns true iff value is of type Array
Usage
import { isArray } from 'typesafe-utils'
const result = [[], null, 123, [0, 1]].filter(isArray)
// result: number[][] => [[], [0, 1]]isArrayNotEmpty
returns true iff an array contains at least one item
Usage
import { isArrayNotEmpty } from 'typesafe-utils'
const nonEmptyArray = ['hi']
if (!!nonEmptyArray.length) {
nonEmptyArray[0].toUpperCase() // ERROR: Object is possibly 'undefined'
}
if (isArrayNotEmpty(nonEmptyArray)) {
// TypeScript will know that the array contains at least 1 item, so it will not complain
nonEmptyArray[0].toUpperCase()
}isArrayEmpty
returns true iff an array contains no items
Usage
import { isArrayEmpty } from 'typesafe-utils'
const emptyArray: string[] = []
if (isArrayEmpty(emptyArray)) {
// emptyArray does not contain any items
}isObject
returns true iff value is of type object
Usage
import { isObject } from 'typesafe-utils'
type SomeType = {
prop?: number
}
const now = new Date()
const result = [{}, now, null, { prop: 123 }].filter(isObject)
// result: (SomeType | Date)[] => [{}, now, { prop: 123 }]isPrimitiveObject
returns true iff value is of the primitive type object and not derived from a class like Date or else.
Usage
import { isPrimitiveObject } from 'typesafe-utils'
type SomeType = {
prop?: number
}
const now = new Date()
const result = [{}, now, null, { prop: 123 }].filter(isPrimitiveObject)
// result: SomeType[] => [{}, { prop: 123 }]filterDuplicates
Removes duplicates from an array. Only the first occurrence of an item will be kept.
Usage
import { filterDuplicates } from 'typesafe-utils'
const items = [1, 2, 3, 5, 8, 1]
const filteredItems = items.filter(filterDuplicates)
// filteredItems: number[] => [1, 2, 3, 5, 8]filterDuplicatesByKey
Removes duplicates from an array by its key. Only the first occurrence of an item will be kept.
Motivation: It is less error-prone if you can only pass the keys an object provides to a filter function. With this function you get full types support.
Usage
import { filterDuplicatesByKey } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [
{ id: 1, name: 'name-1' },
{ id: 2, name: 'name-2' },
{ id: 3, name: 'name-1' },
{ id: 4, name: 'name-2' }
]
const filteredItems = items.filter(filterDuplicatesByKey('name'))
// filteredItems: Product[] => [{ id: 1, name: 'name-1' }, { id: 2, name: 'name-2' }]
const willThrowAnError = items.filter(filterDuplicatesByKey('price'))
// throws: Argument of type '"price"' is **not** assignable to parameter of type '"id" | "name"'and
Combines (&&) multiple filter functions.
Usage
import { and, isString } from 'typesafe-utils'
const items = [null, "test", undefined, "hi"]
const isShortString = and<string, any>(isString, (value) => value.length < 3)
const filteredItems = items.filter(isShortString)
// filteredItems: string[] => ['hi']or
Combines (||) multiple filter functions.
Usage
import { or } from 'typesafe-utils'
const items = [10, 2, 3, 5, 8, 1]
const isFiveOrTen = or((value) => value === 5, (value) => value === 10)
const filteredItems = items.filter(isFiveOrTen)
// filteredItems: number[] => [10, 5]not
Inverts a filter function.
Usage
import { not, filterDuplicates } from 'typesafe-utils'
type Product = {
id: number
name: string
}
const items: Product[] = [
{ id: 1, name: 'name-1' },
{ id: 2, name: 'name-2' },
{ id: 3, name: 'name-1' },
{ id: 4, name: 'name-2' }
]
const filteredItems = items.filter(not<Product>(filterDuplicatesByKey('name')))
// filteredItems: Product[] => [{ id: 3, name: 'name-1' }, { id: 4, name: 'name-2' }]
// The `not` function takes two optional type arguments.
// The first is the type you expect the filter function to return.
// The second is the Type of the Array you want to filter.
// e.g.
const notNull = [1, 5, null].filter<number, number | null>(not((value => value === null)))
// notNull: number[] => [1, 5]
createFilter
Creates a typeguard filter.
Usage
import { createFilter } from 'typesafe-utils'
interface Item {
id: number
}
interface ItemWithName extends Item {
name: string
}
const items: (Item | ItemWithName | undefined)[] = [
{ id: 1 },
undefined
{ id: 3, name: 'name-1' },
{ id: 4 }
]
const filterHasName = createFilter<ItemWithName>((item) => !!item?.name)
const filteredItems = items.filter(filterHasName)
// filteredItems: ItemWithName[] => [{ id: 3, name: 'name-1' }]sorting functions
sortNumberASC
sort number in ASC order
Usage
import { sortNumberASC } from 'typesafe-utils'
const items = [4, -1, 3, 0]
const result = items.sort(sortNumberASC)
// result: number[] => [-1, 0, 3, 4]sortNumberDESC
sort number in DESC order
Usage
import { sortNumberDESC } from 'typesafe-utils'
const items = [2, -5, 0]
const result = items.sort(sortNumberDESC)
// result: number[] => [2, 0, -5]sortNumberPropertyASC
sort property of type number in ASC order
Usage
import { sortNumberPropertyASC } from 'typesafe-utils'
type Car {
speed: number
}
const items: Car[] = [
{ speed: 113 },
{ speed: 100 },
{ speed: 95 }
]
const result = items.sort(sortNumberPropertyASC('speed'))
// result: Car[] => [{ speed: 95 }, { speed: 100 }, { speed: 113 }}sortNumberPropertyDESC
sort property of type number in DESC order
Usage
import { sortNumberPropertyDESC } from 'typesafe-utils'
type Car {
speed: number
}
const items: Car[] = [
{ speed: 70 }
{ speed: 87 }
]
const result = items.sort(sortNumberPropertyDESC('speed'))
// result: Car[] => [{ speed: 87 }, { speed: 70 }]sortStringASC
sort string in ASC order
Usage
import { sortStringASC } from 'typesafe-utils'
const items = ['Hi', 'apples']
const result = items.sort(sortStringASC)
// result: string[] => ['apples', Hi']sortStringDESC
sort string in DESC order
Usage
import { sortStringDESC } from 'typesafe-utils'
const items = ['apple', 'banana']
const result = items.sort(sortStringDESC)
// result: string[] => ['banana', 'apple']sortStringPropertyASC
sort property of type string in ASC order
Usage
import { sortStringPropertyASC } from 'typesafe-utils'
type Car {
color: string
}
const items: Car[] = [
{ color: 'green' },
{ color: 'brown' }
]
const result = items.sort(sortStringPropertyASC('color'))
// result: Car[] => [{ color: 'brown' }, { color: 'green' }]sortStringPropertyDESC
sort property of type string in DESC order
Usage
import { sortStringPropertyDESC } from 'typesafe-utils'
type Car {
color: string
}
const items: Car[] = [
{ color: 'red' },
{ color: 'blue' }
]
const result = items.sort(sortStringPropertyDESC('color'))
// result: Car[] => [{ color: 'red' }, { color: 'blue' }]sortDateASC
sort Date in ASC order
Usage
import { sortDateASC } from 'typesafe-utils'
const today = new Date()
const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000)
const items = [tomorrow, today]
const result = items.sort(sortDateASC)
// result: Date[] => [today, tomorrow]sortDateDESC
sort Date in DESC order
Usage
import { sortDateDESC } from 'typesafe-utils'
const today = new Date()
const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000)
const items = [today, tomorrow]
const result = items.sort(sortDateDESC)
// result: Date[] => [tomorrow, today]sortDatePropertyASC
sort property of type Date in ASC order
Usage
import { sortDatePropertyASC } from 'typesafe-utils'
type Smartphone = {
releaseDate: Date
}
const today = new Date()
const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000)
const items: Smartphone[] = [
{ releaseDate: tomorrow },
{ releaseDate: today }
]
const items: Smartphone[] = []
const result = items.sort(sortDatePropertyASC('releaseDate'))
// result: Smartphone[]=> [{ releaseDate: today }, { releaseDate: tomorrow }]sortDatePropertyDESC
sort property of type Date in DESC order
Usage
import { sortDatePropertyDESC } from 'typesafe-utils'
type Smartphone = {
releaseDate: Date
}
const today = new Date()
const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000)
const items: Smartphone[] = [
{ releaseDate: today },
{ releaseDate: tomorrow }
]
const result = items.sort(sortDatePropertyDESC('releaseDate'))
// result: Smartphone[] => [{ releaseDate: tomorrow }, { releaseDate: today }]mapping functions
pick
Picks an attribute from an Object.
Usage
import { pick } from 'typesafe-utils'
interface Item {
id: number
name: string
price: number
}
const items: Item[] = [
{ id: 1, name: '', price: 123 },
{ id: 3, name: '', price: 0 },
{ id: 7, name: '', price: 12 },
]
const ids = items.map(pick('id'))
// ids: number[] => [ 1, 3, 7 ]other
deepClone
Creates a deep copy of an object containing primitive values.
Motivation: I have seen a variety of clone-functions that return any. There you would need to always specify the type by ourself. Using this function, you will get a correctly typed object back.
Usage
import { deepClone } from 'typesafe-utils'
const objectToClone: MyTypedObject = { ... }
const clonedObject = deepClone(objectToClone)
// => clonedObject: MyTypedObject => { ... }uniqueArray
Removes duplicates from an array.
Usage
import { uniqueArray } from 'typesafe-utils'
const unique = uniqueArray('John', 'Max', 'John')
// => unique: string[] => ['John', 'Max']Types
Truthy
Contains all Truthy values (everything excluding Falsy values)
Usage
import { Truthy } from 'typesafe-utils'
export const isTruthy = <T>(value: T): value is Truthy<T> => !!value
const truthy = [123, undefined].filter(isTruthy) // => number[]
const notTruthy = [false, true].filter(isTruthy) // => never[]Falsy
Contains all Falsy values (false | '' | 0 | null | undefined)
Usage
import { Falsy } from 'typesafe-utils'
export const isFalsy = <T>(value: T): value is Falsy<T> => !value
const falsy = [undefined, ''].filter(isFalsy) // => undefined[]
const notFalsy = [0, ''].filter(isFalsy) // => never[]TypeGuard
TypeGuardWithReturnType
Allows you to write custom TypeGuard functions.
Usage
import { TypeGuard } from 'typesafe-utils'
type Project {
id: number
// ...
}
const isProject = <T>(value: T): value is TypeGuard<Project, T> => value?.hasOwnProperty('id')
const p1 = isProject({ id: 1 }) // => true
const p2 = isProject(true) // => falseTypeGuardInverted
TypeGuardInvertedWithReturnType
Allows you to write custom inverted TypeGuard functions.
Usage
import { TypeGuardInverted } from 'typesafe-utils'
type Project {
id: number
// ...
}
const isNotProject = <T>(value: T): value is TypeGuardInverted<Project, T> => !value?.hasOwnProperty('id')
const p1 = isNotProject({ id: 1 }) // => false
const p2 = isNotProject(null) // => true