Add tests for awaiting a delayed goodbye (#11)

Author: steverep

.github/workflows/ci.yml

@@ -44,9 +44,7 @@ jobs:
         run: yarn run lint:js
       - name: Check format
         run: yarn run lint:format
-      - name: Check types
-        run: yarn run lint:types
       - name: Build package
         run: yarn run build
-      #- name: Run Tests
-      #run: yarn run test
+      - name: Run Tests
+        run: yarn run test

eslint.config.js

@@ -14,7 +14,7 @@ const rootDir = dirname(fileURLToPath(import.meta.url));
 const compat = new FlatCompat({ baseDirectory: rootDir });
 
 export default [
-  { ignores: [".yarn/", ".pnp.*", "dist/"] },
+  { ignores: [".yarn/", ".pnp.*", "**/dist/"] },
   { files: [allFiles], ...eslintJS.configs.recommended },
   ...compat
     .extends(
@@ -35,9 +35,9 @@ export default [
       // Options specific to @typescript-eslint/parser
       parser: typescriptParser,
       parserOptions: {
+        allowAutomaticSingleRunInference: true,
         ecmaVersion: "latest",
-        project: "tsconfig.json",
-        tsconfigRootDir: rootDir,
+        EXPERIMENTAL_useProjectService: true,
       },
     },
     linterOptions: {
@@ -54,5 +54,8 @@ export default [
   {
     files: ["test/**/*.spec.?(c|m)ts"],
     languageOptions: { globals: globals.mocha },
+    rules: {
+      "@typescript-eslint/require-await": "off",
+    },
   },
 ];

mocha.config.cjs

@@ -1,6 +1,8 @@
 module.exports = {
   require: "ts-node/register",
   loader: ["ts-node/esm", "./.pnp.loader.mjs"],
+  asyncOnly: true,
+  forbidOnly: true,
   spec: ["test/**/*.spec.*"],
   watchFiles: ["src"],
 };

package.json

@@ -38,15 +38,14 @@
   "types": "./dist/index.d.cts",
   "sideEffects": false,
   "scripts": {
-    "lint:js": "eslint --cache --cache-strategy=content --cache-location=node_modules/.cache/eslint/.eslintcache .",
+    "lint:js": "eslint --cache-location=node_modules/.cache/eslint/.eslintcache .",
+    "lint:format": "prettier --cache --check .",
+    "lint": "yarn dedupe --check && yarn run lint:js && yarn run lint:format",
     "fix": "yarn run lint:js --fix",
     "format": "prettier --cache --write .",
-    "lint:format": "prettier --cache --check .",
-    "lint:types": "tsc",
-    "lint": "yarn dedupe --check && yarn run lint:js && yarn run lint:format && yarn run lint:types",
-    "build": "tsc --build src",
+    "build": "tsc --build --verbose",
     "test": "mocha --config mocha.config.cjs",
-    "clean": "tsc --build --clean",
+    "clean": "tsc --build --clean && rm -rf test/dist",
     "prepublish": "yarn run lint",
     "prepack": "yarn run build",
     "postpack": "yarn run clean"

src/tsconfig.json

@@ -1,6 +1,9 @@
 {
   "extends": "../tsconfig.json",
+  "include": ["./"],
   "compilerOptions": {
+    // Modules
+    "rootDir": ".",
     // Emit
     "noEmit": false,
     "declaration": true,

test/goodbye.spec.ts

@@ -0,0 +1,93 @@
+import { expect } from "chai";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TransformAsyncModulesPlugin } from "transform-async-modules-webpack-plugin";
+import webpack from "webpack";
+
+type GoodbyeEntry = typeof import("./src/simple.js");
+
+const context = fileURLToPath(new URL(".", import.meta.url));
+const ENTRY_NAMES = ["simple", "chained"] as const;
+const CHECK_CHUNKS = ["goodbye", "parent"] as const;
+
+for (const nodeVersion of [8, 6, 0.12]) {
+  describe(`Goodbye delay with node ${nodeVersion} target`, function () {
+    const outDir = join(context, "dist", `v${nodeVersion}`);
+    let compileProblems = "";
+
+    before("Run Webpack", function (done) {
+      this.timeout("5s");
+      webpack(
+        {
+          name: `goodbye-node${nodeVersion}`,
+          context,
+          entry: Object.fromEntries(
+            ENTRY_NAMES.map((name) => [name, `./src/${name}.js`]),
+          ),
+          output: {
+            clean: true,
+            path: outDir,
+            filename: "[name].cjs",
+            library: { type: "commonjs-static" },
+          },
+          target: `async-node${nodeVersion}`,
+          plugins: [
+            new TransformAsyncModulesPlugin({
+              browserslistConfigFile: false,
+              targets: `node ${nodeVersion}`,
+            }),
+          ],
+          devtool: "source-map",
+          mode: "development",
+          node: false,
+        },
+        (err, stats) => {
+          if (stats?.hasErrors()) {
+            compileProblems = stats.toString("errors-only");
+          }
+          done(err);
+        },
+      );
+    });
+
+    it("Compiles without errors", async function () {
+      expect(compileProblems, compileProblems).to.be.empty;
+    });
+
+    for (const name of CHECK_CHUNKS) {
+      const outChunk = join(outDir, `src_${name}_js.cjs`);
+      if (nodeVersion < 7.6) {
+        it(`Transpiles the async function to a generator in the ${name} chunk`, async function () {
+          const code = await readFile(outChunk, "utf-8");
+          expect(code).to.have.string("function _asyncToGenerator(fn) {");
+        });
+      } else {
+        it(`Contains async arrow function in the ${name} chunk`, async function () {
+          const code = await readFile(outChunk, "utf-8");
+          expect(code).to.have.string(
+            " async (__webpack_handle_async_dependencies__, __webpack_async_result__) => {",
+          );
+        });
+      }
+      if (nodeVersion < 4) {
+        it(`Uses the regenerator runtime in the ${name} chunk`, async function () {
+          const code = await readFile(outChunk, "utf-8");
+          expect(code).to.have.string(" function _regeneratorRuntime() {");
+        });
+      }
+    }
+
+    for (const name of ENTRY_NAMES) {
+      const outEntry = join(outDir, `${name}.cjs`);
+      it(`Awaits with correct phrase and delay for ${name} entry`, async function () {
+        const { goodbye } = (await import(outEntry)) as GoodbyeEntry;
+        const { PHRASE, DELAY, awaitedPhrase, awaitedDelay } = await goodbye;
+        expect(awaitedPhrase).to.be.a("string").which.equals(PHRASE);
+        expect(awaitedDelay)
+          .to.be.a("number")
+          .which.is.at.least(0.99 * DELAY);
+      });
+    }
+  });
+}

test/src/chained.js

@@ -0,0 +1,2 @@
+// Chained entrypoint where both the TLA module and its parent are async.
+export const goodbye = import("./parent.js").then(({ pg }) => pg);

test/src/goodbye.js

@@ -0,0 +1,10 @@
+// This module contains a simple TLA to await a string after a short delay.
+// It will be wrapped in an async function by Webpack.
+import { setTimeout } from "node:timers/promises";
+
+export const PHRASE = "Goodby async!";
+export const DELAY = 250;
+
+const startTime = performance.now();
+export const awaitedPhrase = await setTimeout(DELAY, PHRASE);
+export const awaitedDelay = performance.now() - startTime;

test/src/parent.js

@@ -0,0 +1,3 @@
+// Webpack will also async wrap this module because it imports the TLA module.
+import * as pg from "./goodbye.js";
+export { pg };

test/src/simple.js

@@ -0,0 +1,2 @@
+// Simple entrypoint where only the TLA module is async.
+export const goodbye = import("./goodbye.js");