Skip to content

Commit 79cf7f5

Browse files
Renegade334Renegade334
authored
🤖 Merge PR DefinitelyTyped#72031 [node] node:timers cleanup, restore NodeJS namespace to ambient-only by @Renegade334 
1 parent 51ba303 commit 79cf7f5

File tree

15 files changed

+899
-613
lines changed

15 files changed

+899
-613
lines changed

‎types/node/test/globals.ts‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,3 +61,8 @@ declare var RANDOM_GLOBAL_VARIABLE: true;
6161
e.message; // $ExpectType string
6262
e.name; // $ExpectType string
6363
}
64+
65+
{
66+
// @ts-expect-error The pseudoglobal `NodeJS` namespace should not be addressable outside ambient contexts
67+
NodeJS;
68+
}

‎types/node/test/timers.ts‎

Lines changed: 62 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -1,108 +1,88 @@
11
import * as timers from "node:timers";
22
import { promisify } from "node:util";
3-
{
4-
{
5-
const immediate = timers
6-
.setImmediate(() => {
7-
console.log("immediate");
8-
})
9-
.unref()
10-
.ref();
11-
const b: boolean = immediate.hasRef();
12-
timers.clearImmediate(immediate);
13-
}
14-
{
15-
const timeout = timers
16-
.setInterval(() => {
17-
console.log("interval");
18-
}, 20)
19-
.unref()
20-
.ref()
21-
.refresh();
22-
const b: boolean = timeout.hasRef();
23-
timers.clearInterval(timeout);
24-
timers.clearInterval(timeout[Symbol.toPrimitive]());
25-
}
26-
{
27-
const timeout = timers
28-
.setTimeout(() => {
29-
console.log("timeout");
30-
}, 20)
31-
.unref()
32-
.ref()
33-
.refresh();
34-
const b: boolean = timeout.hasRef();
35-
timers.clearTimeout(timeout);
36-
timers.clearTimeout(timeout[Symbol.toPrimitive]());
37-
}
38-
async function testPromisify(doSomething: {
39-
(foo: any, onSuccessCallback: (result: string) => void, onErrorCallback: (reason: any) => void): void;
40-
[promisify.custom](foo: any): Promise<string>;
41-
}) {
42-
const setTimeout = promisify(timers.setTimeout);
43-
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
44-
let v: void = await setTimeout(100);
45-
let s: string = await setTimeout(100, "");
463

47-
const setImmediate = promisify(timers.setImmediate);
48-
v = await setImmediate();
49-
s = await setImmediate("");
4+
{
5+
const promises: typeof import("node:timers/promises") = timers.promises;
6+
}
507

51-
// $ExpectType (foo: any) => Promise<string>
52-
const doSomethingPromise = promisify(doSomething);
8+
{
9+
// $ExpectType Immediate
10+
const immediate = timers.setImmediate(() => {});
11+
// $ExpectType boolean
12+
immediate.hasRef();
13+
// $ExpectType Immediate
14+
immediate.ref();
15+
// $ExpectType Immediate
16+
immediate.unref();
5317

54-
// $ExpectType string
55-
s = await doSomethingPromise("foo");
56-
}
18+
timers.clearImmediate(immediate);
19+
immediate[Symbol.dispose]();
5720
}
5821

5922
{
60-
const setTimeout = promisify(timers.setTimeout);
23+
// $ExpectType Timeout
24+
const interval = timers.setInterval(() => {}, 100);
25+
// $ExpectType Timeout
26+
interval.close();
27+
// $ExpectType boolean
28+
interval.hasRef();
29+
// $ExpectType Timeout
30+
interval.ref();
31+
// $ExpectType Timeout
32+
interval.refresh();
33+
// $ExpectType Timeout
34+
interval.unref();
6135

62-
const ac = new AbortController();
63-
64-
const signal = ac.signal;
65-
setTimeout(10, undefined, { signal });
66-
ac.abort();
36+
timers.clearInterval(interval);
37+
timers.clearInterval(interval[Symbol.toPrimitive]());
38+
interval[Symbol.dispose]();
6739
}
6840

6941
{
70-
const setImmediate = promisify(timers.setImmediate);
42+
// $ExpectType Timeout
43+
const timeout = timers.setTimeout(() => {}, 100);
44+
// $ExpectType Timeout
45+
timeout.close();
46+
// $ExpectType boolean
47+
timeout.hasRef();
48+
// $ExpectType Timeout
49+
timeout.ref();
50+
// $ExpectType Timeout
51+
timeout.refresh();
52+
// $ExpectType Timeout
53+
timeout.unref();
7154

72-
const ac = new AbortController();
55+
timers.clearTimeout(timeout);
56+
timers.clearTimeout(timeout[Symbol.toPrimitive]());
57+
timeout[Symbol.dispose]();
58+
}
7359

74-
const signal = ac.signal;
75-
setImmediate(10, { signal });
76-
ac.abort();
60+
// Test custom promisifiers
61+
{
62+
const setImmediate: typeof timers.promises.setImmediate = promisify(timers.setImmediate);
63+
const setTimeout: typeof timers.promises.setTimeout = promisify(timers.setTimeout);
64+
// @ts-expect-error setInterval is not promisifiable
65+
const setInterval: typeof timers.promises.setInterval = promisify(timers.setInterval);
7766
}
7867

79-
// unresolved callback argument types
68+
// Allow single callback parameter of type `unknown` to be omitted from passed arguments
8069
{
8170
// `NodeJS.*` is present to make sure we're not using `dom` types
8271
new Promise((resolve): NodeJS.Timeout => timers.setTimeout(resolve, 100));
83-
new Promise((resolve): NodeJS.Timer => timers.setInterval(resolve, 100));
84-
// tslint:disable-next-line no-unnecessary-callback-wrapper
72+
new Promise((resolve): NodeJS.Timeout => timers.setInterval(resolve, 100));
8573
new Promise((resolve): NodeJS.Immediate => timers.setImmediate(resolve));
74+
// @ts-expect-error single argument should not be optional if not of type `unknown`
75+
const timeout: NodeJS.Timeout = timers.setTimeout((s: string) => {}, 100);
8676
}
8777

8878
// globals
8979
{
90-
setTimeout((a: number, b: string) => {}, 12, 1, "test");
91-
setInterval((a: number, b: string) => {}, 12, 1, "test");
92-
setImmediate((a: number, b: string) => {}, 1, "test");
93-
queueMicrotask(() => {
94-
// cool
95-
});
80+
const setImmediate: typeof timers.setImmediate = globalThis.setImmediate;
81+
const setInterval: typeof timers.setInterval = globalThis.setInterval;
82+
const setTimeout: typeof timers.setTimeout = globalThis.setTimeout;
83+
const clearImmediate: typeof timers.clearImmediate = globalThis.clearImmediate;
84+
const clearInterval: typeof timers.clearInterval = globalThis.clearInterval;
85+
const clearTimeout: typeof timers.clearTimeout = globalThis.clearTimeout;
9686

97-
function waitFor(options?: { timeout: number }) {
98-
const timerId = options && setTimeout(() => {}, options.timeout);
99-
clearTimeout(timerId);
100-
timerId?.[Symbol.dispose]();
101-
const intervalId = options && setTimeout(() => {}, options.timeout);
102-
clearInterval(intervalId);
103-
intervalId?.[Symbol.dispose]();
104-
const immediateId = options && setImmediate(() => {});
105-
clearImmediate(immediateId);
106-
immediateId?.[Symbol.dispose]();
107-
}
87+
queueMicrotask(() => {});
10888
}

‎types/node/test/timers_promises.ts‎

Lines changed: 31 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,27 +1,42 @@
11
import { TimerOptions } from "node:timers";
22
import { scheduler, setImmediate, setInterval, setTimeout } from "node:timers/promises";
3+
34
const opts: TimerOptions = {
45
ref: false,
56
signal: new AbortController().signal,
67
};
78

8-
const res: Promise<number> = setImmediate(123, opts);
9-
setImmediate(); // $ExpectType Promise<void>
10-
11-
const res2: Promise<string> = setTimeout(123, "asd", opts);
12-
setTimeout(); // $ExpectType Promise<void>
9+
// $ExpectType Promise<number>
10+
setImmediate(123, opts);
11+
// $ExpectType Promise<number>
12+
setImmediate(123);
13+
// $ExpectType Promise<void>
14+
setImmediate();
1315

14-
const res3: AsyncIterable<string> = setInterval(123, "asd", opts);
15-
setInterval(); // $ExpectType AsyncIterable<void>
16+
// $ExpectType Promise<string>
17+
setTimeout(123, "asd", opts);
18+
// $ExpectType Promise<string>
19+
setTimeout(123, "asd");
20+
// $ExpectType Promise<void>
21+
setTimeout(123);
22+
// $ExpectType Promise<void>
23+
setTimeout();
1624

17-
const res4: Promise<void> = scheduler.yield();
18-
scheduler.yield(); // $ExpectType Promise<void>
25+
// $ExpectType AsyncIterator<string, any, any>
26+
setInterval(123, "asd", opts);
27+
// $ExpectType AsyncIterator<string, any, any>
28+
setInterval(123, "asd");
29+
// $ExpectType AsyncIterator<void, any, any>
30+
setInterval(123);
31+
// $ExpectType AsyncIterator<void, any, any>
32+
setInterval();
1933

20-
const res5: Promise<void> = scheduler.wait(123, opts);
21-
scheduler.wait(); // $ExpectType Promise<void>
34+
// $ExpectType Promise<void>
35+
scheduler.wait(123, { signal: new AbortController().signal });
36+
// $ExpectType Promise<void>
37+
scheduler.wait(123);
38+
// @ts-expect-error
39+
scheduler.wait();
2240

23-
(async () => {
24-
for await (const test of setInterval(123, 1)) {
25-
test; // $ExpectType number
26-
}
27-
});
41+
// $ExpectType Promise<void>
42+
scheduler.yield();

0 commit comments

Comments
 (0)