Imports in tests refactoring

slowcheetah · zloirock · commit 9dc8a5e6b0c4 · 2026-01-05T01:50:32.000+02:00
diff --git a/packages/core-js-types/src/base/web/efficient-script-yielding.d.ts b/packages/core-js-types/src/base/web/efficient-script-yielding.d.ts
@@ -1,4 +1,4 @@
-type Immediate = number | object | undefined; // For compatibility with Node, `undefined` has been added
+type Immediate = number | object;
 
 /**
  * Schedules the execution of a function as soon as possible after the current script yields.
@@ -12,4 +12,4 @@ declare function setImmediate(handler: (...args: any[]) => void, ...args: any[])
  * Cancels a function scheduled with setImmediate.
  * @param immediate The identifier of the scheduled function to cancel.
  */
-declare function clearImmediate(immediate: Immediate): void;
+declare function clearImmediate(immediate: Immediate | undefined): void; // For compatibility with Node, `undefined` has been added
diff --git a/tests/type-definitions/entries.pure.ts b/tests/type-definitions/entries.pure.ts
@@ -1,8 +1,8 @@
-import $date from '@core-js/pure/full/date/index';
-new $date();
+import $Date from '@core-js/pure/full/date/index';
+new $Date();
 
-import $date2 from '@core-js/pure/full/date/index.js';
-new $date2();
+import $Date2 from '@core-js/pure/full/date/index.js';
+new $Date2();
 
-import $date3 from '@core-js/pure/full/date';
-new $date3();
+import $Date3 from '@core-js/pure/full/date';
+new $Date3();
diff --git a/tests/type-definitions/pure/common/date.test.ts b/tests/type-definitions/pure/common/date.test.ts
@@ -1,4 +1,4 @@
-import $date from '@core-js/pure/full/date/index';
+import $Date from '@core-js/pure/full/date/index';
 
-new $date();
-new $date('2020-01-01');
+new $Date();
+new $Date('2020-01-01');
diff --git a/tests/type-definitions/pure/proposals/array-is-template-object.test.ts b/tests/type-definitions/pure/proposals/array-is-template-object.test.ts
@@ -1,14 +1,14 @@
 import arrayIsTemplateObject from '@core-js/pure/full/array/is-template-object';
 import objectFreeze from '@core-js/pure/full/object/freeze';
-import sym from '@core-js/pure/full/symbol/index';
+import $Symbol from '@core-js/pure/full/symbol/index';
 
 const t: boolean = arrayIsTemplateObject([]);
 arrayIsTemplateObject({});
 arrayIsTemplateObject(['a', 'b']);
 arrayIsTemplateObject(objectFreeze(['foo', 'bar']));
 arrayIsTemplateObject(123);
 arrayIsTemplateObject('str');
