Merge remote-tracking branch 'upstream/main' into fix-node-modules-test-glob

# Conflicts:
#	lib/utils.ts

Author: dsherret

README.md

@@ -173,6 +173,73 @@ await build({
 });
 ```
 
+### Test Preload Module
+
+Specify a module to load before running the tests with the `testPreloadModule`
+build option:
+
+```ts
+await build({
+  // ...etc...
+  testPreloadModule: "./scripts/test_preload.ts",
+});
+```
+
+This is useful for setting up the Node.js environment the tests run in without
+affecting the distributed code. For example, when the distributed code assumes a
+global exists that Node.js doesn't have:
+
+```ts
+// scripts/test_preload.ts
+import { Headers, Response } from "npm:undici";
+
+Object.assign(globalThis, { Headers, Response });
+```
+
+The module is transformed and type checked like the test files are and it is not
+included in the npm package. It is loaded once for each of the emitted script
+and ESM output, before any test file.
+
+### Polyfills
+
+dnt adds polyfills for language features that may not exist in the environment
+implied by `compilerOptions.target`. If you're targeting a runtime that already
+supports a feature, use the `polyfills` build option to opt out and keep the
+extra code out of your package:
+
+```ts
+await build({
+  // ...etc...
+  polyfills: {
+    importMeta: false,
+  },
+});
+```
+
+Pass `true` or `false` instead of an object to enable or disable every polyfill
+at once. Anything you don't specify continues to be decided by the target, so
+`polyfills` overrides the target rather than replacing it.
+
+The supported names are `arrayFindLast`, `arrayFromAsync`, `errorCause`,
+`importMeta`, `objectHasOwn`, `promiseWithResolvers`, and `stringReplaceAll`.
+
+Note that the polyfills also provide the type declarations for the features they
+polyfill, so opting out of one means relying on your `compilerOptions.lib`
+declarations for it instead.
+
+The `importMeta` polyfill can only be disabled when the `scriptModule` build
+option is `false`, because `import.meta` is not valid CommonJS:
+
+```ts
+await build({
+  // ...etc...
+  scriptModule: false,
+  polyfills: {
+    importMeta: false,
+  },
+});
+```
+
 ### Shims
 
 dnt will shim the globals specified in the build options. For example, if you

deno.jsonc

@@ -51,6 +51,7 @@
     "tests/node_types_project/npm",
     "tests/package_mappings_project/npm",
     "tests/polyfill_array_find_last_project/npm",
+    "tests/polyfill_disabled_project/npm",
     "tests/polyfill_project/npm",
     "tests/shim_project/npm",
     "tests/test_project/npm",

lib/compiler_transforms.test.ts

@@ -70,3 +70,17 @@ Deno.test("transform import.meta.resolve expressions in esModule", () => {
     `function test(specifier) { globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).resolve(specifier); }\n`,
   );
 });
+
+Deno.test("does not transform new.target in commonjs", () => {
+  testImportReplacementsCjs(
+    "function test(...args) { return Reflect.construct(Struct, args, new.target); }",
+    `function test(...args) { return Reflect.construct(Struct, args, new.target); }\n`,
+  );
+});
+
+Deno.test("does not transform new.target in esModule", () => {
+  testImportReplacementsEsm(
+    "function test(...args) { return Reflect.construct(Struct, args, new.target); }",
+    `function test(...args) { return Reflect.construct(Struct, args, new.target); }\n`,
+  );
+});

lib/compiler_transforms.ts

@@ -14,8 +14,11 @@ export const transformImportMeta: ts.TransformerFactory<ts.SourceFile> = (
   return (sourceFile) => ts.visitEachChild(sourceFile, visitNode, context);
 
   function visitNode(node: ts.Node): ts.Node {
-    // find `import.meta`
-    if (ts.isMetaProperty(node)) {
+    // find `import.meta` (not `new.target`, which is also a meta property)
+    if (
+      ts.isMetaProperty(node) &&
+      node.keywordToken === ts.SyntaxKind.ImportKeyword
+    ) {
       if (isScriptModule) {
         return getReplacementImportMetaScript();
       } else {

lib/npm_ignore.ts

@@ -2,6 +2,7 @@
 
 import type { OutputFile } from "../transform.ts";
 import type { SourceMapOptions } from "./compiler.ts";
+import { toDtsFilePath, toJsFilePath } from "./utils.ts";
 
 export function getNpmIgnoreText(options: {
   sourceMap?: SourceMapOptions;
@@ -26,8 +27,8 @@ export function getNpmIgnoreText(options: {
 
   function* getTestFileNames() {
     for (const file of options.testFiles) {
-      const filePath = file.filePath.replace(/\.ts$/i, ".js");
-      const dtsFilePath = file.filePath.replace(/\.ts$/i, ".d.ts");
+      const filePath = toJsFilePath(file.filePath);
+      const dtsFilePath = toDtsFilePath(file.filePath);
       if (options.includeEsModule) {
         const esmFilePath = `/esm/${filePath}`;
         yield esmFilePath;

lib/package_json.ts

@@ -3,7 +3,7 @@
 import type { EntryPoint, ShimOptions } from "../mod.ts";
 import type { TransformOutput } from "../transform.ts";
 import type { PackageJson } from "./types.ts";
-import { getDntVersion } from "./utils.ts";
+import { getDntVersion, toDtsFilePath, toJsFilePath } from "./utils.ts";
 
 export interface GetPackageJsonOptions {
   transformOutput: TransformOutput;
@@ -32,8 +32,8 @@ export function getPackageJson({
     .main.entryPoints.map((e, i) => ({
       name: entryPoints[i].name,
       kind: entryPoints[i].kind ?? "export",
-      path: e.replace(/\.tsx?$/i, ".js"),
-      types: e.replace(/\.tsx?$/i, ".d.ts"),
+      path: toJsFilePath(e),
+      types: toDtsFilePath(e),
     }));
   const exports = finalEntryPoints.filter((e) => e.kind === "export");
   const binaries = finalEntryPoints.filter((e) => e.kind === "bin");

lib/polyfills.test.ts

@@ -0,0 +1,114 @@
+// Copyright 2018-2024 the Deno authors. MIT license.
+
+import { assertEquals, assertThrows } from "@std/assert";
+import {
+  resolvePolyfillOptions,
+  resolveUseImportMetaPolyfill,
+} from "./polyfills.ts";
+
+Deno.test("resolvePolyfillOptions - undefined leaves everything to the target", () => {
+  assertEquals(resolvePolyfillOptions(undefined), {});
+});
+
+Deno.test("resolvePolyfillOptions - boolean applies to every polyfill", () => {
+  assertEquals(resolvePolyfillOptions(false), {
+    arrayFindLast: false,
+    arrayFromAsync: false,
+    errorCause: false,
+    importMeta: false,
+    objectHasOwn: false,
+    promiseWithResolvers: false,
+    stringReplaceAll: false,
+  });
+  assertEquals(
+    Object.values(resolvePolyfillOptions(true)).every((v) => v),
+    true,
+  );
+});
+
+Deno.test("resolvePolyfillOptions - object only includes what's specified", () => {
+  assertEquals(
+    resolvePolyfillOptions({ importMeta: false, errorCause: true }),
+    { importMeta: false, errorCause: true },
+  );
+});
+
+Deno.test("resolvePolyfillOptions - undefined values fall back to the target", () => {
+  assertEquals(
+    resolvePolyfillOptions({ importMeta: undefined, errorCause: true }),
+    { errorCause: true },
+  );
+});
+
+Deno.test("resolvePolyfillOptions - throws for an unknown polyfill", () => {
+  assertThrows(
+    () =>
+      resolvePolyfillOptions(
+        { importMata: false } as Record<string, boolean>,
+      ),
+    Error,
+    "Unknown polyfill 'importMata'",
+  );
+});
+
+Deno.test("resolveUseImportMetaPolyfill - required when emitting a script module", () => {
+  assertEquals(
+    resolveUseImportMetaPolyfill({
+      polyfills: {},
+      target: "Latest",
+      emitScriptModule: true,
+    }),
+    true,
+  );
+});
+
+Deno.test("resolveUseImportMetaPolyfill - throws when disabled with a script module", () => {
+  assertThrows(
+    () =>
+      resolveUseImportMetaPolyfill({
+        polyfills: { importMeta: false },
+        target: "ES2021",
+        emitScriptModule: true,
+      }),
+    Error,
+    "cannot be disabled when emitting a script module",
+  );
+});
+
+Deno.test("resolveUseImportMetaPolyfill - esm only follows the target by default", () => {
+  assertEquals(
+    resolveUseImportMetaPolyfill({
+      polyfills: {},
+      target: "ES2021",
+      emitScriptModule: false,
+    }),
+    true,
+  );
+  assertEquals(
+    resolveUseImportMetaPolyfill({
+      polyfills: {},
+      target: "Latest",
+      emitScriptModule: false,
+    }),
+    false,
+  );
+});
+
+Deno.test("resolveUseImportMetaPolyfill - esm only respects an explicit override", () => {
+  assertEquals(
+    resolveUseImportMetaPolyfill({
+      polyfills: { importMeta: false },
+      target: "ES2021",
+      emitScriptModule: false,
+    }),
+    false,
+  );
+  assertEquals(
+    resolveUseImportMetaPolyfill({
+      polyfills: { importMeta: true },
+      target: "Latest",
+      emitScriptModule: false,
+    }),
+    true,
+  );
+});

lib/polyfills.ts

@@ -0,0 +1,71 @@
+// Copyright 2018-2024 the Deno authors. MIT license.
+
+import type { PolyfillName, PolyfillOptions, ScriptTarget } from "./types.ts";
+
+/** Every polyfill dnt knows how to apply. */
+export const polyfillNames: readonly PolyfillName[] = [
+  "arrayFindLast",
+  "arrayFromAsync",
+  "errorCause",
+  "importMeta",
+  "objectHasOwn",
+  "promiseWithResolvers",
+  "stringReplaceAll",
+];
+
+/** Resolves the user provided polyfill options into an explicit
+ * enabled/disabled value per polyfill.
+ *
+ * Polyfills that the user didn't specify are left out of the result so that
+ * the script target continues to decide whether they're used.
+ */
+export function resolvePolyfillOptions(
+  options: PolyfillOptions | undefined,
+): Record<string, boolean> {
+  if (options == null) {
+    return {};
+  }
+  if (typeof options === "boolean") {
+    return Object.fromEntries(polyfillNames.map((name) => [name, options]));
+  }
+
+  const resolved: Record<string, boolean> = {};
+  for (const [name, enabled] of Object.entries(options)) {
+    if (enabled == null) {
+      continue;
+    }
+    if (!polyfillNames.includes(name as PolyfillName)) {
+      throw new Error(
+        `Unknown polyfill '${name}' specified in the 'polyfills' option. ` +
+          `Supported polyfills: ${polyfillNames.join(", ")}`,
+      );
+    }
+    resolved[name] = enabled;
+  }
+  return resolved;
+}
+
+/** Whether the `import.meta` polyfill applies, given the resolved polyfill
+ * overrides and the rest of the build options.
+ *
+ * `import.meta` is a syntax error in CommonJS, so the polyfill is required
+ * whenever a script module is emitted regardless of the target.
+ */
+export function resolveUseImportMetaPolyfill(options: {
+  polyfills: Record<string, boolean>;
+  target: ScriptTarget;
+  emitScriptModule: boolean;
+}): boolean {
+  const explicit = options.polyfills["importMeta"];
+  if (options.emitScriptModule) {
+    if (explicit === false) {
+      throw new Error(
+        "The 'importMeta' polyfill cannot be disabled when emitting a script " +
+          "module because `import.meta` is not valid CommonJS. Set the " +
+          "'scriptModule' build option to false to distribute an ES module only.",
+      );
+    }
+    return true;
+  }
+  return explicit ?? options.target !== "Latest";
+}