Merge branch 'v2'

Author: uhyo

.github/workflows/publish.yml

@@ -22,10 +22,12 @@ jobs:
           node-version: 14
       - run: npm ci
       - run: npm run build:tsc
-      - run: npm run build:lib
-      - run: npm test
       - run: npm run build:package
-      - uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
-          package: "./dist-package/package.json"
+      - run: npm ci
+        working-directory: ./tests
+      - run: npm test
+        working-directory: ./tests
+      - run: node scripts/npm-publish.mjs
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NO_DRY_RUN: "1"

.github/workflows/test.yml

@@ -26,4 +26,7 @@ jobs:
       - run: npm ci
       - run: npm run build:tsc
       - run: npm run build:lib
+      - run: npm ci
+        working-directory: ./tests
       - run: npm test
+        working-directory: ./tests

.gitignore

@@ -1,3 +1,4 @@
 /node_modules
 /dist
-/dist-package
+/dist-package
+/tests/node_modules

README.md

@@ -16,37 +16,27 @@ This package provides an alternative set of type definitions which replaces, and
 
 This package also includes other improved, stricter type definitions.
 
-## Usage
+## Installation
 
-### Install
+You only need to install `better-typescript-lib`. Additional configuration is not needed; your TypeScript project automatically use `better-typescript-lib` definitions.
 
-```sh
-npm i -D better-typescript-lib
-```
+Currently v2 is beta-released.
 
-### Disable built-in library from tsconfig.json
-
-```diff
-- "lib": ["es5", "dom"]
-+ "noLib": true
+```sh
+npm i -D better-typescript-lib@2.0.0-beta
 ```
 
-### Include better-typescript-lib
+### How it works
 
-Include better-typescript-lib with triple-slash directives from the entry point of your code. Note that these directives must be placed at the very top of a `.ts` file.
-
-```ts
-/// <reference path="./node_modules/better-typescript-lib/lib.es5.d.ts" />
-/// <reference path="./node_modules/better-typescript-lib/lib.dom.d.ts" />
-```
+Starting from TypeScript 4.5, the TypeScript compiler detects existence of `@typescript/xxx` packages (e.g. `@typescript/es2015`) and uses them instead of the built-in definitions. By installing `better-typescript-lib`, these package names are mapped to corresponding `@better-typescript-lib/xxx` packages.
 
 ## Supported TypeScript Versions
 
 | better-typescript-lib | TypeScript      |
 | --------------------- | --------------- |
-| 1.2.0                 | TS 4.4 or later |
-| 1.1.0                 | TS 4.2 or later |
-| 1.0.0                 | TS 4.1 or later |
+| 2.0.0                 | TS 4.5 or later |
+
+For TS 4.4 and lower, see `v1` branch.
 
 ## Concepts
 

TypeScript

@@ -1,9 +1,10 @@
-import { mkdir, readdir, rm, symlink, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import path from "path";
 import ts from "typescript";
 import { replacement } from "./replacement";
 
 const projectDir = process.env.PROJECT || process.cwd();
+const betterLibDir = path.join(projectDir, "lib");
 const distDir = path.join(projectDir, "generated");
 const tsDir = path.join(projectDir, "TypeScript");
 
@@ -15,7 +16,6 @@ async function main() {
   await mkdir(distDir, {
     recursive: true,
   });
-  await symlink(path.join(projectDir, "lib"), path.join(distDir, "better"));
 
   // copy TypeScript lib files
   const tsLibDir = path.join(tsDir, "src", "lib");
@@ -32,10 +32,17 @@ async function main() {
     if (!file) {
       continue;
     }
+    let result = "";
     const repl = replacement.get(libFile);
-    let result = repl
-      ? `/// <reference path="./better/lib.${libFile}" />\n`
-      : "";
+    if (repl) {
+      // copy better lib into the top of the file
+      result += await readFile(
+        path.join(betterLibDir, `lib.${libFile}`),
+        "utf8"
+      );
+      result += "// --------------------\n";
+    }
+
     if (!repl) {
       for (const statement of file.statements) {
         result += statement.getFullText(file);
@@ -53,11 +60,6 @@ async function main() {
       }
     }
     result += file.text.slice(file.endOfFileToken.pos);
-    // Replace <reference lib="" /> to <reference path="" />
-    result = result.replace(
-      /^\/\/\/\s*<reference\s+lib="(.+?)"\s*\/>/gm,
-      (_, lib) => `/// <reference path="./lib.${lib}.d.ts" />`
-    );
 
     await writeFile(path.join(distDir, "lib." + libFile), result);
     console.log(libFile);

build/build.ts

@@ -1,50 +1,175 @@
-import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, rm, symlink, writeFile } from "fs/promises";
 import path from "path";
 
+const scope = "better-typescript-lib";
+
 const projectDir = process.env.PROJECT || process.cwd();
 const libDir = path.join(projectDir, "generated");
-const betterDir = path.join(projectDir, "lib");
 const templateDir = path.join(projectDir, "package-template");
 const packageDir = path.join(projectDir, "dist-package");
