⬅️ Back to Table of Contents

📄 builtinSymbolLikes

📊 Analysis Summary

Metric	Count
🔧 Functions	8
📦 Imports	1

📚 Table of Contents

• Imports
• Functions

🛠️ File Location:

📂 packages/type-utils/src/builtinSymbolLikes.ts

📦 Imports

Name	Source
isSymbolFromDefaultLibrary	./isSymbolFromDefaultLibrary

---

Functions

isPromiseLike(program: ts.Program, type: ts.Type): boolean

Examples:

```ts
class DerivedClass extends Promise<number> {}
DerivedClass.reject
// ^ PromiseLike

<details><summary>Raw JSDoc</summary>

```typescript
/**
 * @example
 * ```ts
 * class DerivedClass extends Promise<number> {}
 * DerivedClass.reject
 * // ^ PromiseLike
 * ```
 */

Calls:

• isBuiltinSymbolLike

Code

export function isPromiseLike(program: ts.Program, type: ts.Type): boolean {
  return isBuiltinSymbolLike(program, type, 'Promise');
}

isPromiseConstructorLike(program: ts.Program, type: ts.Type): boolean

Examples:

```ts
const value = Promise
value.reject
// ^ PromiseConstructorLike

<details><summary>Raw JSDoc</summary>

```typescript
/**
 * @example
 * ```ts
 * const value = Promise
 * value.reject
 * // ^ PromiseConstructorLike
 * ```
 */

Calls:

• isBuiltinSymbolLike

Code

export function isPromiseConstructorLike(
  program: ts.Program,
  type: ts.Type,
): boolean {
  return isBuiltinSymbolLike(program, type, 'PromiseConstructor');
}

isErrorLike(program: ts.Program, type: ts.Type): boolean

Examples:

```ts
class Foo extends Error {}
new Foo()
//   ^ ErrorLike

<details><summary>Raw JSDoc</summary>

```typescript
/**
 * @example
 * ```ts
 * class Foo extends Error {}
 * new Foo()
 * //   ^ ErrorLike
 * ```
 */

Calls:

• isBuiltinSymbolLike

Code

export function isErrorLike(program: ts.Program, type: ts.Type): boolean {
  return isBuiltinSymbolLike(program, type, 'Error');
}

isReadonlyErrorLike(program: ts.Program, type: ts.Type): boolean

Examples:

```ts
type T = Readonly<Error>
//   ^ ReadonlyErrorLike

<details><summary>Raw JSDoc</summary>

```typescript
/**
 * @example
 * ```ts
 * type T = Readonly<Error>
 * //   ^ ReadonlyErrorLike
 * ```
 */

Calls:

• isReadonlyTypeLike
• isErrorLike
• isReadonlyErrorLike

Code

export function isReadonlyErrorLike(
  program: ts.Program,
  type: ts.Type,
): boolean {
  return isReadonlyTypeLike(program, type, subtype => {
    const [typeArgument] = subtype.aliasTypeArguments;
    return (
      isErrorLike(program, typeArgument) ||
      isReadonlyErrorLike(program, typeArgument)
    );
  });
}

