docs: generate diffs

Author: uhyo

build/diff.ts

@@ -0,0 +1,76 @@
+// Generates diff per lib file.
+
+import { createPatch } from "diff";
+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 { projectDir } from "./logic/projectDir";
+
+const docsDir = path.join(projectDir, "docs");
+const docsDiffDir = path.join(docsDir, "diff");
+
+async function main() {
+  await rm(docsDiffDir, {
+    force: true,
+    recursive: true,
+  });
+  await mkdir(docsDiffDir, {
+    recursive: true,
+  });
+
+  const { tsLibDir, libFiles } = await getLibFiles();
+  const hasDiffFiles: string[] = [];
+  for (const libFile of libFiles) {
+    const betterLib = generate(tsLibDir, libFile, false);
+    if (betterLib === undefined) {
+      continue;
+    }
+
+    const diffFile = path.join(docsDiffDir, libFile + ".md");
+
+    const originalLib = await readFile(path.join(tsLibDir, libFile), "utf8");
+    const formattedOriginalLib = prettier.format(originalLib, {
+      parser: "typescript",
+    });
+    const formattedBetterLib = prettier.format(betterLib, {
+      parser: "typescript",
+    });
+    if (formattedOriginalLib === formattedBetterLib) {
+      continue;
+    }
+
+    const diffPatch = createPatch(
+      libFile,
+      formattedOriginalLib,
+      formattedBetterLib
+    );
+
+    const md = `# ${libFile} Diffs
+
+\`\`\`diff
+${diffPatch}
+\`\`\`
+`;
+
+    await writeFile(diffFile, md);
+    console.log(libFile);
+    hasDiffFiles.push(libFile);
+  }
+  const diffDoc = `
+# Diffs
+
+The following files are improved in better-typescript-lib:
+
+${hasDiffFiles
+  .map((libFile) => `- [${libFile}](./diff/${libFile}.md)`)
+  .join("\n")}
+`;
+  await writeFile(path.join(docsDir, "diff.md"), diffDoc);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

docs/diff.md

@@ -0,0 +1,18 @@
+
+# Diffs
+
+- [es2015.collection.d.ts](es2015.collection.d.ts.md)
+- [es2015.core.d.ts](es2015.core.d.ts.md)
+- [es2015.generator.d.ts](es2015.generator.d.ts.md)
+- [es2015.iterable.d.ts](es2015.iterable.d.ts.md)
+- [es2015.promise.d.ts](es2015.promise.d.ts.md)
+- [es2015.proxy.d.ts](es2015.proxy.d.ts.md)
+- [es2015.reflect.d.ts](es2015.reflect.d.ts.md)
+- [es2017.object.d.ts](es2017.object.d.ts.md)
+- [es2018.asyncgenerator.d.ts](es2018.asyncgenerator.d.ts.md)
+- [es2018.asynciterable.d.ts](es2018.asynciterable.d.ts.md)
+- [es2019.object.d.ts](es2019.object.d.ts.md)
+- [es2021.promise.d.ts](es2021.promise.d.ts.md)
+- [es2021.string.d.ts](es2021.string.d.ts.md)
+- [es2022.object.d.ts](es2022.object.d.ts.md)
+- [es5.d.ts](es5.d.ts.md)

docs/diff/es2015.collection.d.ts.md

@@ -0,0 +1,99 @@
+# es2015.collection.d.ts Diffs
+
+```diff
+Index: es2015.collection.d.ts
+===================================================================
+--- es2015.collection.d.ts
++++ es2015.collection.d.ts
+@@ -1,28 +1,28 @@
+ interface Map<K, V> {
+   clear(): void;
+   delete(key: K): boolean;
+-  forEach(
+-    callbackfn: (value: V, key: K, map: Map<K, V>) => void,
+-    thisArg?: any
++  forEach<This>(
++    callbackfn: (this: This, value: V, key: K, map: Map<K, V>) => void,
++    thisArg?: This
+   ): void;
+   get(key: K): V | undefined;
+   has(key: K): boolean;
+   set(key: K, value: V): this;
+   readonly size: number;
+ }
+ 
++declare var Map: MapConstructor;
++
+ interface MapConstructor {
+-  new (): Map<any, any>;
+   new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+-  readonly prototype: Map<any, any>;
++  readonly prototype: Map<unknown, unknown>;
+ }
+-declare var Map: MapConstructor;
+ 
+ interface ReadonlyMap<K, V> {
+-  forEach(
+-    callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void,
+-    thisArg?: any
++  forEach<This>(
++    callbackfn: (this: This, value: V, key: K, map: ReadonlyMap<K, V>) => void,
++    thisArg?: This
+   ): void;
+   get(key: K): V | undefined;
+   has(key: K): boolean;
+   readonly size: number;
+@@ -33,39 +33,39 @@
+   get(key: K): V | undefined;
+   has(key: K): boolean;
+   set(key: K, value: V): this;
+ }
++declare var WeakMap: WeakMapConstructor;
+ 
+ interface WeakMapConstructor {
+-  new <K extends object = object, V = any>(
++  new <K extends object = object, V = unknown>(
+     entries?: readonly [K, V][] | null
+   ): WeakMap<K, V>;
+-  readonly prototype: WeakMap<object, any>;
++  readonly prototype: WeakMap<object, unknown>;
+ }
+-declare var WeakMap: WeakMapConstructor;
+ 
+ interface Set<T> {
+   add(value: T): this;
+   clear(): void;
+   delete(value: T): boolean;
+-  forEach(
+-    callbackfn: (value: T, value2: T, set: Set<T>) => void,
+-    thisArg?: any
++  forEach<This>(
++    callbackfn: (this: This, value: T, value2: T, set: Set<T>) => void,
++    thisArg?: This
+   ): void;
+   has(value: T): boolean;
+   readonly size: number;
+ }
++declare var Set: SetConstructor;
+ 
+ interface SetConstructor {
+-  new <T = any>(values?: readonly T[] | null): Set<T>;
+-  readonly prototype: Set<any>;
++  new <T>(values?: readonly T[] | null): Set<T>;
++  readonly prototype: Set<unknown>;
+ }
+-declare var Set: SetConstructor;
+ 
+ interface ReadonlySet<T> {
+-  forEach(
+-    callbackfn: (value: T, value2: T, set: ReadonlySet<T>) => void,
+-    thisArg?: any
++  forEach<This>(
++    callbackfn: (this: This, value: T, value2: T, set: ReadonlySet<T>) => void,
++    thisArg?: This
+   ): void;
+   has(value: T): boolean;
+   readonly size: number;
+ }
+
+```