+const testsDir = path.join(projectDir, "tests");
 
 async function main() {
   await rm(packageDir, {
     force: true,
     recursive: true,
   });
-  await mkdir(path.join(packageDir, "better"), {
+  await mkdir(packageDir, {
     recursive: true,
   });
 
-  // copy package template
-  // copy lib files
-  const files = (await readdir(libDir))
-    .filter((libFile) => /\.d\.ts$/.test(libFile))
-    .map((libFile) => path.join(libDir, libFile))
-    .concat(
-      (await readdir(templateDir)).map((file) => path.join(templateDir, file))
-    )
-    .concat([
-      path.join(projectDir, "README.md"),
-      path.join(projectDir, "LICENSE"),
-    ]);
-  await Promise.all(
-    files
-      .map(async (libFile) => {
-        await writeFile(
-          path.join(packageDir, path.basename(libFile)),
-          await readFile(libFile)
-        );
-      })
-      .concat(
-        (await readdir(betterDir)).map(async (libFile) => {
-          await writeFile(
-            path.join(packageDir, "better", libFile),
-            await readFile(path.join(betterDir, libFile))
-          );
-        })
-      )
+  // 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) =>
+    /\.d\.ts$/.test(libFile)
   );
+
+  const packageNames = new Set<string>();
+  for (const libFile of libFiles) {
+    console.log(`Processing ${libFile}`);
+    const libFilePath = path.join(libDir, libFile);
+    const { packageName, packagePath } =
+      getPackageNameAndPathOfLib(libFilePath);
+    packageNames.add(packageName);
+
+    const alreadyExisted = await mkdir(path.join(packageDir, packageName))
+      .then(() => false)
+      .catch((err) => {
+        if (err.code !== "EEXIST") {
+          throw err;
+        }
+        return true;
+      });
+    if (!alreadyExisted) {
+      // install package template files
+      await installPackageTemplateFiles(path.join(packageDir, packageName));
+      // update package.json
+      const packageJsonPath = path.join(
+        packageDir,
+        packageName,
+        "package.json"
+      );
+      await writeToPackageJson(packageJsonPath, () => ({
+        name: toScopedPackageName(packageName),
+        version,
+      }));
+    }
+
+    // copy lib file
+    const targetPath = path.join(packageDir, packageName, packagePath);
+    const targetDir = path.dirname(targetPath);
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(targetPath, await readFile(libFilePath));
+  }
+  // Prepare "main" package
+  {
+    const mainPackageDir = path.join(packageDir, "__main");
+    await mkdir(mainPackageDir);
+
+    // install package template files
+    await installPackageTemplateFiles(mainPackageDir);
+    // copy root README to main package
+    await writeFile(
+      path.join(mainPackageDir, "README.md"),
+      await readFile(path.join(projectDir, "README.md"))
+    );
+    // update package.json
+    const packageJsonPath = path.join(mainPackageDir, "package.json");
+    await writeToPackageJson(packageJsonPath, () => ({
+      name: rootPackageName,
+      version,
+      types: "./dist/index.d.ts",
+      dependencies: Object.fromEntries(
+        [...packageNames].map((packageName) => [
+          `@typescript/lib-${packageName}`,
+          `npm:${toScopedPackageName(packageName)}@${version}`,
+        ])
+      ),
+    }));
+    // prepare symlink to dist
+    await symlink(
+      path.join(projectDir, "dist"),
+      path.join(mainPackageDir, "dist")
+    );
+  }
+  // update package.json in "tests" folder
+  {
+    const packageJsonPath = path.join(testsDir, "package.json");
+    await writeToPackageJson(packageJsonPath, (original) => ({
+      dependencies: {
+        ...original.dependencies,
+        ...Object.fromEntries(
+          [...packageNames].map((packageName) => [
+            `@typescript/lib-${packageName}`,
+            `file:${path.relative(
+              path.dirname(packageJsonPath),
+              path.join(packageDir, packageName)
+            )}`,
+          ])
+        ),
+      },
+    }));
+  }
+
+  function installPackageTemplateFiles(dir: string) {
+    return Promise.all(
+      packageTemplateFiles.map(async (file) => {
+        const filePath = path.join(templateDir, file);
+        const targetPath = path.join(dir, file);
+        return writeFile(targetPath, await readFile(filePath));
+      })
+    );
+  }
+  async function writeToPackageJson(
+    packageJsonPath: string,
+    updates: (original: any) => Record<string, unknown>
+  ) {
+    const original = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    return writeFile(
+      packageJsonPath,
+      JSON.stringify(
+        {
+          ...original,
+          ...updates(original),
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+  function toScopedPackageName(packageName: string) {
+    return `@${scope}/${packageName}`;
+  }
+}
+
+function getPackageNameAndPathOfLib(libFile: string) {
+  const libFileName = path.basename(libFile, ".d.ts");
+  const components = libFileName.split(".");
+
+  // lib.dom.d.ts -> @typescript/lib-dom
+  // lib.dom.iterable.d.ts -> @typescript/lib-dom/iterable
+  // lib.es2015.symbol.wellknown.d.ts -> @typescript/lib-es2015/symbol-wellknown
+
+  if (components[0] !== "lib") {
+    throw new Error(`Invalid lib file: ${libFile}`);
+  }
+
+  const packageName = components[1];
+  const packagePath =
+    components.length > 2
+      ? components.slice(2).join("-") + ".d.ts"
+      : "index.d.ts";
+  return {
+    packageName,
+    packagePath,
+  };
 }
 
 main().catch((err) => {