Support stripping TypeScript’s CJS syntax

[remcohaszing]

What is the problem this feature will solve?

Currently it’s not possible to use Node.js type stripping to load a TypeScript CJS file:

import fs = require('fs')
export = fs

This is equivalent to the following JavaScript:

var fs = require('fs')
module.exports = fs

You could use the JavaScript style syntax, but then it’s no longer proper TypeScript. So you miss out on type checking features.

What is the feature you are proposing to solve the problem?

The import and export statements are long enough, that they can be replaced with whitespace and a temporary variable. Some helper code can be added to the end of the file. The code above can be replaced with:

// `import` → `var   `
var    fs = require('fs')
// `export` → `var xp`
var xp = fs
// Helper code
module.exports = xp

What alternatives have you considered?

No response

[marco-ippolito]

This syntax is not erasable and I think it's not even allowed with erasableSyntaxOnly so I don't think it's gonna happen

[remcohaszing]

How do you mean the syntax is not erasable? Because of the helper code at the end? Or because something other than whitespace is used to erase the syntax?

Also the import and export can be considered two distinct features. Now that I’m thinking of it, import variable = expression can be used for other expressions as well.

The TypeScript option erasableSyntaxOnly disallows the syntax, but I think this is only done to match Node.js behaviour.

[marco-ippolito]

no it's because the syntax needs to be transformed, that requires source maps and cannot be just replaced by blank spaces, like enums. to be valid js it requires to be transformed thats what --experimental-transform-types was doing. Both import = and export = are not supported for this reason

Erasable syntax:

const foo: string = 'boo';

// valid js
const foo:       =  'boo';

[remcohaszing]

Or because something other than whitespace is used to erase the syntax?

So you meant “yes” to this question?

import foo = 'boo';

// valid js
var    foo = 'boo';

Because of the helper code at the end?

And also “yes” to this question?

export = foo

// valid js
var xp = foo
// At end of file
module.exports = xp

No source maps are needed for either of these.

[marco-ippolito]

Or because something other than whitespace is used to erase the syntax?

Yes
Please read https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-8.html#the---erasablesyntaxonly-option

TypeScript-specific syntax cannot have runtime semantics.

In this case export has runtime semantic so it's not allowed.
And yes sourcemaps are needed. if you set a breakpoint at line 1 of:

export = foo

var xp = foo
module.exports = xp

You will find something else.

If you set a breaking point to line 1 of:

const foo: string = 'boo';

You will find

const foo       = 'boo';

[Renegade334]

The TS team recently clarified that the definition of "erasable syntax" is strictly limited to that TS syntax which can be replaced 1:1 with whitespace to yield valid JS. This proposal will always be unachievable under this definition.

Associated TS discussion: microsoft/TypeScript#61175