@angular/compiler-cli 8.0.0 → 8.1.0-beta.0

package/ngcc/src/rendering/commonjs_rendering_formatter.d.ts

@@ -0,0 +1,25 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/commonjs_rendering_formatter" />
+import * as ts from 'typescript';
+import MagicString from 'magic-string';
+import { Import, ImportManager } from '../../../src/ngtsc/translator';
+import { ExportInfo } from '../analysis/private_declarations_analyzer';
+import { NgccReflectionHost } from '../host/ngcc_host';
+import { Esm5RenderingFormatter } from './esm5_rendering_formatter';
+/**
+ * A RenderingFormatter that works with CommonJS files, instead of `import` and `export` statements
+ * the module is an IIFE with a factory function call with dependencies, which are defined in a
+ * wrapper function for AMD, CommonJS and global module formats.
+ */
+export declare class CommonJsRenderingFormatter extends Esm5RenderingFormatter {
+    protected commonJsHost: NgccReflectionHost;
+    constructor(commonJsHost: NgccReflectionHost, isCore: boolean);
+    /**
+     *  Add the imports below any in situ imports as `require` calls.
+     */
+    addImports(output: MagicString, imports: Import[], file: ts.SourceFile): void;
+    /**
+     * Add the exports to the bottom of the file.
+     */
+    addExports(output: MagicString, entryPointBasePath: string, exports: ExportInfo[], importManager: ImportManager, file: ts.SourceFile): void;
+    protected findEndOfImports(sf: ts.SourceFile): number;
+}

package/ngcc/src/rendering/commonjs_rendering_formatter.js

