🚑 Get the lib files from libs.json

Author: aaditmshah

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 renamed to 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/alias.ts renamed to build/util/alias.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;
+  };

build/util/isNotNullish.ts

@@ -10,13 +10,14 @@
     "@types/node": "^16.9.6",
     "@types/prettier": "^2.6.0",
     "diff": "^5.0.0",
+    "json5": "^2.2.3",
     "prettier": "^2.6.2",
     "tsd": "^0.25.0",
     "typescript": "^4.9.4"
   },
   "scripts": {
     "build:tsc": "tsc",
-    "build:lib": "node dist/build/build.js",
+    "build:lib": "node dist/build/lib.js",
     "build:package": "node dist/build/package.js",
     "build:diff": "node dist/build/diff.js",
     "test": "echo 'Please run tests in the tests/ directory' && exit 1"
@@ -31,4 +32,4 @@
       "types": []
     }
   }
-}
+}

build/util/parsers.ts

@@ -45,6 +45,7 @@
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
     // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
     // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    "resolveJsonModule": true,
     // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
     // "typeRoots": [],                       /* List of folders to include type definitions from. */
     // "types": [],                           /* Type declaration files to be included in compilation. */