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

package/ngcc/src/rendering/esm_rendering_formatter.js

@@ -0,0 +1,202 @@
+(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/esm_rendering_formatter", ["require", "exports", "tslib", "typescript", "@angular/compiler-cli/src/ngtsc/path", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/ngcc/src/host/ngcc_host", "@angular/compiler-cli/ngcc/src/rendering/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var ts = require("typescript");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
+    var ngcc_host_1 = require("@angular/compiler-cli/ngcc/src/host/ngcc_host");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/rendering/utils");
+    /**
+     * A RenderingFormatter that works with ECMAScript Module import and export statements.
+     */
+    var EsmRenderingFormatter = /** @class */ (function () {
+        function EsmRenderingFormatter(host, isCore) {
+            this.host = host;
+            this.isCore = isCore;
+        }
+        /**
+         *  Add the imports at the top of the file, after any imports that are already there.
+         */
+        EsmRenderingFormatter.prototype.addImports = function (output, imports, sf) {
+            var insertionPoint = this.findEndOfImports(sf);
+            var renderedImports = imports.map(function (i) { return "import * as " + i.qualifier + " from '" + i.specifier + "';\n"; }).join('');
+            output.appendLeft(insertionPoint, renderedImports);
+        };
+        /**
+         * Add the exports to the end of the file.
+         */
+        EsmRenderingFormatter.prototype.addExports = function (output, entryPointBasePath, exports, importManager, file) {
+            exports.forEach(function (e) {
+                var exportFrom = '';
+                var isDtsFile = typescript_1.isDtsPath(entryPointBasePath);
+                var from = isDtsFile ? e.dtsFrom : e.from;
+                if (from) {
+                    var basePath = utils_1.stripExtension(from);
+                    var relativePath = './' + path_1.PathSegment.relative(path_1.AbsoluteFsPath.dirname(entryPointBasePath), basePath);
+                    exportFrom = entryPointBasePath !== basePath ? " from '" + relativePath + "'" : '';
+                }
+                // aliases should only be added in dts files as these are lost when rolling up dts file.
+                var exportStatement = e.alias && isDtsFile ? e.alias + " as " + e.identifier : e.identifier;
+                var exportStr = "\nexport {" + exportStatement + "}" + exportFrom + ";";
+                output.append(exportStr);
+            });
+        };
+        /**
+         * Add the constants directly after the imports.
+         */
+        EsmRenderingFormatter.prototype.addConstants = function (output, constants, file) {
+            if (constants === '') {
+                return;
+            }
+            var insertionPoint = this.findEndOfImports(file);
+            // Append the constants to the right of the insertion point, to ensure they get ordered after
+            // added imports (those are appended left to the insertion point).
+            output.appendRight(insertionPoint, '\n' + constants + '\n');
+        };
+        /**
+         * Add the definitions directly after their decorated class.
+         */
+        EsmRenderingFormatter.prototype.addDefinitions = function (output, compiledClass, definitions) {
+            var classSymbol = this.host.getClassSymbol(compiledClass.declaration);
+            if (!classSymbol) {
+                throw new Error("Compiled class does not have a valid symbol: " + compiledClass.name);
+            }
+            var insertionPoint = classSymbol.valueDeclaration.getEnd();
+            output.appendLeft(insertionPoint, '\n' + definitions);
+        };
+        /**
+         * Remove static decorator properties from classes.
+         */
+        EsmRenderingFormatter.prototype.removeDecorators = function (output, decoratorsToRemove) {
+            decoratorsToRemove.forEach(function (nodesToRemove, containerNode) {
+                if (ts.isArrayLiteralExpression(containerNode)) {
+                    var items = containerNode.elements;
+                    if (items.length === nodesToRemove.length) {
+                        // Remove the entire statement
+                        var statement = findStatement(containerNode);
+                        if (statement) {
+                            output.remove(statement.getFullStart(), statement.getEnd());
+                        }
+                    }
+                    else {
+                        nodesToRemove.forEach(function (node) {
+                            // remove any trailing comma
+                            var end = (output.slice(node.getEnd(), node.getEnd() + 1) === ',') ?
+                                node.getEnd() + 1 :
+                                node.getEnd();
+                            output.remove(node.getFullStart(), end);
+                        });
+                    }
+                }
+            });
+        };
+        /**
+         * Rewrite the the IVY switch markers to indicate we are in IVY mode.
+         */
+        EsmRenderingFormatter.prototype.rewriteSwitchableDeclarations = function (outputText, sourceFile, declarations) {
+            declarations.forEach(function (declaration) {
+                var start = declaration.initializer.getStart();
+                var end = declaration.initializer.getEnd();
+                var replacement = declaration.initializer.text.replace(ngcc_host_1.PRE_R3_MARKER, ngcc_host_1.POST_R3_MARKER);
+                outputText.overwrite(start, end, replacement);
+            });
+        };
+        /**
+         * Add the type parameters to the appropriate functions that return `ModuleWithProviders`
+         * structures.
+         *
+         * This function will only get called on typings files.
+         */
+        EsmRenderingFormatter.prototype.addModuleWithProvidersParams = function (outputText, moduleWithProviders, importManager) {
+            var _this = this;
+            moduleWithProviders.forEach(function (info) {
+                var ngModuleName = info.ngModule.node.name.text;
+                var declarationFile = path_1.AbsoluteFsPath.fromSourceFile(info.declaration.getSourceFile());
+                var ngModuleFile = path_1.AbsoluteFsPath.fromSourceFile(info.ngModule.node.getSourceFile());
+                var importPath = info.ngModule.viaModule ||
+                    (declarationFile !== ngModuleFile ?
+                        utils_1.stripExtension("./" + path_1.PathSegment.relative(path_1.AbsoluteFsPath.dirname(declarationFile), ngModuleFile)) :
+                        null);
+                var ngModule = generateImportString(importManager, importPath, ngModuleName);
+                if (info.declaration.type) {
+                    var typeName = info.declaration.type && ts.isTypeReferenceNode(info.declaration.type) ?
+                        info.declaration.type.typeName :
+                        null;
+                    if (_this.isCoreModuleWithProvidersType(typeName)) {
+                        // The declaration already returns `ModuleWithProvider` but it needs the `NgModule` type
+                        // parameter adding.
+                        outputText.overwrite(info.declaration.type.getStart(), info.declaration.type.getEnd(), "ModuleWithProviders<" + ngModule + ">");
+                    }
+                    else {
+                        // The declaration returns an unknown type so we need to convert it to a union that
+                        // includes the ngModule property.
+                        var originalTypeString = info.declaration.type.getText();
+                        outputText.overwrite(info.declaration.type.getStart(), info.declaration.type.getEnd(), "(" + originalTypeString + ")&{ngModule:" + ngModule + "}");
+                    }
+                }
+                else {
+                    // The declaration has no return type so provide one.
+                    var lastToken = info.declaration.getLastToken();
+                    var insertPoint = lastToken && lastToken.kind === ts.SyntaxKind.SemicolonToken ?
+                        lastToken.getStart() :
+                        info.declaration.getEnd();
+                    outputText.appendLeft(insertPoint, ": " + generateImportString(importManager, '@angular/core', 'ModuleWithProviders') + "<" + ngModule + ">");
+                }
+            });
+        };
+        EsmRenderingFormatter.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 stmt = _c.value;
+                    if (!ts.isImportDeclaration(stmt) && !ts.isImportEqualsDeclaration(stmt) &&
+                        !ts.isNamespaceImport(stmt)) {
+                        return stmt.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;
+        };
+        /**
+         * 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.
+         */
+        EsmRenderingFormatter.prototype.isCoreModuleWithProvidersType = function (typeName) {
+            var id = typeName && ts.isIdentifier(typeName) ? this.host.getImportOfIdentifier(typeName) : null;
+            return (id && id.name === 'ModuleWithProviders' && (this.isCore || id.from === '@angular/core'));
+        };
+        return EsmRenderingFormatter;
+    }());
+    exports.EsmRenderingFormatter = EsmRenderingFormatter;
+    function findStatement(node) {
+        while (node) {
+            if (ts.isExpressionStatement(node)) {
+                return node;
+            }
+            node = node.parent;
+        }
+        return undefined;
+    }
+    function generateImportString(importManager, importPath, importName) {
+        var importAs = importPath ? importManager.generateNamedImport(importPath, importName) : null;
+        return importAs ? importAs.moduleImport + "." + importAs.symbol : "" + importName;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"esm_rendering_formatter.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/rendering/esm_rendering_formatter.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';\nimport {PathSegment, AbsoluteFsPath} from '../../../src/ngtsc/path';\nimport {Import, ImportManager} from '../../../src/ngtsc/translator';\nimport {isDtsPath} from '../../../src/ngtsc/util/src/typescript';\nimport {CompiledClass} from '../analysis/decoration_analyzer';\nimport {NgccReflectionHost, POST_R3_MARKER, PRE_R3_MARKER, SwitchableVariableDeclaration} from '../host/ngcc_host';\nimport {ModuleWithProvidersInfo} from '../analysis/module_with_providers_analyzer';\nimport {ExportInfo} from '../analysis/private_declarations_analyzer';\nimport {RenderingFormatter, RedundantDecoratorMap} from './rendering_formatter';\nimport {stripExtension} from './utils';\n\n/**\n * A RenderingFormatter that works with ECMAScript Module import and export statements.\n */\nexport class EsmRenderingFormatter implements RenderingFormatter {\n  constructor(protected host: NgccReflectionHost, protected isCore: boolean) {}\n\n  /**\n   *  Add the imports at the top of the file, after any imports that are already there.\n   */\n  addImports(output: MagicString, imports: Import[], sf: ts.SourceFile): void {\n    const insertionPoint = this.findEndOfImports(sf);\n    const renderedImports =\n        imports.map(i => `import * as ${i.qualifier} from '${i.specifier}';\\n`).join('');\n    output.appendLeft(insertionPoint, renderedImports);\n  }\n\n  /**\n   * Add the exports to the end of the file.\n   */\n  addExports(\n      output: MagicString, entryPointBasePath: AbsoluteFsPath, exports: ExportInfo[],\n      importManager: ImportManager, file: ts.SourceFile): void {\n    exports.forEach(e => {\n      let exportFrom = '';\n      const isDtsFile = isDtsPath(entryPointBasePath);\n      const from = isDtsFile ? e.dtsFrom : e.from;\n\n      if (from) {\n        const basePath = stripExtension(from);\n        const relativePath =\n            './' + PathSegment.relative(AbsoluteFsPath.dirname(entryPointBasePath), basePath);\n        exportFrom = entryPointBasePath !== basePath ? ` from '${relativePath}'` : '';\n      }\n\n      // aliases should only be added in dts files as these are lost when rolling up dts file.\n      const exportStatement = e.alias && isDtsFile ? `${e.alias} as ${e.identifier}` : e.identifier;\n      const exportStr = `\\nexport {${exportStatement}}${exportFrom};`;\n      output.append(exportStr);\n    });\n  }\n\n  /**\n   * Add the constants directly after the imports.\n   */\n  addConstants(output: MagicString, constants: string, file: ts.SourceFile): void {\n    if (constants === '') {\n      return;\n    }\n    const insertionPoint = this.findEndOfImports(file);\n\n    // Append the constants to the right of the insertion point, to ensure they get ordered after\n    // added imports (those are appended left to the insertion point).\n    output.appendRight(insertionPoint, '\\n' + constants + '\\n');\n  }\n\n  /**\n   * Add the definitions directly after their decorated class.\n   */\n  addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void {\n    const classSymbol = this.host.getClassSymbol(compiledClass.declaration);\n    if (!classSymbol) {\n      throw new Error(`Compiled class does not have a valid symbol: ${compiledClass.name}`);\n    }\n    const insertionPoint = classSymbol.valueDeclaration !.getEnd();\n    output.appendLeft(insertionPoint, '\\n' + definitions);\n  }\n\n  /**\n   * Remove static decorator properties from classes.\n   */\n  removeDecorators(output: MagicString, decoratorsToRemove: RedundantDecoratorMap): void {\n    decoratorsToRemove.forEach((nodesToRemove, containerNode) => {\n      if (ts.isArrayLiteralExpression(containerNode)) {\n        const items = containerNode.elements;\n        if (items.length === nodesToRemove.length) {\n          // Remove the entire statement\n          const statement = findStatement(containerNode);\n          if (statement) {\n            output.remove(statement.getFullStart(), statement.getEnd());\n          }\n        } else {\n          nodesToRemove.forEach(node => {\n            // remove any trailing comma\n            const end = (output.slice(node.getEnd(), node.getEnd() + 1) === ',') ?\n                node.getEnd() + 1 :\n                node.getEnd();\n            output.remove(node.getFullStart(), end);\n          });\n        }\n      }\n    });\n  }\n\n  /**\n   * Rewrite the the IVY switch markers to indicate we are in IVY mode.\n   */\n  rewriteSwitchableDeclarations(\n      outputText: MagicString, sourceFile: ts.SourceFile,\n      declarations: SwitchableVariableDeclaration[]): void {\n    declarations.forEach(declaration => {\n      const start = declaration.initializer.getStart();\n      const end = declaration.initializer.getEnd();\n      const replacement = declaration.initializer.text.replace(PRE_R3_MARKER, POST_R3_MARKER);\n      outputText.overwrite(start, end, replacement);\n    });\n  }\n\n\n  /**\n   * Add the type parameters to the appropriate functions that return `ModuleWithProviders`\n   * structures.\n   *\n   * This function will only get called on typings files.\n   */\n  addModuleWithProvidersParams(\n      outputText: MagicString, moduleWithProviders: ModuleWithProvidersInfo[],\n      importManager: ImportManager): void {\n    moduleWithProviders.forEach(info => {\n      const ngModuleName = info.ngModule.node.name.text;\n      const declarationFile = AbsoluteFsPath.fromSourceFile(info.declaration.getSourceFile());\n      const ngModuleFile = AbsoluteFsPath.fromSourceFile(info.ngModule.node.getSourceFile());\n      const importPath = info.ngModule.viaModule ||\n          (declarationFile !== ngModuleFile ?\n               stripExtension(\n                   `./${PathSegment.relative(AbsoluteFsPath.dirname(declarationFile), ngModuleFile)}`) :\n               null);\n      const ngModule = generateImportString(importManager, importPath, ngModuleName);\n\n      if (info.declaration.type) {\n        const typeName = info.declaration.type && ts.isTypeReferenceNode(info.declaration.type) ?\n            info.declaration.type.typeName :\n            null;\n        if (this.isCoreModuleWithProvidersType(typeName)) {\n          // The declaration already returns `ModuleWithProvider` but it needs the `NgModule` type\n          // parameter adding.\n          outputText.overwrite(\n              info.declaration.type.getStart(), info.declaration.type.getEnd(),\n              `ModuleWithProviders<${ngModule}>`);\n        } else {\n          // The declaration returns an unknown type so we need to convert it to a union that\n          // includes the ngModule property.\n          const originalTypeString = info.declaration.type.getText();\n          outputText.overwrite(\n              info.declaration.type.getStart(), info.declaration.type.getEnd(),\n              `(${originalTypeString})&{ngModule:${ngModule}}`);\n        }\n      } else {\n        // The declaration has no return type so provide one.\n        const lastToken = info.declaration.getLastToken();\n        const insertPoint = lastToken && lastToken.kind === ts.SyntaxKind.SemicolonToken ?\n            lastToken.getStart() :\n            info.declaration.getEnd();\n        outputText.appendLeft(\n            insertPoint,\n            `: ${generateImportString(importManager, '@angular/core', 'ModuleWithProviders')}<${ngModule}>`);\n      }\n    });\n  }\n\n  protected findEndOfImports(sf: ts.SourceFile): number {\n    for (const stmt of sf.statements) {\n      if (!ts.isImportDeclaration(stmt) && !ts.isImportEqualsDeclaration(stmt) &&\n          !ts.isNamespaceImport(stmt)) {\n        return stmt.getStart();\n      }\n    }\n    return 0;\n  }\n\n\n\n  /**\n   * Check whether the given type is the core Angular `ModuleWithProviders` interface.\n   * @param typeName The type to check.\n   * @returns true if the type is the core Angular `ModuleWithProviders` interface.\n   */\n  private isCoreModuleWithProvidersType(typeName: ts.EntityName|null) {\n    const id =\n        typeName && ts.isIdentifier(typeName) ? this.host.getImportOfIdentifier(typeName) : null;\n    return (\n        id && id.name === 'ModuleWithProviders' && (this.isCore || id.from === '@angular/core'));\n  }\n}\n\nfunction findStatement(node: ts.Node) {\n  while (node) {\n    if (ts.isExpressionStatement(node)) {\n      return node;\n    }\n    node = node.parent;\n  }\n  return undefined;\n}\n\nfunction generateImportString(\n    importManager: ImportManager, importPath: string | null, importName: string) {\n  const importAs = importPath ? importManager.generateNamedImport(importPath, importName) : null;\n  return importAs ? `${importAs.moduleImport}.${importAs.symbol}` : `${importName}`;\n}\n"]}

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

