React TypeScript types

index.tsx

/* Type guards */

export function assertType<T>(obj: any, assertion: (obj: T) => boolean): asserts obj is T {
  if (!assertion(obj)) throw new Error('Invalid type')
}

export function is<T>(obj: any, assertion: (obj: T) => boolean): obj is T {
  return assertion(obj);
}

function isFish(pet: Fish | Bird): pet is Fish {
    return (<Fish>pet).swim !== undefined;
}
        
/* 
  Assertion functions
    https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
*/
        
/* Module augmentation */

// declare module 'React' {
//   interface Component<P, S> {
//     setState<K extends keyof T, T = this['state']>(
//       state: ((prevState: Readonly<T>, props: Readonly<P>) => (Pick<T, K> | T | null)) | (Pick<T, K> | T | null),
//       callback?: () => void
//     ): void
//   }
// }

declare module 'react' {
  interface Component<P = {}> {
    setState<K extends keyof T, T extends this['state']>(
      state: ((prevState: Readonly<T>, props: Readonly<P>) => Pick<T, K> | T | null) | (Pick<T, K> | T | null),
      callback?: () => void
    ): void;
  }

  interface PureComponent<P = {}> {
    setState<K extends keyof T, T extends this['state']>(
      state: ((prevState: Readonly<T>, props: Readonly<P>) => Pick<T, K> | T | null) | (Pick<T, K> | T | null),
      callback?: () => void
    ): void;
  }
}

declare global {
  interface Console {
    debug(message?: any, ...optionalParams: any[]): false;
    error(message?: any, ...optionalParams: any[]): false;
    warn(message?: any, ...optionalParams: any[]): false;
    log(message?: any, ...optionalParams: any[]): false;
  }
}

typings.d.ts

/* Ambient module declaration */

declare module JSX {
  interface IntrinsicElements {
    'ion-icon': {name: string}
  }
}

declare module '*.svg';
declare module '*.png';
declare module '*.jpg';
      

type CoercePartial<T extends {}, U> = {
  [K in keyof T]?: T[K] extends Array<infer A>
    ? Array<CoercePartial<A, U>>
    : T[K] extends object
      ? CoercePartial<T[K], U>
      : U;
};

type Modify<T, R> = Omit<T, keyof R> & R;

type NonNullableDeep<T> = {
  [K in keyof T]-?: NonNullableDeep<NonNullable<T[K]>>;
};
type RequiredDeep<T> = NonNullableDeep<T>;


type RequiredDeep_old<T extends {}> = {
  [K in keyof T]-?: NonNullable<T[K]> extends Array<infer U>
    ? NonNullable<RequiredDeep<U>>[]
    : NonNullable<T[K]> extends object
      ? RequiredDeep<NonNullable<T[K]>>
      : NonNullable<T[K]>
};