TypeScript - use a versão correta de setTimeout (nó vs janela)

Estou trabalhando na atualização de algum código TypeScript antigo para usar a versão mais recente do compilador e estou tendo problemas com uma chamada para setTimeout. O código espera chamar a setTimeoutfunção do navegador que retorna um número:

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

No entanto, o compilador está resolvendo isso para a implementação do nó, que retorna um NodeJS.Timer:

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

Este código não é executado no nó, mas as tipificações do nó estão sendo puxadas como uma dependência de outra coisa (não tenho certeza do que).

Como posso instruir o compilador a escolher a versão setTimeoutque desejo?

Aqui está o código em questão:

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

Isso produz o erro do compilador:

TS2322: O tipo 'Timer' não pode ser atribuído ao tipo 'número'.

Outra solução alternativa que não afeta a declaração da variável:

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

Além disso, deve ser possível usar o windowobjeto explicitamente sem any:

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

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

clearTimeout(timer);

Ao usar, ReturnType<fn>você obtém independência da plataforma. Você não será forçado a usar anynem o window.setTimeoutque irá quebrar se você executar o código no servidor nodeJS (por exemplo, página renderizada do lado do servidor).

Boas notícias, isso também é compatível com Deno!

Acho que depende de onde você executará seu código.

Se o destino do tempo de execução for Nó JS do servidor, use:

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

Se o seu destino de tempo de execução for um navegador, use:

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

Enfrentei o mesmo problema e a solução alternativa que nossa equipe decidiu usar foi apenas usar "qualquer" para o tipo de cronômetro. Por exemplo:

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

Ele funcionará com ambas as implementações dos métodos setTimeout / setInterval / clearTimeout / clearInterval.

Isso provavelmente funcionará com versões mais antigas, mas com a versão TypeScript ^3.5.3e a versão Node.js ^10.15.3, você deve ser capaz de importar as funções específicas do Node do módulo Timers , ou seja:

import { setTimeout } from 'timers';

Isso retornará uma instância de Timeout do tipo NodeJS.Timeoutque você pode passar para clearTimeout:

import { clearTimeout, setTimeout } from 'timers';

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

clearTimeout(timeout);

• Se você quer uma solução real para datilografia sobre timers, vamos lá:

  Bug está no tipo de retorno 'número', não é Timer ou qualquer outra coisa.

  Isso é para scripts de versão ~> solução 2.7:

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

Agora que consertamos tudo, basta declarar assim:

 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;
         }

     ...
     }