-arrayIsTemplateObject(sym());
+arrayIsTemplateObject($Symbol());
 
 declare const x: unknown;
 if (arrayIsTemplateObject(x)) {
diff --git a/tests/type-definitions/pure/proposals/async-iteration.test.ts b/tests/type-definitions/pure/proposals/async-iteration.test.ts
@@ -1,8 +1,8 @@
-import $symbol from '@core-js/pure/full/symbol/index';
+import $Symbol from '@core-js/pure/full/symbol/index';
 
-const sym: symbol = $symbol.asyncIterator;
+const sym: symbol = $Symbol.asyncIterator;
 
 // @ts-expect-error
-const bad1: string = $symbol.asyncIterator;
+const bad1: string = $Symbol.asyncIterator;
 // @ts-expect-error
-$symbol['asyncIterator'] = $symbol("other");
+$Symbol['asyncIterator'] = $Symbol('other');
diff --git a/tests/type-definitions/pure/proposals/async-iterator-helper.test.ts b/tests/type-definitions/pure/proposals/async-iterator-helper.test.ts
@@ -11,12 +11,13 @@ import some from '@core-js/pure/full/async-iterator/some';
 import take from '@core-js/pure/full/async-iterator/take';
 import toArray from '@core-js/pure/full/async-iterator/to-array';
 import toAsync from '@core-js/pure/full/iterator/to-async';
-import asyncIterator from '@core-js/pure/full/async-iterator/index';
+import $AsyncIterator from '@core-js/pure/full/async-iterator';
 
 const aiton = from([1, 2, 3]);
+aiton.next();
 aiton.toArray();
 from(new Set([1, 2, 3]));
-from((function* () { yield 3; })());
+from((function * () { yield 3; })());
 const aitos = from('abc');
 
 declare const ilb: Iterable<boolean>;
diff --git a/tests/type-definitions/pure/proposals/await-dictionary.test.ts b/tests/type-definitions/pure/proposals/await-dictionary.test.ts
@@ -1,27 +1,27 @@
-import allKeyed from '@core-js/pure/full/promise/all-keyed';
-import allSettledKeyed from '@core-js/pure/full/promise/all-settled-keyed';
+import promiseAllKeyed from '@core-js/pure/full/promise/all-keyed';
+import promiseAllSettledKeyed from '@core-js/pure/full/promise/all-settled-keyed';
 
-const res: Promise<{ a: number, b: string, c: boolean }> = allKeyed({
+const res: Promise<{ a: number, b: string, c: boolean }> = promiseAllKeyed({
   a: Promise.resolve(1),
   b: Promise.resolve('string'),
   c: Promise.resolve(true),
 });
 
 const sym = Symbol('sym');
-const res2: Promise<{ [sym]: number }> = allKeyed({
+const res2: Promise<{ [sym]: number }> = promiseAllKeyed({
   [sym]: Promise.resolve(1)
 });
 
 // @ts-expect-error
-allKeyed();
+promiseAllKeyed();
 // @ts-expect-error
-allKeyed({ a: 1, b: Promise.resolve(2) });
+promiseAllKeyed({ a: 1, b: Promise.resolve(2) });
 // @ts-expect-error
-allKeyed([ Promise.resolve(1), Promise.resolve(2) ]);
+promiseAllKeyed([ Promise.resolve(1), Promise.resolve(2) ]);
 
 // @ts-expect-error
-allSettledKeyed();
+promiseAllSettledKeyed();
 // @ts-expect-error
-allSettledKeyed({ a: 1, b: Promise.resolve(2) });
+promiseAllSettledKeyed({ a: 1, b: Promise.resolve(2) });
 // @ts-expect-error
-allSettledKeyed([ Promise.resolve(1), Promise.resolve(2) ]);
+promiseAllSettledKeyed([ Promise.resolve(1), Promise.resolve(2) ]);
diff --git a/tests/type-definitions/pure/proposals/explicit-resource-management.test.ts b/tests/type-definitions/pure/proposals/explicit-resource-management.test.ts
@@ -1,25 +1,18 @@
 import symbolDispose from '@core-js/pure/full/symbol/dispose';
 import symbolAsyncDispose from '@core-js/pure/full/symbol/async-dispose';
 import symbolToStringTag from '@core-js/pure/full/symbol/to-string-tag';
-import suppressedError from '@core-js/pure/full/suppressed-error/constructor';
-import disposableStack from '@core-js/pure/full/disposable-stack/constructor';
-import asyncDisposableStack from '@core-js/pure/full/async-disposable-stack/constructor';
 import iteratorRange from '@core-js/pure/full/iterator/range';
 import asyncIteratorFrom from '@core-js/pure/full/async-iterator/from';
+import $SuppressedError from '@core-js/pure/full/suppressed-error/constructor';
+import $DisposableStack from '@core-js/pure/full/disposable-stack/constructor';
+import $AsyncDisposableStack from '@core-js/pure/full/async-disposable-stack/constructor';
 
 const d: symbol = symbolDispose;
 const ad: symbol = symbolAsyncDispose;
 
 // @ts-expect-error
 const wrong: number = symbolDispose;
 
-declare type HasSymbolDispose = {
-  [symbolDispose]: () => void;
-};
-declare type HasSymbolAsyncDispose = {
-  [symbolAsyncDispose]: () => void;
-};
-
 const objD = {
   [symbolDispose]() { /* empty */ }
 };
@@ -30,21 +23,21 @@ const objAD = {
 }
 objAD[symbolAsyncDispose]();
 
-const err1 = new suppressedError('err', 'suppressed', 'msg');
+const err1 = new $SuppressedError('err', 'suppressed', 'msg');
 err1.error;
 err1.suppressed;
 const m1: string = err1.message;
 const _: Error = err1;
 
-const err2 = suppressedError(123, 456);
+const err2 = $SuppressedError(123, 456);
 err2.error;
 err2.suppressed;
 err2.message;
 
 // @ts-expect-error
-new suppressedError(1, 2, 3, 4);
+new $SuppressedError(1, 2, 3, 4);
 
-const objDS = new disposableStack();
+const objDS = new $DisposableStack();
 const disposed: boolean = objDS.disposed;
 objDS.dispose();
 objDS.use(objD);
@@ -67,8 +60,8 @@ objDS.move(1);
 // @ts-expect-error
 objDS[symbolToStringTag] = 'foo';
 
-asyncDisposableStack.prototype;
-const objADS = new asyncDisposableStack();
+$AsyncDisposableStack.prototype;
+const objADS = new $AsyncDisposableStack();
 const disposedASD: boolean = objDS.disposed;
 const rda: Promise<void> = objADS.disposeAsync();
 objADS.use(objAD);
diff --git a/tests/type-definitions/pure/proposals/extractors.test.ts b/tests/type-definitions/pure/proposals/extractors.test.ts
@@ -1,10 +1,10 @@
-import symbolCustomMatcher from '@core-js/pure/full/symbol/custom-matcher';
-import $symbol from '@core-js/pure/full/symbol/index';
+import $customMatcher from '@core-js/pure/full/symbol/custom-matcher';
+import $Symbol from '@core-js/pure/full/symbol/index';
 
-const rscs1: symbol = symbolCustomMatcher;
-const rscs2: typeof symbolCustomMatcher = symbolCustomMatcher;
+const rscs1: symbol = $customMatcher;
+const rscs2: typeof $customMatcher = $customMatcher;
 
 // @ts-expect-error
-$symbol['customMatcher'] = $symbol("other");
+$Symbol['customMatcher'] = $Symbol("other");
 // @ts-expect-error
-const n: number = symbolCustomMatcher;
+const n: number = $customMatcher;
diff --git a/tests/type-definitions/pure/proposals/float16.test.ts b/tests/type-definitions/pure/proposals/float16.test.ts
@@ -1,6 +1,6 @@
-import f16round from '@core-js/pure/full/math/f16round';
+import mathF16round from '@core-js/pure/full/math/f16round';
 
-const res: number = f16round(1);
+const res: number = mathF16round(1);
 
 // @ts-expect-error
-f16round('123');
+mathF16round('123');
diff --git a/tests/type-definitions/pure/proposals/function-demethodize.test.ts b/tests/type-definitions/pure/proposals/function-demethodize.test.ts
@@ -1,7 +1,7 @@
-import demethodize from '@core-js/pure/full/function/demethodize';
+import $demethodize from '@core-js/pure/full/function/demethodize';
 
 function sumTo(this: { base: number }, a: number, b: number): number {
   return this.base + a + b;
 }
 
-demethodize(sumTo);
+$demethodize(sumTo);
diff --git a/tests/type-definitions/pure/proposals/is-error.test.ts b/tests/type-definitions/pure/proposals/is-error.test.ts
@@ -1,12 +1,12 @@
-import isError from '@core-js/pure/full/error/is-error';
+import $isError from '@core-js/pure/full/error/is-error';
 
 const e = new Error();
 const ne = { foo: 1 };
 
-const re1: boolean = isError(e);
-isError(ne);
-isError(undefined);
-isError('str');
+const re1: boolean = $isError(e);
+$isError(ne);
+$isError(undefined);
+$isError('str');
 
 // @ts-expect-error
-isError();
+$isError();
diff --git a/tests/type-definitions/pure/proposals/iterator-chunking.test.ts b/tests/type-definitions/pure/proposals/iterator-chunking.test.ts
@@ -1,26 +1,26 @@
-import chunks from '@core-js/pure/full/iterator/chunks';
-import windows from '@core-js/pure/full/iterator/windows';
+import iteratorChunks from '@core-js/pure/full/iterator/chunks';
+import iteratorWindows from '@core-js/pure/full/iterator/windows';
 
 declare function getNumberIterator(): Iterator<number>;
 
 const numbersIter = getNumberIterator();
 
-const chunksObj: Iterator<number[]> = chunks(numbersIter, 2);
-const windowsObj: Iterator<number[]> = windows(numbersIter, 4);
+const chunksObj: Iterator<number[]> = iteratorChunks(numbersIter, 2);
+const windowsObj: Iterator<number[]> = iteratorWindows(numbersIter, 4);
 
 const chunkNext = chunksObj.next();
 const windowsNext = windowsObj.next();
 
 // @ts-expect-error
-chunks(numbersIter);
+iteratorChunks(numbersIter);
 // @ts-expect-error
-chunks(numbersIter, '2');
+iteratorChunks(numbersIter, '2');
 // @ts-expect-error
-chunks(numbersIter, 2, 3);
+iteratorChunks(numbersIter, 2, 3);
 
 // @ts-expect-error
-windows(numbersIter);
+iteratorWindows(numbersIter);
 // @ts-expect-error
-windows(numbersIter, {});
+iteratorWindows(numbersIter, {});
 // @ts-expect-error
-windows(numbersIter, 4, 1);
+iteratorWindows(numbersIter, 4, 1);
diff --git a/tests/type-definitions/pure/proposals/iterator-joint.test.ts b/tests/type-definitions/pure/proposals/iterator-joint.test.ts
@@ -1,17 +1,17 @@
-import zip from '@core-js/pure/full/iterator/zip';
-import zipKeyed from '@core-js/pure/full/iterator/zip-keyed';
+import iteratorZip from '@core-js/pure/full/iterator/zip';
+import iteratorZipKeyed from '@core-js/pure/full/iterator/zip-keyed';
 
-zip([[1, 2, 3], [4, 5, 6]]);
-zip([['a', 'b', 'c'], ['d', 'e', 'f']]);
-zip([[1, 2, 3], [4, 5, 6]], { mode: "shortest" });
-zipKeyed({ a: [1, 2, 3], b: [4, 5, 6] });
-zipKeyed({ a: ['a', 'b', 'c', 'd'], b: ['e', 'f'] }, { mode: "shortest" });
+iteratorZip([[1, 2, 3], [4, 5, 6]]);
+iteratorZip([['a', 'b', 'c'], ['d', 'e', 'f']]);
+iteratorZip([[1, 2, 3], [4, 5, 6]], { mode: "shortest" });
+iteratorZipKeyed({ a: [1, 2, 3], b: [4, 5, 6] });
+iteratorZipKeyed({ a: ['a', 'b', 'c', 'd'], b: ['e', 'f'] }, { mode: "shortest" });
 
 // @ts-expect-error
-zip(true);
+iteratorZip(true);
 // @ts-expect-error
-zip([[1, 2, 3], [4, 5, 6]], { mode: "incorrect" });
+iteratorZip([[1, 2, 3], [4, 5, 6]], { mode: "incorrect" });
 // @ts-expect-error
-zipKeyed(42);
+iteratorZipKeyed(42);
 // @ts-expect-error
-zipKeyed({ a: [1, 2, 3], b: [4, 5, 6] }, { foo: "bar" });
+iteratorZipKeyed({ a: [1, 2, 3], b: [4, 5, 6] }, { foo: "bar" });
diff --git a/tests/type-definitions/pure/proposals/iterator-range.test.ts b/tests/type-definitions/pure/proposals/iterator-range.test.ts
@@ -1,15 +1,15 @@
-import range from '@core-js/pure/full/iterator/range';
+import iteratorRange from '@core-js/pure/full/iterator/range';
 
-const rir1: Iterator<number> = range(1, 10);
-range(1, 10, 1);
-range(1, 10, { step: 1 });
-range(1, 10, { inclusive: true });
+const rir1: Iterator<number> = iteratorRange(1, 10);
+iteratorRange(1, 10, 1);
+iteratorRange(1, 10, { step: 1 });
+iteratorRange(1, 10, { inclusive: true });
 
 // @ts-expect-error
-range(0, 10, 'not-a-number');
+iteratorRange(0, 10, 'not-a-number');
 // @ts-expect-error
-range(0, 10, { inclusive: 3 });
+iteratorRange(0, 10, { inclusive: 3 });
 // @ts-expect-error
-range(0, 10, { step: 'smth' });
+iteratorRange(0, 10, { step: 'smth' });
 // @ts-expect-error
-range(0, 10, { foo: 'bar' });
+iteratorRange(0, 10, { foo: 'bar' });
diff --git a/tests/type-definitions/pure/proposals/iterator-sequencing.test.ts b/tests/type-definitions/pure/proposals/iterator-sequencing.test.ts
@@ -1,20 +1,20 @@
-import concat from '@core-js/pure/full/iterator/concat';
+import iteratorConcat from '@core-js/pure/full/iterator/concat';
 
 declare const its1: Iterable<string>;
 declare const arrs: string[];
 declare const arrn: number[];
 declare const arrb: boolean[];
 declare const itb1: Iterable<boolean>;
 
-const ri1: Iterator<number | string> = concat(its1);
-const ri2: Iterator<number | string> = concat(arrs);
-const ri3: Iterator<number> = concat(arrn);
-const ri4: Iterator<number | boolean> = concat(arrb, itb1);
-const ri5: Iterator<number> = concat();
+const ri1: Iterator<number | string> = iteratorConcat(its1);
+const ri2: Iterator<number | string> = iteratorConcat(arrs);
+const ri3: Iterator<number> = iteratorConcat(arrn);
+const ri4: Iterator<number | boolean> = iteratorConcat(arrb, itb1);
+const ri5: Iterator<number> = iteratorConcat();
 
 // @ts-expect-error
-concat(1);
+iteratorConcat(1);
 // @ts-expect-error
-concat(true);
+iteratorConcat(true);
 // @ts-expect-error
-concat({});
+iteratorConcat({});
diff --git a/tests/type-definitions/pure/proposals/json-parse-with-source.test.ts b/tests/type-definitions/pure/proposals/json-parse-with-source.test.ts
diff --git a/tests/type-definitions/pure/proposals/pattern-matching.test.ts b/tests/type-definitions/pure/proposals/pattern-matching.test.ts
diff --git a/tests/type-definitions/pure/proposals/string-cooked.test.ts b/tests/type-definitions/pure/proposals/string-cooked.test.ts
diff --git a/tests/type-definitions/pure/proposals/string-dedent.test.ts b/tests/type-definitions/pure/proposals/string-dedent.test.ts
diff --git a/tests/type-definitions/pure/web/url-search-params.test.ts b/tests/type-definitions/pure/web/url-search-params.test.ts
diff --git a/tests/type-definitions/pure/web/url.test.ts b/tests/type-definitions/pure/web/url.test.ts
