diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 6dee0ddbf2146..a0ff7fdf8950b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -35258,6 +35258,12 @@ namespace ts { checkCollisionWithRequireExportsInGeneratedCode(node, node.name!); checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name!); checkAliasSymbol(node); + if (node.kind === SyntaxKind.ImportSpecifier && + idText(node.propertyName || node.name) === "default" && + compilerOptions.esModuleInterop && + moduleKind !== ModuleKind.System && moduleKind < ModuleKind.ES2015) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.ImportDefault); + } } function checkImportDeclaration(node: ImportDeclaration) { @@ -35277,6 +35283,10 @@ namespace ts { if (importClause.namedBindings) { if (importClause.namedBindings.kind === SyntaxKind.NamespaceImport) { checkImportBinding(importClause.namedBindings); + if (moduleKind !== ModuleKind.System && moduleKind < ModuleKind.ES2015 && compilerOptions.esModuleInterop) { + // import * as ns from "foo"; + checkExternalEmitHelpers(node, ExternalEmitHelpers.ImportStar); + } } else { const moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier); @@ -35287,6 +35297,7 @@ namespace ts { } } } + } function checkImportEqualsDeclaration(node: ImportEqualsDeclaration) { @@ -35354,6 +35365,7 @@ namespace ts { } else { // export * from "foo" + // export * as ns from "foo"; const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier!); if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) { error(node.moduleSpecifier, Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol)); @@ -35362,7 +35374,18 @@ namespace ts { checkAliasSymbol(node.exportClause); } if (moduleKind !== ModuleKind.System && moduleKind < ModuleKind.ES2015) { - checkExternalEmitHelpers(node, ExternalEmitHelpers.ExportStar); + if (node.exportClause) { + // export * as ns from "foo"; + // For ES2015 modules, we emit it as a pair of `import * as a_1 ...; export { a_1 as ns }` and don't need the helper. + // We only use the helper here when in esModuleInterop + if (compilerOptions.esModuleInterop) { + checkExternalEmitHelpers(node, ExternalEmitHelpers.ImportStar); + } + } + else { + // export * from "foo" + checkExternalEmitHelpers(node, ExternalEmitHelpers.ExportStar); + } } } } @@ -35434,6 +35457,14 @@ namespace ts { } } } + else { + if (compilerOptions.esModuleInterop && + moduleKind !== ModuleKind.System && + moduleKind < ModuleKind.ES2015 && + idText(node.propertyName || node.name) === "default") { + checkExternalEmitHelpers(node, ExternalEmitHelpers.ImportDefault); + } + } } function checkExportAssignment(node: ExportAssignment) { @@ -37624,6 +37655,8 @@ namespace ts { case ExternalEmitHelpers.AsyncDelegator: return "__asyncDelegator"; case ExternalEmitHelpers.AsyncValues: return "__asyncValues"; case ExternalEmitHelpers.ExportStar: return "__exportStar"; + case ExternalEmitHelpers.ImportStar: return "__importStar"; + case ExternalEmitHelpers.ImportDefault: return "__importDefault"; case ExternalEmitHelpers.MakeTemplateObject: return "__makeTemplateObject"; case ExternalEmitHelpers.ClassPrivateFieldGet: return "__classPrivateFieldGet"; case ExternalEmitHelpers.ClassPrivateFieldSet: return "__classPrivateFieldSet"; diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts index 8fbf370413aeb..15f86bf5a43fa 100644 --- a/src/compiler/factory/emitHelpers.ts +++ b/src/compiler/factory/emitHelpers.ts @@ -31,6 +31,7 @@ namespace ts { createImportStarHelper(expression: Expression): Expression; createImportStarCallbackHelper(): Expression; createImportDefaultHelper(expression: Expression): Expression; + createExportStarHelper(moduleExpression: Expression, exportsExpression?: Expression): Expression; // Class Fields Helpers createClassPrivateFieldGetHelper(receiver: Expression, privateField: Identifier): Expression; createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression): Expression; @@ -69,6 +70,7 @@ namespace ts { createImportStarHelper, createImportStarCallbackHelper, createImportDefaultHelper, + createExportStarHelper, // Class Fields Helpers createClassPrivateFieldGetHelper, createClassPrivateFieldSetHelper, @@ -366,6 +368,16 @@ namespace ts { ); } + function createExportStarHelper(moduleExpression: Expression, exportsExpression: Expression = factory.createIdentifier("exports")) { + context.requestEmitHelper(exportStarHelper); + context.requestEmitHelper(createBindingHelper); + return factory.createCallExpression( + getUnscopedHelperName("__exportStar"), + /*typeArguments*/ undefined, + [moduleExpression, exportsExpression] + ); + } + // Class Fields Helpers function createClassPrivateFieldGetHelper(receiver: Expression, privateField: Identifier) { @@ -815,6 +827,19 @@ namespace ts { };` }; + // emit output for the __export helper function + export const exportStarHelper: UnscopedEmitHelper = { + name: "typescript:export-star", + importName: "__exportStar", + scoped: false, + dependencies: [createBindingHelper], + priority: 2, + text: ` + var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); + };` + }; + // Class fields helpers export const classPrivateFieldGetHelper: UnscopedEmitHelper = { name: "typescript:classPrivateFieldGet", @@ -864,6 +889,7 @@ namespace ts { generatorHelper, importStarHelper, importDefaultHelper, + exportStarHelper, classPrivateFieldGetHelper, classPrivateFieldSetHelper, createBindingHelper, diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts index bd105d8c8af1c..49c90482a6b39 100644 --- a/src/compiler/transformers/module/module.ts +++ b/src/compiler/transformers/module/module.ts @@ -700,7 +700,6 @@ namespace ts { const promise = factory.createNewExpression(factory.createIdentifier("Promise"), /*typeArguments*/ undefined, [func]); if (compilerOptions.esModuleInterop) { - context.requestEmitHelper(importStarHelper); return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), /*typeArguments*/ undefined, [emitHelpers().createImportStarCallbackHelper()]); } return promise; @@ -715,7 +714,6 @@ namespace ts { const promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []); let requireCall: Expression = factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []); if (compilerOptions.esModuleInterop) { - context.requestEmitHelper(importStarHelper); requireCall = emitHelpers().createImportStarHelper(requireCall); } @@ -755,8 +753,7 @@ namespace ts { return innerExpr; } if (getExportNeedsImportStarHelper(node)) { - context.requestEmitHelper(importStarHelper); - return factory.createCallExpression(context.getEmitHelperFactory().getUnscopedHelperName("__importStar"), /*typeArguments*/ undefined, [innerExpr]); + return emitHelpers().createImportStarHelper(innerExpr); } return innerExpr; } @@ -766,11 +763,9 @@ namespace ts { return innerExpr; } if (getImportNeedsImportStarHelper(node)) { - context.requestEmitHelper(importStarHelper); return emitHelpers().createImportStarHelper(innerExpr); } if (getImportNeedsImportDefaultHelper(node)) { - context.requestEmitHelper(importDefaultHelper); return emitHelpers().createImportDefaultHelper(innerExpr); } return innerExpr; @@ -1015,7 +1010,7 @@ namespace ts { setOriginalNode( setTextRange( factory.createExpressionStatement( - context.getEmitHelperFactory().createCreateBindingHelper(generatedName, factory.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory.createStringLiteralFromNode(specifier.name) : undefined) + emitHelpers().createCreateBindingHelper(generatedName, factory.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory.createStringLiteralFromNode(specifier.name) : undefined) ), specifier), specifier @@ -1023,10 +1018,13 @@ namespace ts { ); } else { + const exportNeedsImportDefault = + !!compilerOptions.esModuleInterop && + !(getEmitFlags(node) & EmitFlags.NeverApplyImportHelper) && + idText(specifier.propertyName || specifier.name) === "default"; const exportedValue = factory.createPropertyAccessExpression( - generatedName, - specifier.propertyName || specifier.name - ); + exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName, + specifier.propertyName || specifier.name); statements.push( setOriginalNode( setTextRange( @@ -1051,9 +1049,9 @@ namespace ts { factory.createExpressionStatement( createExportExpression( factory.cloneNode(node.exportClause.name), - moduleKind !== ModuleKind.AMD ? - getHelperExpressionForExport(node, createRequireCall(node)) : - factory.createIdentifier(idText(node.exportClause.name)) + getHelperExpressionForExport(node, moduleKind !== ModuleKind.AMD ? + createRequireCall(node) : + factory.createIdentifier(idText(node.exportClause.name))) ) ), node @@ -1069,7 +1067,7 @@ namespace ts { return setOriginalNode( setTextRange( factory.createExpressionStatement( - createExportStarHelper(context, moduleKind !== ModuleKind.AMD ? createRequireCall(node) : generatedName) + emitHelpers().createExportStarHelper(moduleKind !== ModuleKind.AMD ? createRequireCall(node) : generatedName) ), node), node @@ -1857,24 +1855,6 @@ namespace ts { } } - // emit output for the __export helper function - const exportStarHelper: UnscopedEmitHelper = { - name: "typescript:export-star", - importName: "__exportStar", - scoped: false, - dependencies: [createBindingHelper], - priority: 2, - text: ` - var __exportStar = (this && this.__exportStar) || function(m, exports) { - for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); - };` - }; - - function createExportStarHelper(context: TransformationContext, module: Expression) { - context.requestEmitHelper(exportStarHelper); - return context.factory.createCallExpression(context.getEmitHelperFactory().getUnscopedHelperName("__exportStar"), /*typeArguments*/ undefined, [module, context.factory.createIdentifier("exports")]); - } - // emit helper for dynamic import const dynamicImportUMDHelper: EmitHelper = { name: "typescript:dynamicimport-sync-require", diff --git a/src/compiler/transformers/utilities.ts b/src/compiler/transformers/utilities.ts index ce64f72db7ee7..a52cf7c68cdf7 100644 --- a/src/compiler/transformers/utilities.ts +++ b/src/compiler/transformers/utilities.ts @@ -122,6 +122,8 @@ namespace ts { uniqueExports.set(idText(name), true); exportedNames = append(exportedNames, name); } + // we use the same helpers for `export * as ns` as we do for `import * as ns` + hasImportStar = true; } } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index c62f50b2104b8..1b96ff3c1ed8c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -6436,10 +6436,12 @@ namespace ts { AsyncDelegator = 1 << 14, // __asyncDelegator (used by ES2017 async generator yield* transformation) AsyncValues = 1 << 15, // __asyncValues (used by ES2017 for..await..of transformation) ExportStar = 1 << 16, // __exportStar (used by CommonJS/AMD/UMD module transformation) - MakeTemplateObject = 1 << 17, // __makeTemplateObject (used for constructing template string array objects) - ClassPrivateFieldGet = 1 << 18, // __classPrivateFieldGet (used by the class private field transformation) - ClassPrivateFieldSet = 1 << 19, // __classPrivateFieldSet (used by the class private field transformation) - CreateBinding = 1 << 20, // __createBinding (use by the module transform for (re)exports and namespace imports) + ImportStar = 1 << 17, // __importStar (used by CommonJS/AMD/UMD module transformation) + ImportDefault = 1 << 18, // __importStar (used by CommonJS/AMD/UMD module transformation) + MakeTemplateObject = 1 << 19, // __makeTemplateObject (used for constructing template string array objects) + ClassPrivateFieldGet = 1 << 20, // __classPrivateFieldGet (used by the class private field transformation) + ClassPrivateFieldSet = 1 << 21, // __classPrivateFieldSet (used by the class private field transformation) + CreateBinding = 1 << 22, // __createBinding (use by the module transform for (re)exports and namespace imports) FirstEmitHelper = Extends, LastEmitHelper = CreateBinding, diff --git a/src/testRunner/compilerRunner.ts b/src/testRunner/compilerRunner.ts index ef0abb1c45699..298c84ec8c777 100644 --- a/src/testRunner/compilerRunner.ts +++ b/src/testRunner/compilerRunner.ts @@ -159,13 +159,12 @@ namespace Harness { let configuredName = ""; const keys = Object .keys(configurationOverrides) - .map(k => k.toLowerCase()) .sort(); for (const key of keys) { if (configuredName) { configuredName += ","; } - configuredName += `${key}=${configurationOverrides[key].toLowerCase()}`; + configuredName += `${key.toLowerCase()}=${configurationOverrides[key].toLowerCase()}`; } if (configuredName) { const extname = vpath.extname(this.justName); diff --git a/tests/baselines/reference/esModuleInteropTslibHelpers.errors.txt b/tests/baselines/reference/esModuleInteropTslibHelpers.errors.txt new file mode 100644 index 0000000000000..ec0ea73e4d8a1 --- /dev/null +++ b/tests/baselines/reference/esModuleInteropTslibHelpers.errors.txt @@ -0,0 +1,23 @@ +tests/cases/compiler/file2.ts(1,1): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/refs.d.ts (0 errors) ==== + declare module "path"; +==== tests/cases/compiler/file.ts (0 errors) ==== + import path from "path"; + path.resolve("", "../"); + export class Foo { } +==== tests/cases/compiler/file2.ts (1 errors) ==== + import * as path from "path"; + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + path.resolve("", "../"); + export class Foo2 { } +==== tests/cases/compiler/file3.ts (0 errors) ==== + import {default as resolve} from "path"; + resolve("", "../"); + export class Foo3 { } +==== tests/cases/compiler/file4.ts (0 errors) ==== + import {Bar, default as resolve} from "path"; + resolve("", "../"); + export { Bar } \ No newline at end of file diff --git a/tests/baselines/reference/exportAsNamespace2(module=amd).js b/tests/baselines/reference/exportAsNamespace2(module=amd).js index 24b0d09cbfef5..a211d159abfe5 100644 --- a/tests/baselines/reference/exportAsNamespace2(module=amd).js +++ b/tests/baselines/reference/exportAsNamespace2(module=amd).js @@ -24,11 +24,30 @@ define(["require", "exports"], function (require, exports) { exports.b = 2; }); //// [1.js] +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; define(["require", "exports", "./0"], function (require, exports, ns) { "use strict"; exports.__esModule = true; exports.ns = void 0; - exports.ns = ns; + exports.ns = __importStar(ns); ns.a; ns.b; }); diff --git a/tests/baselines/reference/exportAsNamespace3(module=amd).js b/tests/baselines/reference/exportAsNamespace3(module=amd).js index e790c238c3bf2..0d0f63426fa32 100644 --- a/tests/baselines/reference/exportAsNamespace3(module=amd).js +++ b/tests/baselines/reference/exportAsNamespace3(module=amd).js @@ -27,11 +27,30 @@ define(["require", "exports"], function (require, exports) { exports.b = 2; }); //// [1.js] +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; define(["require", "exports", "./0"], function (require, exports, ns) { "use strict"; exports.__esModule = true; exports.ns = void 0; - exports.ns = ns; + exports.ns = __importStar(ns); ns.a; ns.b; var ns = { a: 1, b: 2 }; diff --git a/tests/baselines/reference/exportAsNamespace_missingEmitHelpers.js b/tests/baselines/reference/exportAsNamespace_missingEmitHelpers.js index abeabc8d48d04..7afa249b2f3a1 100644 --- a/tests/baselines/reference/exportAsNamespace_missingEmitHelpers.js +++ b/tests/baselines/reference/exportAsNamespace_missingEmitHelpers.js @@ -14,4 +14,5 @@ exports.__esModule = true; "use strict"; exports.__esModule = true; exports.ns = void 0; -exports.ns = require("./a"); // Error +var tslib_1 = require("tslib"); +exports.ns = tslib_1.__importStar(require("./a")); // Error diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).js new file mode 100644 index 0000000000000..df9ea324e8707 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.A = void 0; + class A { + } + exports.A = A; +}); +//// [b.js] +define(["require", "exports", "./a"], function (require, exports, a) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = void 0; + exports.a = a; +}); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=amd).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).js new file mode 100644 index 0000000000000..31beae743cc5c --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).js @@ -0,0 +1,25 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.A = void 0; +class A { +} +exports.A = A; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = void 0; +exports.a = require("./a"); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=commonjs).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).js new file mode 100644 index 0000000000000..68116bf951379 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a_1 from "./a"; +export { a_1 as a }; diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2015).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).js new file mode 100644 index 0000000000000..28e70a903d463 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).js @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +export * as a from "./a"; diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=es2020).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).js new file mode 100644 index 0000000000000..3040cd05cb126 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).js @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var A; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + A = class A { + }; + exports_1("A", A); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_1) { + exports_1("a", a_1); + } + ], + execute: function () { + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=false,module=system).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).js new file mode 100644 index 0000000000000..bb9e4bd8c2512 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).js @@ -0,0 +1,29 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.A = void 0; + class A { + } + exports.A = A; +}); +//// [b.js] +define(["require", "exports", "tslib", "./a"], function (require, exports, tslib_1, a) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = void 0; + exports.a = tslib_1.__importStar(a); +}); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=amd).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).js new file mode 100644 index 0000000000000..ad2ad22bf4756 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).js @@ -0,0 +1,26 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.A = void 0; +class A { +} +exports.A = A; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = void 0; +const tslib_1 = require("tslib"); +exports.a = tslib_1.__importStar(require("./a")); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=commonjs).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).js new file mode 100644 index 0000000000000..68116bf951379 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).js @@ -0,0 +1,19 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a_1 from "./a"; +export { a_1 as a }; diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2015).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).js new file mode 100644 index 0000000000000..28e70a903d463 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).js @@ -0,0 +1,18 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +export * as a from "./a"; diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=es2020).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).js b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).js new file mode 100644 index 0000000000000..3040cd05cb126 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).js @@ -0,0 +1,41 @@ +//// [tests/cases/compiler/importHelpersWithExportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +export * as a from "./a"; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var A; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + A = class A { + }; + exports_1("A", A); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_1) { + exports_1("a", a_1); + } + ], + execute: function () { + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).symbols b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).symbols new file mode 100644 index 0000000000000..0c0bedc015859 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).types b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).types new file mode 100644 index 0000000000000..c476dc5c21786 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithExportStarAs(esmoduleinterop=true,module=system).types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +export * as a from "./a"; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).js new file mode 100644 index 0000000000000..879aa4f0b7ffb --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).js @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + class default_1 { + } + exports.default = default_1; +}); +//// [b.js] +define(["require", "exports", "./a", "./a", "./a"], function (require, exports, a_1, a_2, a_3) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = exports.default = void 0; + Object.defineProperty(exports, "default", { enumerable: true, get: function () { return a_1.default; } }); + Object.defineProperty(exports, "a", { enumerable: true, get: function () { return a_2.default; } }); + void a_3.default; +}); diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=amd).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).js new file mode 100644 index 0000000000000..1cd1885355c2a --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).js @@ -0,0 +1,32 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +class default_1 { +} +exports.default = default_1; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = exports.default = void 0; +var a_1 = require("./a"); +Object.defineProperty(exports, "default", { enumerable: true, get: function () { return a_1.default; } }); +var a_2 = require("./a"); +Object.defineProperty(exports, "a", { enumerable: true, get: function () { return a_2.default; } }); +const a_3 = require("./a"); +void a_3.default; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=commonjs).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).js new file mode 100644 index 0000000000000..cb24120cb6e09 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +export default class { +} +//// [b.js] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2015).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).js new file mode 100644 index 0000000000000..cb24120cb6e09 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +export default class { +} +//// [b.js] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=es2020).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).js new file mode 100644 index 0000000000000..18ca3b239e530 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).js @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var default_1; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + default_1 = class { + }; + exports_1("default", default_1); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var a_1; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_2_1) { + exports_1({ + "default": a_2_1["default"] + }); + exports_1({ + "a": a_2_1["default"] + }); + a_1 = a_2_1; + } + ], + execute: function () { + void a_1.default; + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=false,module=system).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).js new file mode 100644 index 0000000000000..6a8466b591ffb --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).js @@ -0,0 +1,34 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + class default_1 { + } + exports.default = default_1; +}); +//// [b.js] +define(["require", "exports", "tslib", "./a", "./a", "./a"], function (require, exports, tslib_1, a_1, a_2, a_3) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = exports.default = void 0; + a_3 = tslib_1.__importDefault(a_3); + Object.defineProperty(exports, "default", { enumerable: true, get: function () { return tslib_1.__importDefault(a_1).default; } }); + Object.defineProperty(exports, "a", { enumerable: true, get: function () { return tslib_1.__importDefault(a_2).default; } }); + void a_3.default; +}); diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=amd).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).js new file mode 100644 index 0000000000000..50e3866222d41 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).js @@ -0,0 +1,33 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +class default_1 { +} +exports.default = default_1; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = exports.default = void 0; +const tslib_1 = require("tslib"); +var a_1 = require("./a"); +Object.defineProperty(exports, "default", { enumerable: true, get: function () { return tslib_1.__importDefault(a_1).default; } }); +var a_2 = require("./a"); +Object.defineProperty(exports, "a", { enumerable: true, get: function () { return tslib_1.__importDefault(a_2).default; } }); +const a_3 = tslib_1.__importDefault(require("./a")); +void a_3.default; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=commonjs).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).js new file mode 100644 index 0000000000000..cb24120cb6e09 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +export default class { +} +//// [b.js] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2015).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).js new file mode 100644 index 0000000000000..cb24120cb6e09 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).js @@ -0,0 +1,24 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +export default class { +} +//// [b.js] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=es2020).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).js b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).js new file mode 100644 index 0000000000000..18ca3b239e530 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).js @@ -0,0 +1,52 @@ +//// [tests/cases/compiler/importHelpersWithImportOrExportDefault.ts] //// + +//// [a.ts] +export default class { } + +//// [b.ts] +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +//// [tslib.d.ts] +declare module "tslib" { + function __importDefault(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var default_1; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + default_1 = class { + }; + exports_1("default", default_1); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var a_1; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_2_1) { + exports_1({ + "default": a_2_1["default"] + }); + exports_1({ + "a": a_2_1["default"] + }); + a_1 = a_2_1; + } + ], + execute: function () { + void a_1.default; + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).symbols b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).symbols new file mode 100644 index 0000000000000..96341fc8c39cf --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).symbols @@ -0,0 +1,26 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : Symbol(default, Decl(b.ts, 0, 8)) + +export { default as a } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>a : Symbol(a, Decl(b.ts, 1, 8)) + +import { default as b } from "./a"; +>default : Symbol(b, Decl(a.ts, 0, 0)) +>b : Symbol(b, Decl(b.ts, 2, 8)) + +void b; +>b : Symbol(b, Decl(b.ts, 2, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importDefault(m: any): void; +>__importDefault : Symbol(__importDefault, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).types b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).types new file mode 100644 index 0000000000000..867143d099172 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefault(esmoduleinterop=true,module=system).types @@ -0,0 +1,27 @@ +=== tests/cases/compiler/a.ts === +export default class { } +No type information for this code. +No type information for this code.=== tests/cases/compiler/b.ts === +export { default } from "./a"; +>default : typeof b + +export { default as a } from "./a"; +>default : typeof b +>a : typeof b + +import { default as b } from "./a"; +>default : typeof b +>b : typeof b + +void b; +>void b : undefined +>b : typeof b + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importDefault(m: any): void; +>__importDefault : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=amd).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=amd).errors.txt new file mode 100644 index 0000000000000..fe25b2d92ddcc --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=amd).errors.txt @@ -0,0 +1,11 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + export { default } from "./a"; + ~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=commonjs).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=commonjs).errors.txt new file mode 100644 index 0000000000000..fe25b2d92ddcc --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.1(esmoduleinterop=true,module=commonjs).errors.txt @@ -0,0 +1,11 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + export { default } from "./a"; + ~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=amd).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=amd).errors.txt new file mode 100644 index 0000000000000..460650a9e590f --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=amd).errors.txt @@ -0,0 +1,11 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + export { default as a } from "./a"; + ~~~~~~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=commonjs).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=commonjs).errors.txt new file mode 100644 index 0000000000000..460650a9e590f --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.2(esmoduleinterop=true,module=commonjs).errors.txt @@ -0,0 +1,11 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + export { default as a } from "./a"; + ~~~~~~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=amd).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=amd).errors.txt new file mode 100644 index 0000000000000..4f9c457cfbe94 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=amd).errors.txt @@ -0,0 +1,12 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + import { default as b } from "./a"; + ~~~~~~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + void b; + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=commonjs).errors.txt b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=commonjs).errors.txt new file mode 100644 index 0000000000000..4f9c457cfbe94 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportOrExportDefaultNoTslib.3(esmoduleinterop=true,module=commonjs).errors.txt @@ -0,0 +1,12 @@ +tests/cases/compiler/b.ts(1,10): error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + + +==== tests/cases/compiler/a.ts (0 errors) ==== + export default class { } + +==== tests/cases/compiler/b.ts (1 errors) ==== + import { default as b } from "./a"; + ~~~~~~~~~~~~ +!!! error TS2354: This syntax requires an imported helper but module 'tslib' cannot be found. + void b; + \ No newline at end of file diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).js new file mode 100644 index 0000000000000..f1bf8849c7168 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.A = void 0; + class A { + } + exports.A = A; +}); +//// [b.js] +define(["require", "exports", "./a"], function (require, exports, a) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = void 0; + exports.a = a; +}); diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=amd).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).js new file mode 100644 index 0000000000000..8ecadfeab37f6 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).js @@ -0,0 +1,27 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.A = void 0; +class A { +} +exports.A = A; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = void 0; +const a = require("./a"); +exports.a = a; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=commonjs).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).js new file mode 100644 index 0000000000000..c08ff68957e44 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a from "./a"; +export { a }; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).js new file mode 100644 index 0000000000000..c08ff68957e44 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a from "./a"; +export { a }; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=es2020).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).js new file mode 100644 index 0000000000000..21f00ba533a79 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var A; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + A = class A { + }; + exports_1("A", A); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var a; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_1) { + a = a_1; + } + ], + execute: function () { + exports_1("a", a); + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=false,module=system).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).js new file mode 100644 index 0000000000000..d19acf3679cb8 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).js @@ -0,0 +1,31 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.A = void 0; + class A { + } + exports.A = A; +}); +//// [b.js] +define(["require", "exports", "tslib", "./a"], function (require, exports, tslib_1, a) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.a = void 0; + a = tslib_1.__importStar(a); + exports.a = a; +}); diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=amd).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).js new file mode 100644 index 0000000000000..acb7d3e90b58a --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).js @@ -0,0 +1,28 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.A = void 0; +class A { +} +exports.A = A; +//// [b.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.a = void 0; +const tslib_1 = require("tslib"); +const a = tslib_1.__importStar(require("./a")); +exports.a = a; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=commonjs).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).js new file mode 100644 index 0000000000000..c08ff68957e44 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a from "./a"; +export { a }; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2015).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).js new file mode 100644 index 0000000000000..c08ff68957e44 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).js @@ -0,0 +1,20 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +export class A { +} +//// [b.js] +import * as a from "./a"; +export { a }; diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=es2020).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).js b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).js new file mode 100644 index 0000000000000..21f00ba533a79 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/importHelpersWithImportStarAs.ts] //// + +//// [a.ts] +export class A { } + +//// [b.ts] +import * as a from "./a"; +export { a }; + +//// [tslib.d.ts] +declare module "tslib" { + function __importStar(m: any): void; +} + +//// [a.js] +System.register([], function (exports_1, context_1) { + "use strict"; + var A; + var __moduleName = context_1 && context_1.id; + return { + setters: [], + execute: function () { + A = class A { + }; + exports_1("A", A); + } + }; +}); +//// [b.js] +System.register(["./a"], function (exports_1, context_1) { + "use strict"; + var a; + var __moduleName = context_1 && context_1.id; + return { + setters: [ + function (a_1) { + a = a_1; + } + ], + execute: function () { + exports_1("a", a); + } + }; +}); diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).symbols b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).symbols new file mode 100644 index 0000000000000..e99fbff5281a2 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).symbols @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : Symbol(A, Decl(a.ts, 0, 0)) + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : Symbol(a, Decl(b.ts, 0, 6)) + +export { a }; +>a : Symbol(a, Decl(b.ts, 1, 8)) + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : Symbol("tslib", Decl(tslib.d.ts, --, --)) + + function __importStar(m: any): void; +>__importStar : Symbol(__importStar, Decl(tslib.d.ts, --, --)) +>m : Symbol(m, Decl(tslib.d.ts, --, --)) +} diff --git a/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).types b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).types new file mode 100644 index 0000000000000..0663a65a9e766 --- /dev/null +++ b/tests/baselines/reference/importHelpersWithImportStarAs(esmoduleinterop=true,module=system).types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/a.ts === +export class A { } +>A : A + +=== tests/cases/compiler/b.ts === +import * as a from "./a"; +>a : typeof a + +export { a }; +>a : typeof a + +=== tests/cases/compiler/tslib.d.ts === +declare module "tslib" { +>"tslib" : typeof import("tslib") + + function __importStar(m: any): void; +>__importStar : (m: any) => void +>m : any +} diff --git a/tests/baselines/reference/jsDeclarationsReexportAliasesEsModuleInterop.js b/tests/baselines/reference/jsDeclarationsReexportAliasesEsModuleInterop.js index d08915482e57c..ea1f56be97038 100644 --- a/tests/baselines/reference/jsDeclarationsReexportAliasesEsModuleInterop.js +++ b/tests/baselines/reference/jsDeclarationsReexportAliasesEsModuleInterop.js @@ -29,7 +29,7 @@ exports.Foob = exports.x = void 0; var cls_1 = __importDefault(require("./cls")); exports.x = new cls_1.default(); var cls_2 = require("./cls"); -Object.defineProperty(exports, "Foob", { enumerable: true, get: function () { return cls_2.default; } }); +Object.defineProperty(exports, "Foob", { enumerable: true, get: function () { return __importDefault(cls_2).default; } }); //// [cls.d.ts] diff --git a/tests/cases/compiler/importHelpersWithExportStarAs.ts b/tests/cases/compiler/importHelpersWithExportStarAs.ts new file mode 100644 index 0000000000000..4dae5fca0a2c7 --- /dev/null +++ b/tests/cases/compiler/importHelpersWithExportStarAs.ts @@ -0,0 +1,14 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @filename: a.ts +export class A { } + +// @filename: b.ts +export * as a from "./a"; + +// @filename: tslib.d.ts +declare module "tslib" { + function __importStar(m: any): void; +} \ No newline at end of file diff --git a/tests/cases/compiler/importHelpersWithImportOrExportDefault.ts b/tests/cases/compiler/importHelpersWithImportOrExportDefault.ts new file mode 100644 index 0000000000000..a314deaf1f24b --- /dev/null +++ b/tests/cases/compiler/importHelpersWithImportOrExportDefault.ts @@ -0,0 +1,17 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @filename: a.ts +export default class { } + +// @filename: b.ts +export { default } from "./a"; +export { default as a } from "./a"; +import { default as b } from "./a"; +void b; + +// @filename: tslib.d.ts +declare module "tslib" { + function __importDefault(m: any): void; +} \ No newline at end of file diff --git a/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.1.ts b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.1.ts new file mode 100644 index 0000000000000..f8d5639d277ba --- /dev/null +++ b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.1.ts @@ -0,0 +1,11 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @noEmit: true +// @noTypesAndSymbols: true +// @filename: a.ts +export default class { } + +// @filename: b.ts +export { default } from "./a"; diff --git a/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.2.ts b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.2.ts new file mode 100644 index 0000000000000..66d99d7cd8305 --- /dev/null +++ b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.2.ts @@ -0,0 +1,11 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @noEmit: true +// @noTypesAndSymbols: true +// @filename: a.ts +export default class { } + +// @filename: b.ts +export { default as a } from "./a"; diff --git a/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.3.ts b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.3.ts new file mode 100644 index 0000000000000..f8c2fdafc9fc1 --- /dev/null +++ b/tests/cases/compiler/importHelpersWithImportOrExportDefaultNoTslib.3.ts @@ -0,0 +1,12 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @noEmit: true +// @noTypesAndSymbols: true +// @filename: a.ts +export default class { } + +// @filename: b.ts +import { default as b } from "./a"; +void b; diff --git a/tests/cases/compiler/importHelpersWithImportStarAs.ts b/tests/cases/compiler/importHelpersWithImportStarAs.ts new file mode 100644 index 0000000000000..e4e97c35381ec --- /dev/null +++ b/tests/cases/compiler/importHelpersWithImportStarAs.ts @@ -0,0 +1,15 @@ +// @importHelpers: true +// @target: es2017 +// @module: commonjs,system,amd,es2015,es2020 +// @esModuleInterop: true,false +// @filename: a.ts +export class A { } + +// @filename: b.ts +import * as a from "./a"; +export { a }; + +// @filename: tslib.d.ts +declare module "tslib" { + function __importStar(m: any): void; +} \ No newline at end of file diff --git a/tests/cases/conformance/es2020/modules/exportAsNamespace_missingEmitHelpers.ts b/tests/cases/conformance/es2020/modules/exportAsNamespace_missingEmitHelpers.ts index 5ace102ce56a4..2e6055754433b 100644 --- a/tests/cases/conformance/es2020/modules/exportAsNamespace_missingEmitHelpers.ts +++ b/tests/cases/conformance/es2020/modules/exportAsNamespace_missingEmitHelpers.ts @@ -1,5 +1,6 @@ // @module: commonjs // @importHelpers: true +// @esModuleInterop: true // @noTypesAndSymbols: true // @Filename: a.ts