Common Types

🔦 Provides frequently used types for your TypeScript projects. 🦄

📃 Table of Contents

- Features
- API
- KeysOf\
- TypeOfValues\
- MethodsOf\
- PropertiesOf\
- DeepPartial\
- Promisable\
- EnumKeys\
- Func
- Callback
- TrimLeft\
- TrimRight\
- Trim\
- IsGeneric\
- MethodSignature\
- Override\
- HasOverlap\
- Extend\
- MethodName\
- Usage
- API
- Examples
- Changelog
- Support
- License
- Related
- Author

🤖 Features

- 🗝 Get all keys of a type with KeysOf
- 📦 Extract all value types from top-level properties via TypeOfValues
- 🔍 Identify only method keys using MethodsOf
- 🧾 Identify only property keys using PropertiesOf
- 🌿 Make every property (nested too) optional with DeepPartial
- ⏳ Accept sync or async values using Promisable
- 🎯 Find keys whose values match a specific type via EnumKeys
- 🛠 Define generic function signatures with Func or Callback
- ✂ Remove leading/trailing whitespace in string types with TrimLeft, TrimRight, Trim
- ❓ Detect generic types using IsGeneric
- 📜 Get a method’s exact signature with MethodSignature
- 📝 Override existing keys with new types via Override
- 🚫 Prevent extending with overlapping keys using Extend
- 🔑 Validate a method exists and return its name with MethodName

🕵🏼 Usage

Install it by executing any of the following, depending on your preferred package manager:

``bash
pnpm add @igorskyflyer/common-types
`

`bash
yarn add @igorskyflyer/common-types
`

`bash
npm i @igorskyflyer/common-types
`

🤹🏼 API

$3

Extracts all keys from the type Type.

> 💡 TIP
>
> CAN be used with generics as well.
>

example.ts
`ts
type ArrayKeys = KeysOf> // 'at' | 'concat' | 'copyWithin', etc.
`

---

$3

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

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

example.ts
`ts
type ValueTypes = TypeOfValues // string | number | boolean
`

---

$3

Extracts all methods from the type Type.

> 🛑 CAUTION
>
> Can NOT be used with generics.
>

example.ts
`ts
type NumberMethods = MethodsOf // 'toString' | 'toFixed' | 'toExponential' | 'toPrecision' | 'valueOf' | 'toLocaleString'
`

---

$3

Extracts all properties from the type Type.

> 🛑 CAUTION
>
> Can NOT be used with generics.
>

example.ts
`ts
type StringProperties = PropertiesOf // 'length'
`

---

$3

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 !An external link.
>

IPerson.ts
`ts
interface IPerson {
name: string
address: {
city: string
zip: number
}
}
`

example.ts
`ts
type PersonOptional = DeepPartial

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

---

$3

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

example.ts
`ts
const immediateValue: number = 42
const promiseValue: Promisable = Promise.resolve(42)

async function handleValue(value: Promisable) {
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)
`

---

$3

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

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

example.ts
`ts
type ConfigNumbers = EnumKeys // 'timeout' | 'retryAttempts'
`

---

$3

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

example.ts
`ts
function process(items: number[], callback: Func): 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
`

---

$3

Alias of Func.

---

$3

Recursively removes all leading whitespace from the String type Input.

example.ts
`ts
type Id = ' ID'
type ProperId = TrimLeft

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

$3

Recursively removes all trailing whitespace from the String type Input.

example.ts
`ts
type Id = 'ID '
type ProperId = TrimRight

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

$3

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

example.ts
`ts
type Id = ' ID '
type ProperId = Trim

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

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

---

$3

Returns a Boolean whether the type Type is a generic.

example.ts
`ts
type ArrayIsGeneric = IsGeneric> // true
type NumberIsGeneric = IsGeneric // false
`
---

$3

Gets the method signature Method of the type Type.

example.ts
`ts
type NumberToFixedMethod = MethodSignature // expects (fractionDigits?: number) => string
`

---

$3

Overrides the type Type with the new type of Changes.

IPerson
`ts
interface IPerson {
name: string
children: boolean
}
`

example.ts
`ts
const person: IPerson = {
name:'John Doe',
children: true
}

type NewPerson = Override //only accepts existing keys

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

---

$3

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
`ts
interface IPerson {
name: string
children: boolean
}
`

example.ts
`ts
type PersonOverlap = HasOverlap<
IPerson,
{
name: string
children: boolean
}
> // returns true
`
---

$3

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

IPerson
`ts
interface IPerson {
name: string
children: number
}
`

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

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

---

$3

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

example.ts
`ts
type NumberToFixedMethod = MethodName // toFixed
`

---

🗒️ Examples

utils.ts
`ts
import type { Callback } from '@igorskyflyer/common-types'

function process(
items: number[],
callback: Callback
): 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)

``

📝 Changelog

📑 The changelog is available here, CHANGELOG.md.

🪪 License

Licensed under the MIT license which is available here, MIT license.

💖 Support

I work hard for every project, including this one and your support means a lot to me!


Consider buying me a coffee. ☕









Thank you for supporting my efforts! 🙏😊

🧬 Related

@igorskyflyer/windev

> _🍃 Provides ways of checking whether a path is a legacy Windows device. 💾_

@igorskyflyer/magic-queryselector

> _🪄 A TypeScript-types patch for querySelector/querySelectorAll, make them return types you expect them to! 🔮_

@igorskyflyer/jmap

> _🕶️ Reads a JSON file into a Map. 🌻_

@igorskyflyer/clone

> _🧬 A lightweight JavaScript utility allowing deep copy-by-value of nested objects, arrays and arrays of objects. 🪁_

@igorskyflyer/extendable-string

> _🦀 ExtendableString allows you to create strings on steroids that have custom transformations applied to them, unlike common, plain strings.. 🪀_

👨🏻‍💻 Author