TypeScript: use la versión correcta de setTimeout (nodo vs ventana)

Estoy trabajando para actualizar un código TypeScript antiguo para usar la última versión del compilador y tengo problemas con una llamada a setTimeout. El código espera llamar a la setTimeoutfunción del navegador que devuelve un número:

setTimeout(handler: (...args: any[]) => void, timeout: number): number;

Sin embargo, el compilador está resolviendo esto en la implementación del nodo, que devuelve un NodeJS.Timer:

setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;

Este código no se ejecuta en el nodo, pero los tipos de nodos se incorporan como una dependencia de otra cosa (no estoy seguro de qué).

¿Cómo puedo indicarle al compilador que elija la versión setTimeoutque quiero?

Aquí está el código en cuestión:

let n: number;
n = setTimeout(function () { /* snip */  }, 500);

Esto produce el error del compilador:

TS2322: El tipo 'Temporizador' no se puede asignar al tipo 'número'.

Otra solución alternativa que no afecta la declaración de variables:

let n: number;
n = <any>setTimeout(function () { /* snip */  }, 500);

Además, debería ser posible utilizar el windowobjeto explícitamente sin any:

let n: number;
n = window.setTimeout(function () { /* snip */  }, 500);

let timer: ReturnType<typeof setTimeout> = setTimeout(() => { ... });

clearTimeout(timer);

Al usarlo ReturnType<fn>, obtiene independencia de la plataforma. No se verá obligado a usar anyni window.setTimeoutque se romperá si ejecuta el código sin servidor nodeJS (por ejemplo, página renderizada del lado del servidor).

Buenas noticias, ¡esto también es compatible con Deno!

Supongo que depende de dónde ejecutará su código.

Si su destino de tiempo de ejecución es el nodo JS del lado del servidor, use:

let timeout: NodeJS.Timeout;
global.clearTimeout(timeout);

Si su objetivo de tiempo de ejecución es un navegador, use:

let timeout: number;
window.clearTimeout(timeout);

Es probable que esto funcione con versiones anteriores, pero con la versión TypeScript ^3.5.3y la versión Node.js ^10.15.3, debería poder importar las funciones específicas de Node desde el módulo Timers , es decir:

import { setTimeout } from 'timers';

Eso devolverá una instancia de Timeout de tipo NodeJS.Timeoutque puede pasar a clearTimeout:

import { clearTimeout, setTimeout } from 'timers';

const timeout: NodeJS.Timeout = setTimeout(function () { /* snip */  }, 500);

clearTimeout(timeout);

Enfrenté el mismo problema y la solución alternativa que nuestro equipo decidió usar fue simplemente usar "cualquiera" para el tipo de temporizador. P.ej:

let n: any;
n = setTimeout(function () { /* snip */  }, 500);

Funcionará con ambas implementaciones de los métodos setTimeout / setInterval / clearTimeout / clearInterval.

• Si desea una solución real para mecanografiar sobre temporizadores, aquí vamos:

  El error está en el tipo de retorno 'número', no es Timer ni nada más.

  Esto es para la solución mecanografiada versión ~> 2.7:

export type Tick = null | number | NodeJS.Timer;

Ahora arreglamos todo, solo declaramos así:

 import { Tick } from "../../globals/types";

 export enum TIMER {
    INTERVAL = "INTERVAL",
    TIMEOUT = "TIMEOUT", 
 };

 interface TimerStateI {
   timeInterval: number;
 }

 interface TimerI: TimerStateI {
   type: string;
   autoStart: boolean;
   isStarted () : bool;
 }

     class myTimer extends React.Component<TimerI, TimerStateI > {

          private myTimer: Tick = null;
          private myType: string = TIMER.INTERVAL;
          private started: boll = false;

          constructor(args){
             super(args);
             this.setState({timeInterval: args.timeInterval});

             if (args.autoStart === true){
               this.startTimer();
             }
          }

          private myTick = () => {
            console.log("Tick");
          }    

          private startTimer = () => {

            if (this.myType === TIMER.INTERVAL) {
              this.myTimer = setInterval(this.myTick, this.timeInterval);
              this.started = true;
            } else if (this.myType === TIMER.TIMEOUT) {
              this.myTimer = setTimeout(this.myTick, this.timeInterval);
              this.started = true;
            }

          }

         private isStarted () : bool {
           return this.started;
         }

     ...
     }