[TypeScript type fixes] #typescript #fix

object.entries.js

/** @type {TypedEntries} */
export function typedEntries(obj) {
  // @ts-expect-error ignore
  return Object.entries(obj);
}

/** @type {TypedFromEntries} */
export function typedFromEntries(entries) {
  return Object.fromEntries(entries);
}

object.entries.types.d.ts

//#region https://dev.to/harry0000/a-bit-convenient-typescript-type-definitions-for-objectentries-d6g

// prettier-ignore
type TupleEntry<T extends readonly unknown[], I extends unknown[] = [], R = never> =
  T extends readonly [infer Head, ...infer Tail] ?
    TupleEntry<Tail, [...I, unknown], R | [`${I['length']}`, Head]> :
    R

// prettier-ignore
// eslint-disable-next-line @typescript-eslint/ban-types
type ObjectEntry<T extends {}> =
  // eslint-disable-next-line @typescript-eslint/ban-types
  T extends object ?
    { [K in keyof T]: [K, Required<T>[K]] }[keyof T] extends infer E ?
      E extends [infer K, infer V] ?
        K extends string | number ?
          [`${K}`, V] :
          never :
        never :
      never :
    never

// prettier-ignore
// eslint-disable-next-line @typescript-eslint/ban-types
type Entry<T extends {}> =
  T extends readonly [unknown, ...unknown[]] ?
    TupleEntry<T> :
    T extends ReadonlyArray<infer U> ?
      [`${number}`, U] :
      ObjectEntry<T>

// eslint-disable-next-line @typescript-eslint/ban-types
type TypedEntries = <T extends {}>(object: T) => ReadonlyArray<Entry<T>>;

/**
 * Returns an object created by key-value entries for properties and methods
 * @param entries An iterable object that contains key-value entries for properties and methods.
 */
type TypedFromEntries = <T = any, P>(
  entries: Iterable<readonly [P, T]>
) => { [k in P]: T };

//#endregion

object.hasown.js

/** @type {TypedHasOwn} */
export function typedHasOwn(obj, fieldName) {
  return Object.hasOwn(obj, fieldName)
}

object.hasown.types.d.ts

type TypedHasOwn = <Obj extends object>(
  obj: Obj,
  field: any
) => field is keyof Obj

object.keys.js

/** @type {TypedKeys} */
export function typedKeys(obj) {
  // @ts-expect-error ignore
  return Object.keys(obj)
}

object.keys.types.d.ts

type TypedKeys = <T = any>(obj: T) => (keyof T)[]