@@ -7,99 +7,38 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { ConstantPool } from '@angular/compiler';
-import { SourceMapConverter } from 'convert-source-map';
-import MagicString from 'magic-string';
-import { RawSourceMap } from 'source-map';
 import * as ts from 'typescript';
-import { CompileResult } from '@angular/compiler-cli/src/ngtsc/transform';
 import { ImportManager } from '../../../src/ngtsc/translator';
 import { CompiledClass, CompiledFile, DecorationAnalyses } from '../analysis/decoration_analyzer';
-import { ModuleWithProvidersInfo, ModuleWithProvidersAnalyses } from '../analysis/module_with_providers_analyzer';
-import { PrivateDeclarationsAnalyses, ExportInfo } from '../analysis/private_declarations_analyzer';
+import { PrivateDeclarationsAnalyses } from '../analysis/private_declarations_analyzer';
 import { SwitchMarkerAnalyses, SwitchMarkerAnalysis } from '../analysis/switch_marker_analyzer';
-import { NgccReflectionHost, SwitchableVariableDeclaration } from '../host/ngcc_host';
+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';
-interface SourceMapInfo {
-    source: string;
-    map: SourceMapConverter | null;
-    isInline: boolean;
-}
-/**
- * Information about a file that has been rendered.
- */
-export interface FileInfo {
-    /**
-     * Path to where the file should be written.
-     */
-    path: string;
-    /**
-     * The contents of the file to be be written.
-     */
-    contents: string;
-}
-interface DtsClassInfo {
-    dtsDeclaration: ts.Declaration;
-    compilation: CompileResult[];
-}
-/**
- * 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[];
-}
-/**
- * The collected decorators that have become redundant after the compilation
- * of Ivy static fields. The map is keyed by the container node, such that we
- * can tell if we should remove the entire decorator property
- */
-export declare type RedundantDecoratorMap = Map<ts.Node, ts.Node[]>;
-export declare const RedundantDecoratorMap: MapConstructor;
+import { FileToWrite } from './utils';
+import { RenderingFormatter } from './rendering_formatter';
 /**
  * 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 abstract class Renderer {
-    protected logger: Logger;
-    protected host: NgccReflectionHost;
-    protected isCore: boolean;
-    protected bundle: EntryPointBundle;
-    protected sourcePath: string;
-    constructor(logger: Logger, host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle, sourcePath: string);
-    renderProgram(decorationAnalyses: DecorationAnalyses, switchMarkerAnalyses: SwitchMarkerAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses, moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses | null): FileInfo[];
+export declare class Renderer {
+    private srcFormatter;
+    private fs;
+    private logger;
+    private host;
+    private isCore;
+    private bundle;
+    constructor(srcFormatter: RenderingFormatter, fs: FileSystem, logger: Logger, host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle);
+    renderProgram(decorationAnalyses: DecorationAnalyses, switchMarkerAnalyses: SwitchMarkerAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
     /**
      * Render the source code and source-map for an Analyzed file.
      * @param compiledFile The analyzed file to render.
      * @param targetPath The absolute path where the rendered file will be written.
      */