isReadonlyTypeLike(program: ts.Program, type: ts.Type, predicate: ( subType: { aliasSymbol: ts.Symbol; al…): boolean

Examples:

```ts
type T = Readonly<{ foo: 'bar' }>
//   ^ ReadonlyTypeLike

<details><summary>Raw JSDoc</summary>

```typescript
/**
 * @example
 * ```ts
 * type T = Readonly<{ foo: 'bar' }>
 * //   ^ ReadonlyTypeLike
 * ```
 */

Calls:

• isBuiltinTypeAliasLike
• subtype.aliasSymbol.getName
• predicate

Code

export function isReadonlyTypeLike(
  program: ts.Program,
  type: ts.Type,
  predicate?: (
    subType: {
      aliasSymbol: ts.Symbol;
      aliasTypeArguments: readonly ts.Type[];
    } & ts.Type,
  ) => boolean,
): boolean {
  return isBuiltinTypeAliasLike(program, type, subtype => {
    return (
      subtype.aliasSymbol.getName() === 'Readonly' && !!predicate?.(subtype)
    );
  });
}

isBuiltinTypeAliasLike(program: ts.Program, type: ts.Type, predicate: ( subType: { aliasSymbol: ts.Symbol; al…): boolean

Parameters:

• program ts.Program
• type ts.Type
• predicate ( subType: { aliasSymbol: ts.Symbol; aliasTypeArguments: readonly ts.Type[]; } & ts.Type, ) => boolean

Returns: boolean

Calls:

• isBuiltinSymbolLikeRecurser
• isSymbolFromDefaultLibrary (from ./isSymbolFromDefaultLibrary)
• predicate

Code

export function isBuiltinTypeAliasLike(
  program: ts.Program,
  type: ts.Type,
  predicate: (
    subType: {
      aliasSymbol: ts.Symbol;
      aliasTypeArguments: readonly ts.Type[];
    } & ts.Type,
  ) => boolean,
): boolean {
  return isBuiltinSymbolLikeRecurser(program, type, subtype => {
    const { aliasSymbol, aliasTypeArguments } = subtype;

    if (!aliasSymbol || !aliasTypeArguments) {
      return false;
    }

    if (
      isSymbolFromDefaultLibrary(program, aliasSymbol) &&
      predicate(
        subtype as {
          aliasSymbol: ts.Symbol;
          aliasTypeArguments: readonly ts.Type[];
        } & ts.Type,
      )
    ) {
      return true;
    }

    return null;
  });
}

isBuiltinSymbolLike(program: ts.Program, type: ts.Type, symbolName: string | string[]): boolean

Parameters:

• program ts.Program
• type ts.Type
• symbolName string | string[]

Returns: boolean

Calls:

• isBuiltinSymbolLikeRecurser
• subType.getSymbol
• symbol.getName
• Array.isArray
• symbolName.some
• isSymbolFromDefaultLibrary (from ./isSymbolFromDefaultLibrary)

Code

export function isBuiltinSymbolLike(
  program: ts.Program,
  type: ts.Type,
  symbolName: string | string[],
): boolean {
  return isBuiltinSymbolLikeRecurser(program, type, subType => {
    const symbol = subType.getSymbol();
    if (!symbol) {
      return false;
    }

    const actualSymbolName = symbol.getName();

    if (
      (Array.isArray(symbolName)
        ? symbolName.some(name => actualSymbolName === name)
        : actualSymbolName === symbolName) &&
      isSymbolFromDefaultLibrary(program, symbol)
    ) {
      return true;
    }

    return null;
  });
}

isBuiltinSymbolLikeRecurser(program: ts.Program, type: ts.Type, predicate: (subType: ts.Type) => boolean | null): boolean

Parameters:

• program ts.Program
• type ts.Type
• predicate (subType: ts.Type) => boolean | null

Returns: boolean

Calls:

• type.isIntersection
• type.types.some
• isBuiltinSymbolLikeRecurser
• type.isUnion
• type.types.every
• tsutils.isTypeParameter
• type.getConstraint
• predicate
• type.getSymbol
• tsutils.isSymbolFlagSet
• program.getTypeChecker
• checker.getDeclaredTypeOfSymbol
• checker.getBaseTypes

Code

export function isBuiltinSymbolLikeRecurser(
  program: ts.Program,
  type: ts.Type,
  predicate: (subType: ts.Type) => boolean | null,
): boolean {
  if (type.isIntersection()) {
    return type.types.some(t =>
      isBuiltinSymbolLikeRecurser(program, t, predicate),
    );
  }
  if (type.isUnion()) {
    return type.types.every(t =>
      isBuiltinSymbolLikeRecurser(program, t, predicate),
    );
  }
  if (tsutils.isTypeParameter(type)) {
    const t = type.getConstraint();

    if (t) {
      return isBuiltinSymbolLikeRecurser(program, t, predicate);
    }

    return false;
  }

  const predicateResult = predicate(type);
  if (typeof predicateResult === 'boolean') {
    return predicateResult;
  }

  const symbol = type.getSymbol();
  if (
    symbol &&
    tsutils.isSymbolFlagSet(
      symbol,
      ts.SymbolFlags.Class | ts.SymbolFlags.Interface,
    )
  ) {
    const checker = program.getTypeChecker();
    const declaredType = checker.getDeclaredTypeOfSymbol(symbol);

    for (const baseType of checker.getBaseTypes(
      declaredType as ts.InterfaceType,
    )) {
      if (isBuiltinSymbolLikeRecurser(program, baseType, predicate)) {
        return true;
      }
    }
  }
  return false;
}

---

Generated by Syntax Scribe