💥 Add strong type definition for fetch().json()

build/diff.ts

@@ -5,7 +5,7 @@ import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import path from "path";
 import prettier from "prettier";
 import { generate } from "./logic/generate";
-import { getLibFiles } from "./logic/getLibFiles";
+import { getLibFiles, tsLibDir } from "./logic/getLibFiles";
 import { projectDir } from "./logic/projectDir";
 
 const docsDir = path.join(projectDir, "docs");
@@ -20,17 +20,17 @@ async function main() {
     recursive: true,
   });
 
-  const { tsLibDir, libFiles } = await getLibFiles();
+  const libFiles = await getLibFiles();
   const hasDiffFiles: string[] = [];
-  for (const libFile of libFiles) {
-    const betterLib = generate(tsLibDir, libFile, false);
+  for (const [targetFile, sourceFile] of libFiles.entries()) {
+    const betterLib = generate(tsLibDir, targetFile, sourceFile, false);
     if (betterLib === undefined) {
       continue;
     }
 
-    const diffFile = path.join(docsDiffDir, libFile + ".md");
+    const diffFile = path.join(docsDiffDir, sourceFile + ".md");
 
-    const originalLib = await readFile(path.join(tsLibDir, libFile), "utf8");
+    const originalLib = await readFile(path.join(tsLibDir, sourceFile), "utf8");
     const formattedOriginalLib = prettier.format(originalLib, {
       parser: "typescript",
     });
@@ -42,21 +42,21 @@ async function main() {
     }
 
     const diffPatch = createPatch(
-      libFile,
+      sourceFile,
       formattedOriginalLib,
       formattedBetterLib
     );
 
-    const md = `# ${libFile} Diffs
+    const md = `# ${sourceFile} Diffs
 
 \`\`\`diff
 ${diffPatch}
 \`\`\`
 `;
 
     await writeFile(diffFile, md);
-    console.log(libFile);
-    hasDiffFiles.push(libFile);
+    console.log(sourceFile);
+    hasDiffFiles.push(sourceFile);
   }
   const diffDoc = `
 # Diffs

build/build.ts → build/lib.ts

@@ -2,7 +2,7 @@ import { mkdir, rm, writeFile } from "fs/promises";
 import path from "path";
 import prettier from "prettier";
 import { generate } from "./logic/generate";
-import { getLibFiles } from "./logic/getLibFiles";
+import { getLibFiles, tsLibDir } from "./logic/getLibFiles";
 import { projectDir } from "./logic/projectDir";
 
 const distDir = path.join(projectDir, "generated");
@@ -17,20 +17,20 @@ async function main() {
   });
 
   // copy TypeScript lib files
-  const { tsLibDir, libFiles } = await getLibFiles();
+  const libFiles = await getLibFiles();
 
   // modify each lib file
-  for (const libFile of libFiles) {
-    let result = generate(tsLibDir, libFile, true);
+  for (const [targetFile, sourceFile] of libFiles.entries()) {
+    let result = generate(tsLibDir, targetFile, sourceFile, true);
     if (result === undefined) {
       continue;
     }
     result = prettier.format(result, {
       parser: "typescript",
     });
 
-    await writeFile(path.join(distDir, "lib." + libFile), result);
-    console.log(libFile);
+    await writeFile(path.join(distDir, targetFile), result);
+    console.log(sourceFile);
   }
 }
 

build/logic/generate.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import ts from "typescript";
-import { alias } from "../alias";
+import { alias } from "../util/alias";
 import { upsert } from "../util/upsert";
 import { projectDir } from "./projectDir";
 
@@ -11,10 +11,11 @@ const betterLibDir = path.join(projectDir, "lib");
  */
 export function generate(
   tsLibDir: string,
-  libFile: string,
+  targetFile: string,
+  sourceFile: string,
   emitOriginalAsComment: boolean
 ): string | undefined {
-  const tsLibFile = path.join(tsLibDir, libFile);
+  const tsLibFile = path.join(tsLibDir, sourceFile);
   const originalProgram = ts.createProgram([tsLibFile], {});
   const originalFile = originalProgram.getSourceFile(tsLibFile);
   if (!originalFile) {
@@ -27,7 +28,7 @@ export function generate(
   let result = `/// <reference no-default-lib="true"/>
 `;
 
-  const replacementTargets = scanBetterFile(printer, libFile);
+  const replacementTargets = scanBetterFile(printer, targetFile);
 
   if (replacementTargets.size === 0) {
     return result + originalFile.text;
@@ -189,11 +190,11 @@ type ReplacementTarget = (
  */
 function scanBetterFile(
   printer: ts.Printer,
-  libFile: string
+  targetFile: string
 ): Map<string, ReplacementTarget[]> {
   const replacementTargets = new Map<string, ReplacementTarget[]>();
   {
-    const betterLibFile = path.join(betterLibDir, `lib.${libFile}`);
+    const betterLibFile = path.join(betterLibDir, targetFile);
     const betterProgram = ts.createProgram([betterLibFile], {});
     const betterFile = betterProgram.getSourceFile(betterLibFile);
     if (betterFile) {

build/logic/getLibFiles.ts

@@ -1,21 +1,23 @@
-import { readdir } from "fs/promises";
+import { readFile } from "fs/promises";
+import JSON5 from "json5";
 import path from "path";
+import { array, record, string, unknown } from "../util/parsers";
 import { projectDir } from "./projectDir";
 
-const tsDir = path.join(projectDir, "TypeScript");
-const tsLibDir = path.join(tsDir, "src", "lib");
+export const tsLibDir = path.join(projectDir, "TypeScript", "src", "lib");
 
-export async function getLibFiles(): Promise<{
-  tsLibDir: string;
-  libFiles: string[];
-}> {
-  // copy TypeScript lib files
-  const libs = await readdir(tsLibDir);
-  const libFiles: string[] = libs.filter((libFile) =>
-    /(?:^|\/|\\).+\.d\.ts$/.test(libFile)
+const libsFile = path.join(tsLibDir, "libs.json");
+
+export const getLibFiles = async () => {
+  const json5 = await readFile(libsFile, "utf8");
+  const result = record(unknown)(JSON5.parse(json5));
+  const libs = array(string)(result.libs);
+  const paths = record(string)(result.paths);
+  return new Map(
+    libs.map((lib) => {
+      const sourceFile = `${lib}.d.ts`;
+      const targetFile = paths[lib] || `lib.${sourceFile}`;
+      return [targetFile, sourceFile];
+    })
   );
-  return {
-    tsLibDir,
-    libFiles,
-  };
-}
+};

build/package.ts

@@ -1,9 +1,10 @@
 import { mkdir, readdir, readFile, rm, symlink, writeFile } from "fs/promises";
 import path from "path";
+import { name as rootPackageName, version } from "../package.json";
+import { projectDir } from "./logic/projectDir";
 
 const scope = "better-typescript-lib";
 
-const projectDir = process.env.PROJECT || process.cwd();
 const libDir = path.join(projectDir, "generated");
 const templateDir = path.join(projectDir, "package-template");
 const packageDir = path.join(projectDir, "dist-package");
@@ -18,13 +19,6 @@ async function main() {
     recursive: true,
   });
 
-  // Read version from root package.json
-  const rootPackageJson = JSON.parse(
-    await readFile(path.join(projectDir, "package.json"), "utf-8")
-  );
-  const rootPackageName: string = rootPackageJson.name;
-  const version: string = rootPackageJson.version;
-
   const packageTemplateFiles = await readdir(templateDir);
 
   const libFiles = (await readdir(libDir)).filter((libFile) =>
@@ -33,6 +27,7 @@ async function main() {
 
   const packageNames = new Set<string>();
   for (const libFile of libFiles) {
+    if (libFile === "lib.d.ts") continue;
     console.log(`Processing ${libFile}`);
     const libFilePath = path.join(libDir, libFile);
     const { packageName, packagePath } =

build/util/parsers.ts

@@ -0,0 +1,29 @@
+export type Parser<A> = (input: unknown) => A;
+
+export const unknown: Parser<unknown> = (input) => input;
+
+export const string: Parser<string> = (input) => {
+  if (typeof input === "string") return input;
+  throw new TypeError(`Expected a string but received ${input}`);
+};
+
+export const array =
+  <A>(parser: Parser<A>): Parser<A[]> =>
+  (input) => {
+    if (!Array.isArray(input))
+      throw new TypeError(`Expected an array but received ${input}`);
+    const result = new Array<A>(input.length);
+    for (let i = 0; i < input.length; i++) result[i] = parser(input[i]);
+    return result;
+  };
+
+export const record =
+  <A>(parser: Parser<A>): Parser<Record<string, A>> =>
+  (input) => {
+    if (typeof input !== "object" || input === null)
+      throw new TypeError(`Expected a non-null object but received ${input}`);
+    const result: Record<string, A> = {};
+    for (const [key, value] of Object.entries(input))
+      result[key] = parser(value);
+    return result;
+  };

docs/diff.md

@@ -3,13 +3,24 @@
 
 The following files are improved in better-typescript-lib:
 
+- [es5.d.ts](./diff/es5.d.ts.md)
+- [es2015.d.ts](./diff/es2015.d.ts.md)
+- [es2016.d.ts](./diff/es2016.d.ts.md)
+- [es2017.d.ts](./diff/es2017.d.ts.md)
+- [es2018.d.ts](./diff/es2018.d.ts.md)
+- [es2019.d.ts](./diff/es2019.d.ts.md)
+- [es2020.d.ts](./diff/es2020.d.ts.md)
+- [es2021.d.ts](./diff/es2021.d.ts.md)
+- [es2022.d.ts](./diff/es2022.d.ts.md)
+- [esnext.d.ts](./diff/esnext.d.ts.md)
 - [dom.generated.d.ts](./diff/dom.generated.d.ts.md)
-- [dom.iterable.d.ts](./diff/dom.iterable.d.ts.md)
 - [dom.iterable.generated.d.ts](./diff/dom.iterable.generated.d.ts.md)
-- [es2015.collection.d.ts](./diff/es2015.collection.d.ts.md)
+- [webworker.generated.d.ts](./diff/webworker.generated.d.ts.md)
+- [webworker.importscripts.d.ts](./diff/webworker.importscripts.d.ts.md)
+- [webworker.iterable.generated.d.ts](./diff/webworker.iterable.generated.d.ts.md)
+- [scripthost.d.ts](./diff/scripthost.d.ts.md)
 - [es2015.core.d.ts](./diff/es2015.core.d.ts.md)
-- [es2015.d.ts](./diff/es2015.d.ts.md)
-- [es2015.full.d.ts](./diff/es2015.full.d.ts.md)
+- [es2015.collection.d.ts](./diff/es2015.collection.d.ts.md)
 - [es2015.generator.d.ts](./diff/es2015.generator.d.ts.md)
 - [es2015.iterable.d.ts](./diff/es2015.iterable.d.ts.md)
 - [es2015.promise.d.ts](./diff/es2015.promise.d.ts.md)
@@ -18,60 +29,47 @@ The following files are improved in better-typescript-lib:
 - [es2015.symbol.d.ts](./diff/es2015.symbol.d.ts.md)
 - [es2015.symbol.wellknown.d.ts](./diff/es2015.symbol.wellknown.d.ts.md)
 - [es2016.array.include.d.ts](./diff/es2016.array.include.d.ts.md)
-- [es2016.d.ts](./diff/es2016.d.ts.md)
-- [es2016.full.d.ts](./diff/es2016.full.d.ts.md)
-- [es2017.d.ts](./diff/es2017.d.ts.md)
-- [es2017.full.d.ts](./diff/es2017.full.d.ts.md)
-- [es2017.intl.d.ts](./diff/es2017.intl.d.ts.md)
 - [es2017.object.d.ts](./diff/es2017.object.d.ts.md)
 - [es2017.sharedmemory.d.ts](./diff/es2017.sharedmemory.d.ts.md)
 - [es2017.string.d.ts](./diff/es2017.string.d.ts.md)
+- [es2017.intl.d.ts](./diff/es2017.intl.d.ts.md)
 - [es2017.typedarrays.d.ts](./diff/es2017.typedarrays.d.ts.md)
 - [es2018.asyncgenerator.d.ts](./diff/es2018.asyncgenerator.d.ts.md)
 - [es2018.asynciterable.d.ts](./diff/es2018.asynciterable.d.ts.md)
-- [es2018.d.ts](./diff/es2018.d.ts.md)
-- [es2018.full.d.ts](./diff/es2018.full.d.ts.md)
-- [es2018.intl.d.ts](./diff/es2018.intl.d.ts.md)
-- [es2018.promise.d.ts](./diff/es2018.promise.d.ts.md)
 - [es2018.regexp.d.ts](./diff/es2018.regexp.d.ts.md)
+- [es2018.promise.d.ts](./diff/es2018.promise.d.ts.md)
+- [es2018.intl.d.ts](./diff/es2018.intl.d.ts.md)
 - [es2019.array.d.ts](./diff/es2019.array.d.ts.md)
-- [es2019.d.ts](./diff/es2019.d.ts.md)
-- [es2019.full.d.ts](./diff/es2019.full.d.ts.md)
-- [es2019.intl.d.ts](./diff/es2019.intl.d.ts.md)
 - [es2019.object.d.ts](./diff/es2019.object.d.ts.md)
 - [es2019.string.d.ts](./diff/es2019.string.d.ts.md)
 - [es2019.symbol.d.ts](./diff/es2019.symbol.d.ts.md)
+- [es2019.intl.d.ts](./diff/es2019.intl.d.ts.md)
 - [es2020.bigint.d.ts](./diff/es2020.bigint.d.ts.md)
-- [es2020.d.ts](./diff/es2020.d.ts.md)
 - [es2020.date.d.ts](./diff/es2020.date.d.ts.md)
-- [es2020.full.d.ts](./diff/es2020.full.d.ts.md)
-- [es2020.intl.d.ts](./diff/es2020.intl.d.ts.md)
-- [es2020.number.d.ts](./diff/es2020.number.d.ts.md)
 - [es2020.promise.d.ts](./diff/es2020.promise.d.ts.md)
 - [es2020.sharedmemory.d.ts](./diff/es2020.sharedmemory.d.ts.md)
 - [es2020.string.d.ts](./diff/es2020.string.d.ts.md)
 - [es2020.symbol.wellknown.d.ts](./diff/es2020.symbol.wellknown.d.ts.md)
-- [es2021.d.ts](./diff/es2021.d.ts.md)
-- [es2021.full.d.ts](./diff/es2021.full.d.ts.md)
-- [es2021.intl.d.ts](./diff/es2021.intl.d.ts.md)
-- [es2021.promise.d.ts](./diff/es2021.promise.d.ts.md)
+- [es2020.intl.d.ts](./diff/es2020.intl.d.ts.md)
+- [es2020.number.d.ts](./diff/es2020.number.d.ts.md)
 - [es2021.string.d.ts](./diff/es2021.string.d.ts.md)
+- [es2021.promise.d.ts](./diff/es2021.promise.d.ts.md)
 - [es2021.weakref.d.ts](./diff/es2021.weakref.d.ts.md)
+- [es2021.intl.d.ts](./diff/es2021.intl.d.ts.md)
 - [es2022.array.d.ts](./diff/es2022.array.d.ts.md)
-- [es2022.d.ts](./diff/es2022.d.ts.md)
 - [es2022.error.d.ts](./diff/es2022.error.d.ts.md)
-- [es2022.full.d.ts](./diff/es2022.full.d.ts.md)
 - [es2022.intl.d.ts](./diff/es2022.intl.d.ts.md)
 - [es2022.object.d.ts](./diff/es2022.object.d.ts.md)
 - [es2022.sharedmemory.d.ts](./diff/es2022.sharedmemory.d.ts.md)
 - [es2022.string.d.ts](./diff/es2022.string.d.ts.md)
-- [es5.d.ts](./diff/es5.d.ts.md)
+- [esnext.intl.d.ts](./diff/esnext.intl.d.ts.md)
 - [es5.full.d.ts](./diff/es5.full.d.ts.md)
-- [esnext.d.ts](./diff/esnext.d.ts.md)
+- [es2015.full.d.ts](./diff/es2015.full.d.ts.md)
+- [es2016.full.d.ts](./diff/es2016.full.d.ts.md)
+- [es2017.full.d.ts](./diff/es2017.full.d.ts.md)
+- [es2018.full.d.ts](./diff/es2018.full.d.ts.md)
+- [es2019.full.d.ts](./diff/es2019.full.d.ts.md)
+- [es2020.full.d.ts](./diff/es2020.full.d.ts.md)
+- [es2021.full.d.ts](./diff/es2021.full.d.ts.md)
+- [es2022.full.d.ts](./diff/es2022.full.d.ts.md)
 - [esnext.full.d.ts](./diff/esnext.full.d.ts.md)
-- [esnext.intl.d.ts](./diff/esnext.intl.d.ts.md)
-- [header.d.ts](./diff/header.d.ts.md)
-- [scripthost.d.ts](./diff/scripthost.d.ts.md)
-- [webworker.generated.d.ts](./diff/webworker.generated.d.ts.md)
-- [webworker.importscripts.d.ts](./diff/webworker.importscripts.d.ts.md)
-- [webworker.iterable.generated.d.ts](./diff/webworker.iterable.generated.d.ts.md)

docs/diff/dom.generated.d.ts.md

@@ -11,5 +11,16 @@ Index: dom.generated.d.ts
  /// Window APIs
  /////////////////////////////
 
+@@ -2800,9 +2801,9 @@
+   readonly bodyUsed: boolean;
+   arrayBuffer(): Promise<ArrayBuffer>;
+   blob(): Promise<Blob>;
+   formData(): Promise<FormData>;
+-  json(): Promise<any>;
++  json(): Promise<JSONValue>;
+   text(): Promise<string>;
+ }
+
+ interface BroadcastChannelEventMap {
 
 ```