Types refactoring

Author: slowcheetah

packages/core-js-types/package.json

@@ -25,16 +25,40 @@
     "email": "zloirock@zloirock.ru",
     "url": "http://zloirock.ru"
   },
-  "types": "dist/core-js-types.56.d.ts",
-  "files": [
-    "dist/core-js-types.56.d.ts"
-  ],
+  "types": "./actual.d.ts",
   "typesVersions": {
     ">=5.6": {
-      "*": ["dist/core-js-types.56.d.ts"]
+      "*": ["dist/56/*"]
     },
     ">=5.2": {
-      "*": ["dist/core-js-types.52.d.ts"]
+      "*": ["dist/52/*"]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./actual.d.ts",
+      "default": "./actual.d.ts"
+    },
+    "./actual": {
+      "types": "./actual.d.ts",
+      "default": "./actual.d.ts"
+    },
+    "./es": {
+      "types": "./es.d.ts",
+      "default": "./es.d.ts"
+    },
+    "./full": {
+      "types": "./full.d.ts",
+      "default": "./full.d.ts"
+    },
+    "./pure": {
+      "types": "./pure.d.ts",
+      "default": "./pure.d.ts"
+
+    },
+    "./stable": {
+      "types": "./stable.d.ts",
+      "default": "./stable.d.ts"
     }
   },
   "sideEffects": false

packages/core-js-types/src/56/proposals/async-iteration.d.ts

@@ -12,3 +12,9 @@ interface SymbolConstructor {
    */
   readonly asyncIterator: unique symbol;
 }
+
+interface AsyncIteratorConstructor {
+
+}
+
+declare var AsyncIterator: AsyncIteratorConstructor;

packages/core-js-types/src/56/proposals/error-cause.d.ts

@@ -55,6 +55,18 @@ declare global {
 
     (message?: string, options?: ErrorOptions): URIError;
   }
+
+  interface AggregateError extends Error {
+    errors: any[];
+  }
+
+  interface AggregateErrorConstructor {
+    new (errors: Iterable<any>, message?: string): AggregateError;
+    (errors: Iterable<any>, message?: string): AggregateError;
+    readonly prototype: AggregateError;
+  }
+
+  var AggregateError: AggregateErrorConstructor;
 }
 
 export {};

scripts/build-types/config.mjs

@@ -2,6 +2,6 @@ export default {
   buildDir: 'packages/core-js-types/dist/',
   bundleName: 'core-js-types',
   latestTsVersion: 59,
-  packageName: '@core-js/pure/',
+  packageName: '@core-js/',
   srcDir: 'packages/core-js-types/src/',
 };

scripts/build-types/index.mjs

@@ -10,12 +10,20 @@ const { copy, outputFile, pathExists, readdir, remove } = fs;
 
 const versionArg = argv._.find(item => item.startsWith('version='));
 const VERSION = versionArg ? versionArg.slice('version='.length) : undefined;
