Jquery error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided.

[pmunin]

TypeScript Version: 2.6.2

Code

//package.json:
{
  "name": "issue-ts-isolatedmodule",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "jquery": "^3.2.1"
  }
  ,"devDependencies": {
    "typescript": "^2.6.2",
    "@types/jquery":"^3.2.17"
  }
}

//tsconfig.json

{
  "compilerOptions": {
    "outDir": "build/dist",
    "module": "esnext",
    "target": "es5",
    "lib": ["es6", "dom"],
    "sourceMap": true,
    "allowJs": true,
    "jsx": "react",
    "moduleResolution": "node",
    "rootDir": "src",
    "forceConsistentCasingInFileNames": true,
    "suppressImplicitAnyIndexErrors": true,
    "isolatedModules": true,
    "preserveConstEnums": true,
    "preserveSymlinks": true,
    "allowSyntheticDefaultImports": true
  },
  "exclude": [
    "node_modules",
    "build",
    "scripts",
    "acceptance-tests",
    "webpack",
    "jest",
    "src/setupTests.ts"
  ]
}

//src/index.ts
export function HalloWorld(){
    return "Hallo world!"
}

Executing tsc -p ..

Expected behavior:
successfully compiled /build/dist/{tsfilename}.js for each ts module:

Actual behavior:

node_modules/@types/jquery/index.d.ts(7690,16): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided.
node_modules/@types/jquery/index.d.ts(7698,16): error TS1209: Ambient const enums are not allowed when the '--isolatedModules' flag is provided.

[RyanCavanaugh]

@mhegazy I was discussing this with Skype earlier this week - it would be much better if const enum was only an error if consumed in an implementation file. Otherwise random .d.ts files from DT can "poison" --isolatedModules compilations. Thoughts?

[pmunin]

If it is consumed by a ts file, how to use JQuery types with --isolatedModules on?

[mhegazy]

I have created a dtslint issue to ban const enums in declaration files. i think a declaration file in general should be applicable to the strictest settings, and this includes --isolatedModules.

[RyanCavanaugh]

We need to expand the lint rule on DefinitelyTyped as const enum on DT really does not make sense.

Separately, accepting PRs to move the error from a const enum existing to a const enum being referenced (in a value position) when isolatedModules is on. Should be relatively easy.

[zspitz]

const enum on DT really does not make sense.

@RyanCavanaugh const enum in an ambient context allows documenting a set of values which are not available via the object model, and which are to be inlined on compilation. Instead of this:

const app = new ActiveXObject('Access.Application');
app.RunCommand(97); // what is 97?

the enum values could be defined in the .d.ts file:

declare namespace Access {
    const enum AcCommand {
        // ...
        acCmdSaveRecord = 97,
        // ...
    }
}

and consumed by the .ts file by name:

app.RunCommand(Access.AcCommand.acCmdSaveRecord);

and inlined on compilation.

Ideally, these values should be part of the object model:

// Javascript implementation code
var Access = {
    AcCommand: {
        acCmdSaveRecord: 97
    }
};

and could then be referred to in the .d.ts file as a plain (non-const) enum; but I don't think this is done in practice.

Perhaps this isn't the best mechanism for inlining declared values, as enum doesn't just imply a documented set of values, but also restricting to that set of values. But the compiler doesn't enforce this; the following would compile:

app.RunCommand(-42);

even though -42 is not one of the values used in the enum.

[mhegazy]

const enum in an ambient context allows documenting a set of fixed values to be inlined on compilation, which are not accessible via the object model. Instead of this:

You should use a union type of literals (string or number) instead.

I understand the documentation rational. but a declaration file is included in multiple projects, and the author of the declaration can not control how the user will build their project. And thus, a .d.ts should adhere to the least common denominator of compiler options. this is not any different from --noImplicitAny or --strictNullchecks.

[zspitz]

@mhegazy

a .d.ts should adhere to the least common denominator of compiler options

Understood. My question is now, why does --isolatedModules prevent inlining values from const enums?