⬅️ Back to Table of Contents

📄 general

📊 Analysis Summary

Metric	Count
🔧 Functions	12
⚡ Async/Await Patterns	2
📐 Interfaces	1

📚 Table of Contents

• Async/Await Patterns
• Functions
• Interfaces

🛠️ File Location:

📂 packages/shared/utils/general.ts

Async/Await Patterns

Type	Function	Await Expressions	Promise Chains
promise-chain	promiseTimeout	none	new Promise(...)
await-expression	createSingletonPromise	_prev	none

---

Functions

promiseTimeout(ms: number, throwOnTimeout: boolean, reason: string): Promise<void>

Parameters:

• ms number
• throwOnTimeout boolean
• reason string

Returns: Promise<void>

Calls:

• setTimeout

Code

export function promiseTimeout(
  ms: number,
  throwOnTimeout = false,
  reason = 'Timeout',
): Promise<void> {
  return new Promise((resolve, reject) => {
    if (throwOnTimeout)
      setTimeout(reject, ms, reason)
    else
      setTimeout(resolve, ms)
  })
}

identity(arg: T): T

Parameters:

• arg T

Returns: T

Code

export function identity<T>(arg: T): T {
  return arg
}

createSingletonPromise(fn: () => Promise<T>): SingletonPromiseReturn<T>

Create singleton promise function

Examples:

const promise = createSingletonPromise(async () => { ... })

await promise() await promise() // all of them will be bind to a single promise instance await promise() // and be resolved together

Raw JSDoc

/**
 * Create singleton promise function
 *
 * @example
 * ```
 * const promise = createSingletonPromise(async () => { ... })
 *
 * await promise()
 * await promise() // all of them will be bind to a single promise instance
 * await promise() // and be resolved together
 * ```
 */

Calls:

• fn

Code

export function createSingletonPromise<T>(fn: () => Promise<T>): SingletonPromiseReturn<T> {
  let _promise: Promise<T> | undefined

  function wrapper() {
    if (!_promise)
      _promise = fn()
    return _promise
  }
  wrapper.reset = async () => {
    const _prev = _promise
    _promise = undefined
    if (_prev)
      await _prev
  }

  return wrapper
}

invoke(fn: () => T): T

Parameters:

• fn () => T

Returns: T

Calls:

• fn

Code

export function invoke<T>(fn: () => T): T {
  return fn()
}

containsProp(obj: object, props: string[]): boolean

Parameters:

• obj object
• props string[]

Returns: boolean

Calls:

• props.some

Code

export function containsProp(obj: object, ...props: string[]) {
  return props.some(k => k in obj)
}

increaseWithUnit(target: number, delta: number): number

Increase string a value with unit

Examples:

'2px' + 1 = '3px'

'15em' + (-2) = '13em'

Raw JSDoc

/**
 * Increase string a value with unit
 *
 * @example '2px' + 1 = '3px'
 * @example '15em' + (-2) = '13em'
 */

Code

export function increaseWithUnit(target: number, delta: number): number

pxValue(px: string): number

Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client

Raw JSDoc

/**
 * Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
 */

Calls:

• px.endsWith
• Number.parseFloat

Code

export function pxValue(px: string) {
  return px.endsWith('rem') ? Number.parseFloat(px) * 16 : Number.parseFloat(px)
}

objectPick(obj: O, keys: T[], omitUndefined: boolean): Pick<O, T>

Create a new subset object by giving keys

Raw JSDoc

/**
 * Create a new subset object by giving keys
 */

Calls:

• keys.reduce

Code

export function objectPick<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined = false) {
  return keys.reduce((n, k) => {
    if (k in obj) {
      if (!omitUndefined || obj[k] !== undefined)
        n[k] = obj[k]
    }
    return n
  }, {} as Pick<O, T>)
}

objectOmit(obj: O, keys: T[], omitUndefined: boolean): Omit<O, T>

Create a new subset object by omit giving keys

Raw JSDoc

/**
 * Create a new subset object by omit giving keys
 */

Calls:

• Object.fromEntries
• Object.entries(obj).filter
• keys.includes

Code

export function objectOmit<O extends object, T extends keyof O>(obj: O, keys: T[], omitUndefined = false) {
  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
    return (!omitUndefined || value !== undefined) && !keys.includes(key as T)
  })) as Omit<O, T>
}

objectEntries(obj: T): [keyof T, T[keyof T]][]

Parameters:

• obj T

Returns: [keyof T, T[keyof T]][]

Calls:

• Object.entries

Code

export function objectEntries<T extends object>(obj: T) {
  return Object.entries(obj) as Array<[keyof T, T[keyof T]]>
}

toArray(value: T | readonly T[]): readonly T[]

Parameters:

• value T | readonly T[]

Returns: readonly T[]

Code

export function toArray<T>(value: T | readonly T[]): readonly T[]

Internal helpers

Declared inside another function in this file.

wrapper(): Promise<T>

Returns: Promise<T>

Calls:

• fn

Code

function wrapper() {
    if (!_promise)
      _promise = fn()
    return _promise
  }

---

Interfaces

SingletonPromiseReturn<T>

Interface Code

export interface SingletonPromiseReturn<T> {
  (): Promise<T>
  /**
   * Reset current staled promise.
   * await it to have proper shutdown.
   */
  reset: () => Promise<void>
}

Properties

Name	Type	Optional	Description
reset	() => Promise<void>	✗	not shown

---

Generated by Syntax Scribe