-    renderFile(sourceFile: ts.SourceFile, compiledFile: CompiledFile | undefined, switchMarkerAnalysis: SwitchMarkerAnalysis | undefined, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileInfo[];
-    renderDtsFile(dtsFile: ts.SourceFile, renderInfo: DtsRenderInfo): FileInfo[];
-    /**
-     * Add the type parameters to the appropriate functions that return `ModuleWithProviders`
-     * structures.
-     *
-     * This function only gets called on typings files, so it doesn't need different implementations
-     * for each bundle format.
-     */
-    protected addModuleWithProvidersParams(outputText: MagicString, moduleWithProviders: ModuleWithProvidersInfo[], importManager: ImportManager): void;
-    protected abstract addConstants(output: MagicString, constants: string, file: ts.SourceFile): void;
-    protected abstract addImports(output: MagicString, imports: {
-        specifier: string;
-        qualifier: string;
-    }[], sf: ts.SourceFile): void;
-    protected abstract addExports(output: MagicString, entryPointBasePath: string, exports: ExportInfo[]): void;
-    protected abstract addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void;
-    protected abstract removeDecorators(output: MagicString, decoratorsToRemove: RedundantDecoratorMap): void;
-    protected abstract rewriteSwitchableDeclarations(outputText: MagicString, sourceFile: ts.SourceFile, declarations: SwitchableVariableDeclaration[]): void;
+    renderFile(sourceFile: ts.SourceFile, compiledFile: CompiledFile | undefined, switchMarkerAnalysis: SwitchMarkerAnalysis | undefined, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
     /**
      * From the given list of classes, computes a map of decorators that should be removed.
      * The decorators to remove are keyed by their container node, such that we can tell if
@@ -107,41 +46,8 @@ export declare abstract class Renderer {
      * @param classes The list of classes that may have decorators to remove.
      * @returns A map of decorators to remove, keyed by their container node.
      */
-    protected computeDecoratorsToRemove(classes: CompiledClass[]): RedundantDecoratorMap;
-    /**
-     * Get the map from the source (note whether it is inline or external)
-     */
-    protected extractSourceMap(file: ts.SourceFile): SourceMapInfo;
-    /**
-     * Merge the input and output source-maps, replacing the source-map comment in the output file
-     * with an appropriate source-map comment pointing to the merged source-map.
-     */
-    protected renderSourceAndMap(sourceFile: ts.SourceFile, input: SourceMapInfo, output: MagicString): FileInfo[];
-    protected getTypingsFilesToRender(decorationAnalyses: DecorationAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses, moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses | null): Map<ts.SourceFile, DtsRenderInfo>;
-    /**
-     * 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;
-    private getImportRewriter;
+    private computeDecoratorsToRemove;
 }
-/**
- * Merge the two specified source-maps into a single source-map that hides the intermediate
- * source-map.
- * E.g. Consider these mappings:
- *
- * ```
- * OLD_SRC -> OLD_MAP -> INTERMEDIATE_SRC -> NEW_MAP -> NEW_SRC
- * ```
- *
- * this will be replaced with:
- *
- * ```
- * OLD_SRC -> MERGED_MAP -> NEW_SRC
- * ```
- */
-export declare function mergeSourceMaps(oldMap: RawSourceMap | null, newMap: RawSourceMap): SourceMapConverter;
 /**
  * Render the constant pool as source code for the given class.
  */
@@ -155,5 +61,3 @@ export declare function renderConstantPool(sourceFile: ts.SourceFile, constantPo
  * @param imports An object that tracks the imports that are needed by the rendered definitions.
  */
 export declare function renderDefinitions(sourceFile: ts.SourceFile, compiledClass: CompiledClass, imports: ImportManager): string;
-export declare function stripExtension(filePath: string): string;
-export {};