@igor.dvlpr/common-types NPM

📃 Table of contents

🕵🏼 Usage

Install it by executing:

npm i -D "@igor.dvlpr/common-types"

🤹🏼 API

`KeysOf<Type>`

Extracts all keys from the type Type.

!TIP CAN be used with generics as well.

example.ts

type ArrayKeys = KeysOf<Array<string>> // 'at' | 'concat' | 'copyWithin', etc.

`TypeOfValues<Type>`

Extracts all value types of the type Type. Works with top-level properties only.

IPerson.ts

interface IPerson {
  firstName: string
  lastName: string
  zip: number
  isMember: boolean
}

example.ts

type ValueTypes = TypeOfValues<IPerson> // string | number | boolean

`MethodsOf<Type>`

Extracts all methods from the type Type.

!CAUTION Can NOT be used with generics.

example.ts

type NumberMethods = MethodsOf<Number> // 'toString' | 'toFixed' | 'toExponential' | 'toPrecision' | 'valueOf' | 'toLocaleString'

`PropertiesOf<Type>`

Extracts all properties from the type Type.

!CAUTION Can NOT be used with generics.

example.ts

type StringProperties = PropertiesOf<String> // 'length'

`DeepPartial<Type>`

Constructs a type with all top-level and nested properties of the type Type set to optional.

!TIP See also TypeScript's built-in utility type Partial<Type> .

IPerson.ts

interface IPerson {
  name: string
  address: {
    city: string
    zip: number
  }
}

example.ts

type PersonOptional = DeepPartial<IPerson>

/**
 * PersonOptional:
 *  {
 *    name?: string
 *    address?: {
 *      city?: string
 *      zip?: number
 *    }
 *  }
 */

`Promisable<Type>`

Provides a convenient way to allow flexibility in handling values that could either be immediate or asynchronously resolved.

example.ts

const immediateValue: number = 42
const promiseValue: Promisable<number> = Promise.resolve(42)

async function handleValue(value: Promisable<number>) {
  const result = await processValue(value)
  console.log(result) // Will log the number 42, whether value was a direct number or a Promise resolving to 42
}

handleValue(immediateValue)
handleValue(promiseValue)

`EnumKeys<Type, KeyType>`

Extracts all keys from the Type that are of the type KeyType.

IConfig

interface IConfig {
  apiUrl: string
  timeout: number
  isEnabled: boolean
  retryAttempts: number
}

example.ts

type ConfigNumbers = EnumKeys<IConfig, number> // 'timeout' | 'retryAttempts'

`Func<Args, FnReturn>`

Constructs a generic Function-like type with the arguments of type Args and the return value of type FnReturn.

example.ts

function process(items: number[], callback: Func<number, boolean>): boolean {
  // shortened for brevity
  // do NOT access your Array immediately :)
  for (let i = 0; i < items.length; i++) {
    if (callback(items[i])) {
      return true
    }
  }

  return false
}

process([1, 1, 8, 1], (item) => {
  if (item % 2 === 0) {
    return true
  }

  return false
}) // returns true

`Callback<Args, FnReturn>`

Alias of Func<Args, FnReturn>.

`TrimLeft<Input>`

Recursively removes all leading whitespace from the String type Input.

example.ts

type Id = '    ID'
type ProperId = TrimLeft<Id>

const id: ProperId = '   ID' // ERROR: does NOT accept leading whitespace

`TrimRight<Input>`

Recursively removes all trailing whitespace from the String type Input.

example.ts

type Id = 'ID     '
type ProperId = TrimRight<Id>

const id: ProperId = 'ID    ' // ERROR: does NOT accept leading whitespace

`Trim<Input>`

Recursively removes all leading and trailing whitespace from the String type Input.

example.ts

type Id = '    ID     '
type ProperId = Trim<Id>

const id: ProperId = '   ID    ' // ERROR: does NOT accept leading nor trailing whitespace

!TIP A very cool usage of the Trim<Input> type is implemented in the magic-querySelector project.

`IsGeneric<Type>`

Returns a Boolean whether the type Type is a generic.

example.ts

type ArrayIsGeneric = IsGeneric<Array<string>> // true
type NumberIsGeneric = IsGeneric<number> // false

`MethodSignature<Type, Method>`

Gets the method signature Method of the type Type.

example.ts

type NumberToFixedMethod = MethodSignature<Number, 'toFixed'> // expects (fractionDigits?: number) => string

`Override<Type, Changes>`

Overrides the type Type with the new type of Changes.

IPerson

interface IPerson {
  name: string
  children: boolean
}

example.ts

const person: IPerson = {
  name:'John Doe',
  children: true
}

type NewPerson = Override<IPerson, { children: number }> //only accepts existing keys

const newPerson: NewPerson = {
  name:'John Doe',
  children: 2
}

`HasOverlap<FirstType, SecondType>`

Checks whether the types FirstType and SecondType overlap, i.e. have the same keys.

!WARNING It only checks the key names, NOT their TYPES!

IPerson

interface IPerson {
  name: string
  children: boolean
}

example.ts

type PersonOverlap = HasOverlap<
  IPerson,
  {
    name: string
    children: boolean
  }
> // returns true

`Extend<Type, Changes>`

Extends the type Type with the new type of Changes with only non-existent keys in type Type.

IPerson

interface IPerson {
  name: string
  children: number
}

example.ts

type NewPerson = Extend<IPerson, { name: string }> //only accepts non-existing keys
// will return `never` here
const newPerson: NewPerson = {
  name: 'John Doe',
  children: 2
} // will error

type NewestPerson = Extend<IPerson, { profession: string }> //only accepts non-existing keys
const newestPerson: NewestPerson = {
  name: 'John Doe',
  children: 2,
  profession: 'Developer'
} // will NOT error

`MethodName<Type, Method>`

Checks for the existence of the method Method in the type of Type and returns it if found.

example.ts

type NumberToFixedMethod = MethodName<Number, 'toFixed'> // toFixed

✨ Examples

utils.ts

import type { Callback } from '@igor.dvlpr/common-types'

function process(
  items: number[],
  callback: Callback<number, boolean>
): boolean {
  // shortened for brevity
  // do NOT access your Array immediately :)
  for (let i = 0; i < items.length; i++) {
    if (callback(items[i])) {
      return true
    }
  }

  return false
}

const result = process([1, 1, 8, 1], (item) => {
  if (item % 2 === 0) {
    return true
  }

  return false
}) // returns true

console.log(result)