-
-async function buildType(typeFilePath, entry, options) {
+const imports = {
+  es: new Set(),
+  stable: new Set(),
+  actual: new Set(),
+  full: new Set(),
+  pure: new Set(),
+};
+
+async function buildType(entry, options) {
   let {
     entryFromNamespace,
     subset = entryFromNamespace ?? 'full',
     template, templateStable, templateActual, templateFull, filter, modules, enforceEntryCreation,
+    customType, tsVersion,
   } = options;
 
   switch (subset) {
@@ -50,9 +58,23 @@ async function buildType(typeFilePath, entry, options) {
 
   if (filter) modules = modules.filter(it => filter.has(it));
 
+  const tplPure = template({ ...options, modules, rawModules, level, entry, types, packageName: `${ config.packageName }pure/` });
   const tpl = template({ ...options, modules, rawModules, level, entry, types, packageName: config.packageName });
 
-  await outputFile(typeFilePath, `${ tpl.dts }${ tpl.dts ? '\n\n' : '' }`, { flag: 'a' });
+  types.forEach(type => {
+    imports[subset].add(type);
+    imports.pure.add(type);
+  });
+  if (customType) {
+    imports[subset].add(customType);
+    imports.pure.add(customType);
+  }
+
+  const filePath = buildFilePath(tsVersion, subset);
+  const filePathPure = buildFilePath(tsVersion, 'pure');
+
+  await outputFile(filePath, `${ tpl.dts }${ tpl.dts ? '\n\n' : '' }`, { flag: 'a' });
+  await outputFile(filePathPure, `${ tplPure.dts }${ tplPure.dts ? '\n\n' : '' }`, { flag: 'a' });
 }
 
 async function getVersions() {
@@ -70,19 +92,7 @@ async function buildTypesDirForTSVersion(version) {
   const versions = await getVersions();
   for (const v of versions) {
     if (v > version) break;
-    await copy(path.join(config.srcDir, v.toString()), path.join(config.buildDir, version.toString()));
-  }
-}
-
-async function addImports(filePath, fromPath) {
-  const entries = await readdir(fromPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      await addImports(filePath, path.join(fromPath, entry.name));
-    } else {
-      const typePath = path.join(fromPath, entry.name).replace(config.buildDir, '');
-      await outputFile(filePath, `/// <reference path="./${ typePath }" />\n`, { flag: 'a' });
-    }
+    await copy(path.join(config.srcDir, v.toString()), path.join(config.buildDir, version.toString(), 'types'));
   }
 }
 
@@ -96,38 +106,43 @@ const ESWithProposalsSet = new Set(ESWithProposalsModules);
 const StableSet = new Set(StableModules);
 const ActualSet = new Set(ActualModules);
 
+function buildFilePath(tsVersion, subset) {
+  return path.join(config.buildDir, tsVersion.toString(), `${ subset }.d.ts`);
+}
+
+async function prependImports(version) {
+  for (const subset of Object.keys(imports)) {
+    const filePath = buildFilePath(version, subset);
+    const importLines = Array.from(imports[subset], it => `/// <reference types="./types/${ it }.d.ts" />`).join('\n');
+    const originalContent = await fs.readFile(filePath, 'utf8');
+    await outputFile(filePath, `${ importLines }\n\n${ originalContent }`);
+  }
+}
+
 async function buildTypesForTSVersion(tsVersion) {
   tsVersion = tsVersion.toString().replace('.', '');
-  const bundleName = `${ config.bundleName }.${ tsVersion === config.latestTsVersion ? 'latest' : tsVersion }.d.ts`;
-  const bundlePath = path.join(config.buildDir, bundleName);
-  const typesPath = path.join(config.buildDir, tsVersion.toString());
+  const bundlePath = path.join(config.buildDir, tsVersion);
   if (await pathExists(bundlePath)) await remove(bundlePath);
-  if (await pathExists(typesPath)) await remove(typesPath);
   await buildTypesDirForTSVersion(tsVersion);
-  await addImports(bundlePath, typesPath);
 
   for (const [entry, definition] of Object.entries(features)) {
-    await buildType(bundlePath, `es/${ entry }`, { ...definition, entryFromNamespace: 'es' });
-    await buildType(bundlePath, `stable/${ entry }`, { ...definition, entryFromNamespace: 'stable' });
-    await buildType(bundlePath, `actual/${ entry }`, { ...definition, entryFromNamespace: 'actual' });
-    await buildType(bundlePath, `full/${ entry }`, { ...definition, entryFromNamespace: 'full' });
+    await buildType(`es/${ entry }`, { ...definition, entryFromNamespace: 'es', tsVersion });
+    await buildType(`stable/${ entry }`, { ...definition, entryFromNamespace: 'stable', tsVersion });
+    await buildType(`actual/${ entry }`, { ...definition, entryFromNamespace: 'actual', tsVersion });
+    await buildType(`full/${ entry }`, { ...definition, entryFromNamespace: 'full', tsVersion });
   }
 
   for (const [name, definition] of Object.entries(proposals)) {
-    await buildType(bundlePath, `proposals/${ name }`, { ...definition, template: $proposal });
+    await buildType(`proposals/${ name }`, { ...definition, template: $proposal, tsVersion });
   }
 
-  await buildType(bundlePath, 'stage/3', { template: $path, modules: ActualModules, subset: 'es-stage' });
-  await buildType(bundlePath, 'stage/2.7', { template: $path, modules: modulesToStage(StableModules, 2.7), subset: 'es-stage' });
-  await buildType(bundlePath, 'stage/2', { template: $path, modules: modulesToStage(StableModules, 2), subset: 'es-stage' });
-  await buildType(bundlePath, 'stage/1', { template: $path, modules: modulesToStage(StableModules, 1), subset: 'es-stage' });
-  await buildType(bundlePath, 'stage/0', { template: $path, modules: AllModules, subset: 'es-stage' });
-
-  await buildType(bundlePath, 'es/index', { template: $path, modules: ESModules, subset: 'es' });
-  await buildType(bundlePath, 'stable/index', { template: $path, modules: StableModules, subset: 'stable' });
-  await buildType(bundlePath, 'actual/index', { template: $path, modules: ActualModules });
-  await buildType(bundlePath, 'full/index', { template: $path, modules: AllModules });
-  await buildType(bundlePath, 'index', { template: $path, modules: ActualModules });
+  await buildType('es/index', { template: $path, modules: ESModules, subset: 'es', tsVersion });
+  await buildType('stable/index', { template: $path, modules: StableModules, subset: 'stable', tsVersion });
+  await buildType('actual/index', { template: $path, modules: ActualModules, tsVersion });
+  await buildType('full/index', { template: $path, modules: AllModules, tsVersion });
+  await buildType('index', { template: $path, modules: ActualModules, tsVersion });
+
+  await prependImports(tsVersion);
 }
 
 if (VERSION) {

tests/type-definitions/global/proposals/accessible-object-hasownproperty.test.ts

@@ -1,5 +1,4 @@
 import 'core-js/full';
-import '@core-js/types';
 
 Object.hasOwn({a: 1}, 'a');
 Object.hasOwn([], 0);

tests/type-definitions/global/proposals/array-buffer-base64.test.ts

@@ -1,5 +1,4 @@
 import 'core-js/full';
-import '@core-js/types';
 
 function acceptUint8Array(v: Uint8Array) {}
 function acceptProcessMetadata(v: { read: number; written: number }) {}

tests/type-definitions/global/proposals/array-buffer-transfer.test.ts

@@ -1,5 +1,4 @@
 import 'core-js/full';
-import '@core-js/types';
 
 const ab = new ArrayBuffer(16);
 // todo uncomment when fixed

tests/type-definitions/global/proposals/array-filtering.test.ts

@@ -1,5 +1,4 @@
 import 'core-js/full';
-import '@core-js/types';
 
 [1, 2, 3].filterReject((v, i, arr) => v > 1);
 ['a', 'b'].filterReject((v, i, arr) => v === 'a');

tests/type-definitions/global/proposals/array-find-from-last.test.ts

@@ -1,5 +1,4 @@
 import 'core-js/full';
-import '@core-js/types';
 
 const res: number | undefined = [1, 2, 3].findLast(v => v > 1);
 [1, 2, 3].findLast((v): v is 2 => v === 2);