@@ -0,0 +1,89 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/ngcc/src/rendering/commonjs_rendering_formatter", ["require", "exports", "tslib", "canonical-path", "typescript", "@angular/compiler-cli/ngcc/src/host/commonjs_host", "@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter", "@angular/compiler-cli/ngcc/src/rendering/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var canonical_path_1 = require("canonical-path");
+    var ts = require("typescript");
+    var commonjs_host_1 = require("@angular/compiler-cli/ngcc/src/host/commonjs_host");
+    var esm5_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/rendering/utils");
+    /**
+     * A RenderingFormatter that works with CommonJS files, instead of `import` and `export` statements
+     * the module is an IIFE with a factory function call with dependencies, which are defined in a
+     * wrapper function for AMD, CommonJS and global module formats.
+     */
+    var CommonJsRenderingFormatter = /** @class */ (function (_super) {
+        tslib_1.__extends(CommonJsRenderingFormatter, _super);
+        function CommonJsRenderingFormatter(commonJsHost, isCore) {
+            var _this = _super.call(this, commonJsHost, isCore) || this;
+            _this.commonJsHost = commonJsHost;
+            return _this;
+        }
+        /**
+         *  Add the imports below any in situ imports as `require` calls.
+         */
+        CommonJsRenderingFormatter.prototype.addImports = function (output, imports, file) {
+            var insertionPoint = this.findEndOfImports(file);
+            var renderedImports = imports.map(function (i) { return "var " + i.qualifier + " = require('" + i.specifier + "');\n"; }).join('');
+            output.appendLeft(insertionPoint, renderedImports);
+        };
+        /**
+         * Add the exports to the bottom of the file.
+         */
+        CommonJsRenderingFormatter.prototype.addExports = function (output, entryPointBasePath, exports, importManager, file) {
+            exports.forEach(function (e) {
+                var basePath = utils_1.stripExtension(e.from);
+                var relativePath = './' + canonical_path_1.relative(canonical_path_1.dirname(entryPointBasePath), basePath);
+                var namedImport = entryPointBasePath !== basePath ?
+                    importManager.generateNamedImport(relativePath, e.identifier) :
+                    { symbol: e.identifier, moduleImport: null };
+                var importNamespace = namedImport.moduleImport ? namedImport.moduleImport + "." : '';
+                var exportStr = "\nexports." + e.identifier + " = " + importNamespace + namedImport.symbol + ";";
+                output.append(exportStr);
+            });
+        };
+        CommonJsRenderingFormatter.prototype.findEndOfImports = function (sf) {
+            var e_1, _a;
+            try {
+                for (var _b = tslib_1.__values(sf.statements), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var statement = _c.value;
+                    if (ts.isExpressionStatement(statement) && commonjs_host_1.isRequireCall(statement.expression)) {
+                        continue;
+                    }
+                    var declarations = ts.isVariableStatement(statement) ?
+                        Array.from(statement.declarationList.declarations) :
+                        [];
+                    if (declarations.some(function (d) { return !d.initializer || !commonjs_host_1.isRequireCall(d.initializer); })) {
+                        return statement.getStart();
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return 0;
+        };
+        return CommonJsRenderingFormatter;
+    }(esm5_rendering_formatter_1.Esm5RenderingFormatter));
+    exports.CommonJsRenderingFormatter = CommonJsRenderingFormatter;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/rendering/dts_renderer.d.ts

@@ -0,0 +1,51 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/dts_renderer" />
+import * as ts from 'typescript';
+import { DecorationAnalyses } from '../analysis/decoration_analyzer';
+import { ModuleWithProvidersInfo, ModuleWithProvidersAnalyses } from '../analysis/module_with_providers_analyzer';
+import { PrivateDeclarationsAnalyses, ExportInfo } from '../analysis/private_declarations_analyzer';
+import { FileSystem } from '../file_system/file_system';
+import { NgccReflectionHost } from '../host/ngcc_host';
+import { EntryPointBundle } from '../packages/entry_point_bundle';
+import { Logger } from '../logging/logger';
+import { FileToWrite } from './utils';
+import { RenderingFormatter } from './rendering_formatter';
+import { CompileResult } from '@angular/compiler-cli/src/ngtsc/transform';
+/**
+ * A structure that captures information about what needs to be rendered
+ * in a typings file.
+ *
+ * It is created as a result of processing the analysis passed to the renderer.
+ *
+ * The `renderDtsFile()` method consumes it when rendering a typings file.
+ */
+declare class DtsRenderInfo {
+    classInfo: DtsClassInfo[];
+    moduleWithProviders: ModuleWithProvidersInfo[];
+    privateExports: ExportInfo[];
+}
+/**
+ * Information about a class in a typings file.
+ */
+export interface DtsClassInfo {
+    dtsDeclaration: ts.Declaration;
+    compilation: CompileResult[];
+}
+/**
+ * A base-class for rendering an `AnalyzedFile`.
+ *
+ * Package formats have output files that must be rendered differently. Concrete sub-classes must
+ * implement the `addImports`, `addDefinitions` and `removeDecorators` abstract methods.
+ */
+export declare class DtsRenderer {
+    private dtsFormatter;
+    private fs;
+    private logger;
+    private host;
+    private isCore;
+    private bundle;
+    constructor(dtsFormatter: RenderingFormatter, fs: FileSystem, logger: Logger, host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle);
+    renderProgram(decorationAnalyses: DecorationAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses, moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses | null): FileToWrite[];
+    renderDtsFile(dtsFile: ts.SourceFile, renderInfo: DtsRenderInfo): FileToWrite[];
+    private getTypingsFilesToRender;
+}
+export {};

package/ngcc/src/rendering/dts_renderer.js

@@ -0,0 +1,135 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/ngcc/src/rendering/dts_renderer", ["require", "exports", "tslib", "magic-string", "typescript", "@angular/compiler-cli/src/ngtsc/translator", "@angular/compiler-cli/ngcc/src/constants", "@angular/compiler-cli/ngcc/src/rendering/utils", "@angular/compiler-cli/ngcc/src/rendering/source_maps"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * @license
+     * Copyright Google Inc. All Rights Reserved.
+     *
+     * Use of this source code is governed by an MIT-style license that can be
+     * found in the LICENSE file at https://angular.io/license
+     */
+    var magic_string_1 = require("magic-string");
+    var ts = require("typescript");
+    var translator_1 = require("@angular/compiler-cli/src/ngtsc/translator");
+    var constants_1 = require("@angular/compiler-cli/ngcc/src/constants");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/rendering/utils");
+    var source_maps_1 = require("@angular/compiler-cli/ngcc/src/rendering/source_maps");
+    /**
+     * A structure that captures information about what needs to be rendered
+     * in a typings file.
+     *
+     * It is created as a result of processing the analysis passed to the renderer.
+     *
+     * The `renderDtsFile()` method consumes it when rendering a typings file.
+     */
+    var DtsRenderInfo = /** @class */ (function () {
+        function DtsRenderInfo() {
+            this.classInfo = [];
+            this.moduleWithProviders = [];
+            this.privateExports = [];
+        }
+        return DtsRenderInfo;
+    }());
+    /**
+     * A base-class for rendering an `AnalyzedFile`.
+     *
+     * Package formats have output files that must be rendered differently. Concrete sub-classes must
+     * implement the `addImports`, `addDefinitions` and `removeDecorators` abstract methods.
+     */
+    var DtsRenderer = /** @class */ (function () {
+        function DtsRenderer(dtsFormatter, fs, logger, host, isCore, bundle) {
+            this.dtsFormatter = dtsFormatter;
+            this.fs = fs;
+            this.logger = logger;
+            this.host = host;
+            this.isCore = isCore;
+            this.bundle = bundle;
+        }
+        DtsRenderer.prototype.renderProgram = function (decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses) {
+            var _this = this;
+            var renderedFiles = [];
+            // Transform the .d.ts files
+            if (this.bundle.dts) {
+                var dtsFiles = this.getTypingsFilesToRender(decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses);
+                // If the dts entry-point is not already there (it did not have compiled classes)
+                // then add it now, to ensure it gets its extra exports rendered.
+                if (!dtsFiles.has(this.bundle.dts.file)) {
+                    dtsFiles.set(this.bundle.dts.file, new DtsRenderInfo());
+                }
+                dtsFiles.forEach(function (renderInfo, file) { return renderedFiles.push.apply(renderedFiles, tslib_1.__spread(_this.renderDtsFile(file, renderInfo))); });
+            }
+            return renderedFiles;
+        };
+        DtsRenderer.prototype.renderDtsFile = function (dtsFile, renderInfo) {
+            var input = source_maps_1.extractSourceMap(this.fs, this.logger, dtsFile);
+            var outputText = new magic_string_1.default(input.source);
+            var printer = ts.createPrinter();
+            var importManager = new translator_1.ImportManager(utils_1.getImportRewriter(this.bundle.dts.r3SymbolsFile, this.isCore, false), constants_1.IMPORT_PREFIX);
+            renderInfo.classInfo.forEach(function (dtsClass) {
+                var endOfClass = dtsClass.dtsDeclaration.getEnd();
+                dtsClass.compilation.forEach(function (declaration) {
+                    var type = translator_1.translateType(declaration.type, importManager);
+                    var typeStr = printer.printNode(ts.EmitHint.Unspecified, type, dtsFile);
+                    var newStatement = "    static " + declaration.name + ": " + typeStr + ";\n";
+                    outputText.appendRight(endOfClass - 1, newStatement);
+                });
+            });
+            this.dtsFormatter.addModuleWithProvidersParams(outputText, renderInfo.moduleWithProviders, importManager);
+            this.dtsFormatter.addExports(outputText, dtsFile.fileName, renderInfo.privateExports, importManager, dtsFile);
+            this.dtsFormatter.addImports(outputText, importManager.getAllImports(dtsFile.fileName), dtsFile);
+            return source_maps_1.renderSourceAndMap(dtsFile, input, outputText);
+        };
+        DtsRenderer.prototype.getTypingsFilesToRender = function (decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses) {
+            var _this = this;
+            var dtsMap = new Map();
+            // Capture the rendering info from the decoration analyses
+            decorationAnalyses.forEach(function (compiledFile) {
+                compiledFile.compiledClasses.forEach(function (compiledClass) {
+                    var dtsDeclaration = _this.host.getDtsDeclaration(compiledClass.declaration);
+                    if (dtsDeclaration) {
+                        var dtsFile = dtsDeclaration.getSourceFile();
+                        var renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) : new DtsRenderInfo();
+                        renderInfo.classInfo.push({ dtsDeclaration: dtsDeclaration, compilation: compiledClass.compilation });
+                        dtsMap.set(dtsFile, renderInfo);
+                    }
+                });
+            });
+            // Capture the ModuleWithProviders functions/methods that need updating
+            if (moduleWithProvidersAnalyses !== null) {
+                moduleWithProvidersAnalyses.forEach(function (moduleWithProvidersToFix, dtsFile) {
+                    var renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) : new DtsRenderInfo();
+                    renderInfo.moduleWithProviders = moduleWithProvidersToFix;
+                    dtsMap.set(dtsFile, renderInfo);
+                });
+            }
+            // Capture the private declarations that need to be re-exported
+            if (privateDeclarationsAnalyses.length) {
+                privateDeclarationsAnalyses.forEach(function (e) {
+                    if (!e.dtsFrom && !e.alias) {
+                        throw new Error("There is no typings path for " + e.identifier + " in " + e.from + ".\n" +
+                            "We need to add an export for this class to a .d.ts typings file because " +
+                            "Angular compiler needs to be able to reference this class in compiled code, such as templates.\n" +
+                            "The simplest fix for this is to ensure that this class is exported from the package's entry-point.");
+                    }
+                });
+                var dtsEntryPoint = this.bundle.dts.file;
+                var renderInfo = dtsMap.has(dtsEntryPoint) ? dtsMap.get(dtsEntryPoint) : new DtsRenderInfo();
+                renderInfo.privateExports = privateDeclarationsAnalyses;
+                dtsMap.set(dtsEntryPoint, renderInfo);
+            }
+            return dtsMap;
+        };
+        return DtsRenderer;
+    }());
+    exports.DtsRenderer = DtsRenderer;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dts_renderer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/rendering/dts_renderer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport MagicString from 'magic-string';\nimport * as ts from 'typescript';\n\nimport {translateType, ImportManager} from '../../../src/ngtsc/translator';\nimport {DecorationAnalyses} from '../analysis/decoration_analyzer';\nimport {ModuleWithProvidersInfo, ModuleWithProvidersAnalyses} from '../analysis/module_with_providers_analyzer';\nimport {PrivateDeclarationsAnalyses, ExportInfo} from '../analysis/private_declarations_analyzer';\nimport {IMPORT_PREFIX} from '../constants';\nimport {FileSystem} from '../file_system/file_system';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {EntryPointBundle} from '../packages/entry_point_bundle';\nimport {Logger} from '../logging/logger';\nimport {FileToWrite, getImportRewriter} from './utils';\nimport {RenderingFormatter} from './rendering_formatter';\nimport {extractSourceMap, renderSourceAndMap} from './source_maps';\nimport {CompileResult} from '@angular/compiler-cli/src/ngtsc/transform';\n\n/**\n * A structure that captures information about what needs to be rendered\n * in a typings file.\n *\n * It is created as a result of processing the analysis passed to the renderer.\n *\n * The `renderDtsFile()` method consumes it when rendering a typings file.\n */\nclass DtsRenderInfo {\n  classInfo: DtsClassInfo[] = [];\n  moduleWithProviders: ModuleWithProvidersInfo[] = [];\n  privateExports: ExportInfo[] = [];\n}\n\n\n/**\n * Information about a class in a typings file.\n */\nexport interface DtsClassInfo {\n  dtsDeclaration: ts.Declaration;\n  compilation: CompileResult[];\n}\n\n/**\n * A base-class for rendering an `AnalyzedFile`.\n *\n * Package formats have output files that must be rendered differently. Concrete sub-classes must\n * implement the `addImports`, `addDefinitions` and `removeDecorators` abstract methods.\n */\nexport class DtsRenderer {\n  constructor(\n      private dtsFormatter: RenderingFormatter, private fs: FileSystem, private logger: Logger,\n      private host: NgccReflectionHost, private isCore: boolean, private bundle: EntryPointBundle) {\n  }\n\n  renderProgram(\n      decorationAnalyses: DecorationAnalyses,\n      privateDeclarationsAnalyses: PrivateDeclarationsAnalyses,\n      moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses|null): FileToWrite[] {\n    const renderedFiles: FileToWrite[] = [];\n\n    // Transform the .d.ts files\n    if (this.bundle.dts) {\n      const dtsFiles = this.getTypingsFilesToRender(\n          decorationAnalyses, privateDeclarationsAnalyses, moduleWithProvidersAnalyses);\n\n      // If the dts entry-point is not already there (it did not have compiled classes)\n      // then add it now, to ensure it gets its extra exports rendered.\n      if (!dtsFiles.has(this.bundle.dts.file)) {\n        dtsFiles.set(this.bundle.dts.file, new DtsRenderInfo());\n      }\n      dtsFiles.forEach(\n          (renderInfo, file) => renderedFiles.push(...this.renderDtsFile(file, renderInfo)));\n    }\n\n    return renderedFiles;\n  }\n\n  renderDtsFile(dtsFile: ts.SourceFile, renderInfo: DtsRenderInfo): FileToWrite[] {\n    const input = extractSourceMap(this.fs, this.logger, dtsFile);\n    const outputText = new MagicString(input.source);\n    const printer = ts.createPrinter();\n    const importManager = new ImportManager(\n        getImportRewriter(this.bundle.dts !.r3SymbolsFile, this.isCore, false), IMPORT_PREFIX);\n\n    renderInfo.classInfo.forEach(dtsClass => {\n      const endOfClass = dtsClass.dtsDeclaration.getEnd();\n      dtsClass.compilation.forEach(declaration => {\n        const type = translateType(declaration.type, importManager);\n        const typeStr = printer.printNode(ts.EmitHint.Unspecified, type, dtsFile);\n        const newStatement = `    static ${declaration.name}: ${typeStr};\\n`;\n        outputText.appendRight(endOfClass - 1, newStatement);\n      });\n    });\n\n    this.dtsFormatter.addModuleWithProvidersParams(\n        outputText, renderInfo.moduleWithProviders, importManager);\n    this.dtsFormatter.addExports(\n        outputText, dtsFile.fileName, renderInfo.privateExports, importManager, dtsFile);\n    this.dtsFormatter.addImports(\n        outputText, importManager.getAllImports(dtsFile.fileName), dtsFile);\n\n\n\n    return renderSourceAndMap(dtsFile, input, outputText);\n  }\n\n  private getTypingsFilesToRender(\n      decorationAnalyses: DecorationAnalyses,\n      privateDeclarationsAnalyses: PrivateDeclarationsAnalyses,\n      moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses|\n      null): Map<ts.SourceFile, DtsRenderInfo> {\n    const dtsMap = new Map<ts.SourceFile, DtsRenderInfo>();\n\n    // Capture the rendering info from the decoration analyses\n    decorationAnalyses.forEach(compiledFile => {\n      compiledFile.compiledClasses.forEach(compiledClass => {\n        const dtsDeclaration = this.host.getDtsDeclaration(compiledClass.declaration);\n        if (dtsDeclaration) {\n          const dtsFile = dtsDeclaration.getSourceFile();\n          const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) ! : new DtsRenderInfo();\n          renderInfo.classInfo.push({dtsDeclaration, compilation: compiledClass.compilation});\n          dtsMap.set(dtsFile, renderInfo);\n        }\n      });\n    });\n\n    // Capture the ModuleWithProviders functions/methods that need updating\n    if (moduleWithProvidersAnalyses !== null) {\n      moduleWithProvidersAnalyses.forEach((moduleWithProvidersToFix, dtsFile) => {\n        const renderInfo = dtsMap.has(dtsFile) ? dtsMap.get(dtsFile) ! : new DtsRenderInfo();\n        renderInfo.moduleWithProviders = moduleWithProvidersToFix;\n        dtsMap.set(dtsFile, renderInfo);\n      });\n    }\n\n    // Capture the private declarations that need to be re-exported\n    if (privateDeclarationsAnalyses.length) {\n      privateDeclarationsAnalyses.forEach(e => {\n        if (!e.dtsFrom && !e.alias) {\n          throw new Error(\n              `There is no typings path for ${e.identifier} in ${e.from}.\\n` +\n              `We need to add an export for this class to a .d.ts typings file because ` +\n              `Angular compiler needs to be able to reference this class in compiled code, such as templates.\\n` +\n              `The simplest fix for this is to ensure that this class is exported from the package's entry-point.`);\n        }\n      });\n      const dtsEntryPoint = this.bundle.dts !.file;\n      const renderInfo =\n          dtsMap.has(dtsEntryPoint) ? dtsMap.get(dtsEntryPoint) ! : new DtsRenderInfo();\n      renderInfo.privateExports = privateDeclarationsAnalyses;\n      dtsMap.set(dtsEntryPoint, renderInfo);\n    }\n\n    return dtsMap;\n  }\n}\n"]}

package/ngcc/src/rendering/esm5_rendering_formatter.d.ts

@@ -0,0 +1,21 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter" />
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import MagicString from 'magic-string';
+import { CompiledClass } from '../analysis/decoration_analyzer';
+import { EsmRenderingFormatter } from './esm_rendering_formatter';
+/**
+ * A RenderingFormatter that works with files that use ECMAScript Module `import` and `export`
+ * statements, but instead of `class` declarations it uses ES5 `function` wrappers for classes.
+ */
+export declare class Esm5RenderingFormatter extends EsmRenderingFormatter {
+    /**
+     * Add the definitions inside the IIFE of each decorated class
+     */
+    addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void;
+}

package/ngcc/src/rendering/esm5_rendering_formatter.js

@@ -0,0 +1,44 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/ngcc/src/rendering/esm5_rendering_formatter", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/ngcc/src/host/esm5_host", "@angular/compiler-cli/ngcc/src/rendering/esm_rendering_formatter"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var ts = require("typescript");
+    var esm5_host_1 = require("@angular/compiler-cli/ngcc/src/host/esm5_host");
+    var esm_rendering_formatter_1 = require("@angular/compiler-cli/ngcc/src/rendering/esm_rendering_formatter");
+    /**
+     * A RenderingFormatter that works with files that use ECMAScript Module `import` and `export`
+     * statements, but instead of `class` declarations it uses ES5 `function` wrappers for classes.
+     */
+    var Esm5RenderingFormatter = /** @class */ (function (_super) {
+        tslib_1.__extends(Esm5RenderingFormatter, _super);
+        function Esm5RenderingFormatter() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        /**
+         * Add the definitions inside the IIFE of each decorated class
+         */
+        Esm5RenderingFormatter.prototype.addDefinitions = function (output, compiledClass, definitions) {
+            var iifeBody = esm5_host_1.getIifeBody(compiledClass.declaration);
+            if (!iifeBody) {
+                throw new Error("Compiled class declaration is not inside an IIFE: " + compiledClass.name + " in " + compiledClass.declaration.getSourceFile().fileName);
+            }
+            var returnStatement = iifeBody.statements.find(ts.isReturnStatement);
+            if (!returnStatement) {
+                throw new Error("Compiled class wrapper IIFE does not have a return statement: " + compiledClass.name + " in " + compiledClass.declaration.getSourceFile().fileName);
+            }
+            var insertionPoint = returnStatement.getFullStart();
+            output.appendLeft(insertionPoint, '\n' + definitions);
+        };
+        return Esm5RenderingFormatter;
+    }(esm_rendering_formatter_1.EsmRenderingFormatter));
+    exports.Esm5RenderingFormatter = Esm5RenderingFormatter;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/rendering/esm_rendering_formatter.d.ts

@@ -0,0 +1,63 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/esm_rendering_formatter" />
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import MagicString from 'magic-string';
+import * as ts from 'typescript';
+import { AbsoluteFsPath } from '../../../src/ngtsc/path';
+import { Import, ImportManager } from '../../../src/ngtsc/translator';
+import { CompiledClass } from '../analysis/decoration_analyzer';
+import { NgccReflectionHost, SwitchableVariableDeclaration } from '../host/ngcc_host';
+import { ModuleWithProvidersInfo } from '../analysis/module_with_providers_analyzer';
+import { ExportInfo } from '../analysis/private_declarations_analyzer';
+import { RenderingFormatter, RedundantDecoratorMap } from './rendering_formatter';
+/**
+ * A RenderingFormatter that works with ECMAScript Module import and export statements.
+ */
+export declare class EsmRenderingFormatter implements RenderingFormatter {
+    protected host: NgccReflectionHost;
+    protected isCore: boolean;
+    constructor(host: NgccReflectionHost, isCore: boolean);
+    /**
+     *  Add the imports at the top of the file, after any imports that are already there.
+     */
+    addImports(output: MagicString, imports: Import[], sf: ts.SourceFile): void;
+    /**
+     * Add the exports to the end of the file.
+     */
+    addExports(output: MagicString, entryPointBasePath: AbsoluteFsPath, exports: ExportInfo[], importManager: ImportManager, file: ts.SourceFile): void;
+    /**
+     * Add the constants directly after the imports.
+     */
+    addConstants(output: MagicString, constants: string, file: ts.SourceFile): void;
+    /**
+     * Add the definitions directly after their decorated class.
+     */
+    addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void;
+    /**
+     * Remove static decorator properties from classes.
+     */
+    removeDecorators(output: MagicString, decoratorsToRemove: RedundantDecoratorMap): void;
+    /**
+     * Rewrite the the IVY switch markers to indicate we are in IVY mode.
+     */
+    rewriteSwitchableDeclarations(outputText: MagicString, sourceFile: ts.SourceFile, declarations: SwitchableVariableDeclaration[]): void;
+    /**
+     * Add the type parameters to the appropriate functions that return `ModuleWithProviders`
+     * structures.
+     *
+     * This function will only get called on typings files.
+     */
+    addModuleWithProvidersParams(outputText: MagicString, moduleWithProviders: ModuleWithProvidersInfo[], importManager: ImportManager): void;
+    protected findEndOfImports(sf: ts.SourceFile): number;
+    /**
+     * Check whether the given type is the core Angular `ModuleWithProviders` interface.
+     * @param typeName The type to check.
+     * @returns true if the type is the core Angular `ModuleWithProviders` interface.
+     */
+    private isCoreModuleWithProvidersType;
+}