Allow dynamic usage of import = require syntax

[kirkwaiblinger]

🔍 Search Terms

dynamic import, require, verbatimmodulesyntax

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

I propose that import = require() should be allowed anywhere a require() statement is allowed (under appropriate module settings).

function foo() {
   import foo = require('./module.js');
}

📃 Motivating Example

I've been trying to convert a commonjs project to verbatimModuleSyntax. Currently dynamic JSON imports are written as

function foo() {
   const json = await import('./foo.json');
}

which are rewritten as Promise.resolve().then(() => require('./foo.json')); by TS due to my module setting. The import() syntax currently has the advantage that TS statically analyzes and provides types for the imported JSON.

I'd like to convert the JSON import to a require() call, however, a bare require() loses static analysis. Therefore, I'd like to be able to use

function foo() {
   import json = require('./foo.json');
}

in order to have type inference and static analysis of the json file (also to have it copied to the output build).

(using a node import()-from-CJS is not available to me at this time)

💻 Use Cases

1. What do you want to use this for? dynamic require()s with static analysis, under verbatimModuleSyntax
2. What shortcomings exist with current approaches? No static analysis of dynamic require()s.
3. What workarounds are you using in the meantime? Not using verbatimModuleSyntax

---

Somewhat relates to #60598

[MartinJohns]

Would that even be legal JavaScript syntax?

[kirkwaiblinger]

Would that even be legal JavaScript syntax?

Why wouldn't it? A require() call is always valid... It's just a function call.

[kirkwaiblinger]

Oh, I understand the question better now. This is existing TS syntax and it's required (pun intended) for CJS + verbatimModuleSyntax. I'm just asking for it to be permitted in all locations where a statement is permitted, rather than just the top level.

• https://www.typescriptlang.org/docs/handbook/2/modules.html#es-module-syntax-with-commonjs-behavior
• https://www.typescriptlang.org/tsconfig/#verbatimModuleSyntax
• Proposal: deprecate importsNotUsedAsValues and preserveValueImports in favor of single flag #51479 :

  True to its name, verbatimModuleSyntax has another consequence: ESM syntax cannot be used in files that will emit CommonJS syntax. For example:

  import { writeFile } from "fs";
  This import is legal under --module esnext, but an error in --module commonjs. (In node16 and nodenext, it depends on the file extension and/or the package.json "type" field.) If the file is determined to be a CommonJS module at emit by any of these settings, it must be written as

  import fs = require("fs");
  instead. Many users have the impression that this syntax is legacy or deprecated, but that’s not the case. It accurately reflects that the output will use a require statement, instead of obscuring the output behind layers of transformations and interop helpers. I think using this syntax is particularly valuable in .cts files under --module nodenext, because in Node’s module system, imports and requires have markedly different semantics, and actually writing out require helps you understand when and why you can’t require an ES module—it’s easier to lose track of this when your require is disguised as an ESM import in the source file.