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

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

@@ -0,0 +1,45 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/source_maps" />
+/**
+ * @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 { SourceMapConverter } from 'convert-source-map';
+import MagicString from 'magic-string';
+import { RawSourceMap } from 'source-map';
+import * as ts from 'typescript';
+import { FileSystem } from '../file_system/file_system';
+import { Logger } from '../logging/logger';
+import { FileToWrite } from './utils';
+export interface SourceMapInfo {
+    source: string;
+    map: SourceMapConverter | null;
+    isInline: boolean;
+}
+/**
+ * Get the map from the source (note whether it is inline or external)
+ */
+export declare function extractSourceMap(fs: FileSystem, logger: Logger, 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.
+ */
+export declare function renderSourceAndMap(sourceFile: ts.SourceFile, input: SourceMapInfo, output: MagicString): FileToWrite[];
+/**
+ * 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;

package/ngcc/src/rendering/source_maps.js

@@ -0,0 +1,129 @@
+(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/source_maps", ["require", "exports", "convert-source-map", "source-map", "@angular/compiler-cli/src/ngtsc/path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @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 convert_source_map_1 = require("convert-source-map");
+    var source_map_1 = require("source-map");
+    var path_1 = require("@angular/compiler-cli/src/ngtsc/path");
+    /**
+     * Get the map from the source (note whether it is inline or external)
+     */
+    function extractSourceMap(fs, logger, file) {
+        var inline = convert_source_map_1.commentRegex.test(file.text);
+        var external = convert_source_map_1.mapFileCommentRegex.exec(file.text);
+        if (inline) {
+            var inlineSourceMap = convert_source_map_1.fromSource(file.text);
+            return {
+                source: convert_source_map_1.removeComments(file.text).replace(/\n\n$/, '\n'),
+                map: inlineSourceMap,
+                isInline: true,
+            };
+        }
+        else if (external) {
+            var externalSourceMap = null;
+            try {
+                var fileName = external[1] || external[2];
+                var filePath = path_1.AbsoluteFsPath.resolve(path_1.AbsoluteFsPath.dirname(path_1.AbsoluteFsPath.fromSourceFile(file)), fileName);
+                var mappingFile = fs.readFile(filePath);
+                externalSourceMap = convert_source_map_1.fromJSON(mappingFile);
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    logger.warn("The external map file specified in the source code comment \"" + e.path + "\" was not found on the file system.");
+                    var mapPath = path_1.AbsoluteFsPath.fromUnchecked(file.fileName + '.map');
+                    if (path_1.PathSegment.basename(e.path) !== path_1.PathSegment.basename(mapPath) && fs.exists(mapPath) &&
+                        fs.stat(mapPath).isFile()) {
+                        logger.warn("Guessing the map file name from the source file name: \"" + path_1.PathSegment.basename(mapPath) + "\"");
+                        try {
+                            externalSourceMap = convert_source_map_1.fromObject(JSON.parse(fs.readFile(mapPath)));
+                        }
+                        catch (e) {
+                            logger.error(e);
+                        }
+                    }
+                }
+            }
+            return {
+                source: convert_source_map_1.removeMapFileComments(file.text).replace(/\n\n$/, '\n'),
+                map: externalSourceMap,
+                isInline: false,
+            };
+        }
+        else {
+            return { source: file.text, map: null, isInline: false };
+        }
+    }
+    exports.extractSourceMap = extractSourceMap;
+    /**
+     * 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.
+     */
+    function renderSourceAndMap(sourceFile, input, output) {
+        var outputPath = path_1.AbsoluteFsPath.fromSourceFile(sourceFile);
+        var outputMapPath = path_1.AbsoluteFsPath.fromUnchecked(outputPath + ".map");
+        var relativeSourcePath = path_1.PathSegment.basename(outputPath);
+        var relativeMapPath = relativeSourcePath + ".map";
+        var outputMap = output.generateMap({
+            source: outputPath,
+            includeContent: true,
+        });
+        // we must set this after generation as magic string does "manipulation" on the path
+        outputMap.file = relativeSourcePath;
+        var mergedMap = mergeSourceMaps(input.map && input.map.toObject(), JSON.parse(outputMap.toString()));
+        var result = [];
+        if (input.isInline) {
+            result.push({ path: outputPath, contents: output.toString() + "\n" + mergedMap.toComment() });
+        }
+        else {
+            result.push({
+                path: outputPath,
+                contents: output.toString() + "\n" + convert_source_map_1.generateMapFileComment(relativeMapPath)
+            });
+            result.push({ path: outputMapPath, contents: mergedMap.toJSON() });
+        }
+        return result;
+    }
+    exports.renderSourceAndMap = renderSourceAndMap;
+    /**
+     * 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
+     * ```
+     */
+    function mergeSourceMaps(oldMap, newMap) {
+        if (!oldMap) {
+            return convert_source_map_1.fromObject(newMap);
+        }
+        var oldMapConsumer = new source_map_1.SourceMapConsumer(oldMap);
+        var newMapConsumer = new source_map_1.SourceMapConsumer(newMap);
+        var mergedMapGenerator = source_map_1.SourceMapGenerator.fromSourceMap(newMapConsumer);
+        mergedMapGenerator.applySourceMap(oldMapConsumer);
+        var merged = convert_source_map_1.fromJSON(mergedMapGenerator.toString());
+        return merged;
+    }
+    exports.mergeSourceMaps = mergeSourceMaps;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_maps.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/rendering/source_maps.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 {SourceMapConverter, commentRegex, fromJSON, fromObject, fromSource, generateMapFileComment, mapFileCommentRegex, removeComments, removeMapFileComments} from 'convert-source-map';\nimport MagicString from 'magic-string';\nimport {RawSourceMap, SourceMapConsumer, SourceMapGenerator} from 'source-map';\nimport * as ts from 'typescript';\nimport {AbsoluteFsPath, PathSegment} from '../../../src/ngtsc/path';\nimport {FileSystem} from '../file_system/file_system';\nimport {Logger} from '../logging/logger';\nimport {FileToWrite} from './utils';\n\nexport interface SourceMapInfo {\n  source: string;\n  map: SourceMapConverter|null;\n  isInline: boolean;\n}\n\n/**\n * Get the map from the source (note whether it is inline or external)\n */\nexport function extractSourceMap(\n    fs: FileSystem, logger: Logger, file: ts.SourceFile): SourceMapInfo {\n  const inline = commentRegex.test(file.text);\n  const external = mapFileCommentRegex.exec(file.text);\n\n  if (inline) {\n    const inlineSourceMap = fromSource(file.text);\n    return {\n      source: removeComments(file.text).replace(/\\n\\n$/, '\\n'),\n      map: inlineSourceMap,\n      isInline: true,\n    };\n  } else if (external) {\n    let externalSourceMap: SourceMapConverter|null = null;\n    try {\n      const fileName = external[1] || external[2];\n      const filePath = AbsoluteFsPath.resolve(\n          AbsoluteFsPath.dirname(AbsoluteFsPath.fromSourceFile(file)), fileName);\n      const mappingFile = fs.readFile(filePath);\n      externalSourceMap = fromJSON(mappingFile);\n    } catch (e) {\n      if (e.code === 'ENOENT') {\n        logger.warn(\n            `The external map file specified in the source code comment \"${e.path}\" was not found on the file system.`);\n        const mapPath = AbsoluteFsPath.fromUnchecked(file.fileName + '.map');\n        if (PathSegment.basename(e.path) !== PathSegment.basename(mapPath) && fs.exists(mapPath) &&\n            fs.stat(mapPath).isFile()) {\n          logger.warn(\n              `Guessing the map file name from the source file name: \"${PathSegment.basename(mapPath)}\"`);\n          try {\n            externalSourceMap = fromObject(JSON.parse(fs.readFile(mapPath)));\n          } catch (e) {\n            logger.error(e);\n          }\n        }\n      }\n    }\n    return {\n      source: removeMapFileComments(file.text).replace(/\\n\\n$/, '\\n'),\n      map: externalSourceMap,\n      isInline: false,\n    };\n  } else {\n    return {source: file.text, map: null, isInline: false};\n  }\n}\n\n/**\n * Merge the input and output source-maps, replacing the source-map comment in the output file\n * with an appropriate source-map comment pointing to the merged source-map.\n */\nexport function renderSourceAndMap(\n    sourceFile: ts.SourceFile, input: SourceMapInfo, output: MagicString): FileToWrite[] {\n  const outputPath = AbsoluteFsPath.fromSourceFile(sourceFile);\n  const outputMapPath = AbsoluteFsPath.fromUnchecked(`${outputPath}.map`);\n  const relativeSourcePath = PathSegment.basename(outputPath);\n  const relativeMapPath = `${relativeSourcePath}.map`;\n\n  const outputMap = output.generateMap({\n    source: outputPath,\n    includeContent: true,\n    // hires: true // TODO: This results in accurate but huge sourcemaps. Instead we should fix\n    // the merge algorithm.\n  });\n\n  // we must set this after generation as magic string does \"manipulation\" on the path\n  outputMap.file = relativeSourcePath;\n\n  const mergedMap =\n      mergeSourceMaps(input.map && input.map.toObject(), JSON.parse(outputMap.toString()));\n\n  const result: FileToWrite[] = [];\n  if (input.isInline) {\n    result.push({path: outputPath, contents: `${output.toString()}\\n${mergedMap.toComment()}`});\n  } else {\n    result.push({\n      path: outputPath,\n      contents: `${output.toString()}\\n${generateMapFileComment(relativeMapPath)}`\n    });\n    result.push({path: outputMapPath, contents: mergedMap.toJSON()});\n  }\n  return result;\n}\n\n\n/**\n * Merge the two specified source-maps into a single source-map that hides the intermediate\n * source-map.\n * E.g. Consider these mappings:\n *\n * ```\n * OLD_SRC -> OLD_MAP -> INTERMEDIATE_SRC -> NEW_MAP -> NEW_SRC\n * ```\n *\n * this will be replaced with:\n *\n * ```\n * OLD_SRC -> MERGED_MAP -> NEW_SRC\n * ```\n */\nexport function mergeSourceMaps(\n    oldMap: RawSourceMap | null, newMap: RawSourceMap): SourceMapConverter {\n  if (!oldMap) {\n    return fromObject(newMap);\n  }\n  const oldMapConsumer = new SourceMapConsumer(oldMap);\n  const newMapConsumer = new SourceMapConsumer(newMap);\n  const mergedMapGenerator = SourceMapGenerator.fromSourceMap(newMapConsumer);\n  mergedMapGenerator.applySourceMap(oldMapConsumer);\n  const merged = fromJSON(mergedMapGenerator.toString());\n  return merged;\n}\n"]}

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

@@ -0,0 +1,28 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/umd_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 { UmdReflectionHost } from '../host/umd_host';
+import { Esm5RenderingFormatter } from './esm5_rendering_formatter';
+/**
+ * A RenderingFormatter that works with UMD 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 UmdRenderingFormatter extends Esm5RenderingFormatter {
+    protected umdHost: UmdReflectionHost;
+    constructor(umdHost: UmdReflectionHost, isCore: boolean);
+    /**
+     *  Add the imports to the UMD module IIFE.
+     */
+    addImports(output: MagicString, imports: Import[], file: ts.SourceFile): void;
+    /**
+     * Add the exports to the bottom of the UMD module factory function.
+     */
+    addExports(output: MagicString, entryPointBasePath: string, exports: ExportInfo[], importManager: ImportManager, file: ts.SourceFile): void;
+    /**
+     * Add the constants to the top of the UMD factory function.
+     */
+    addConstants(output: MagicString, constants: string, file: ts.SourceFile): void;
+}

package/ngcc/src/rendering/umd_rendering_formatter.js

@@ -0,0 +1,222 @@
+(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/umd_rendering_formatter", ["require", "exports", "tslib", "canonical-path", "typescript", "@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 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 UMD 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 UmdRenderingFormatter = /** @class */ (function (_super) {
+        tslib_1.__extends(UmdRenderingFormatter, _super);
+        function UmdRenderingFormatter(umdHost, isCore) {
+            var _this = _super.call(this, umdHost, isCore) || this;
+            _this.umdHost = umdHost;
+            return _this;
+        }
+        /**
+         *  Add the imports to the UMD module IIFE.
+         */
+        UmdRenderingFormatter.prototype.addImports = function (output, imports, file) {
+            // Assume there is only one UMD module in the file
+            var umdModule = this.umdHost.getUmdModule(file);
+            if (!umdModule) {
+                return;
+            }
+            var wrapperFunction = umdModule.wrapperFn;
+            // We need to add new `require()` calls for each import in the CommonJS initializer
+            renderCommonJsDependencies(output, wrapperFunction, imports);
+            renderAmdDependencies(output, wrapperFunction, imports);
+            renderGlobalDependencies(output, wrapperFunction, imports);
+            renderFactoryParameters(output, wrapperFunction, imports);
+        };
+        /**
+         * Add the exports to the bottom of the UMD module factory function.
+         */
+        UmdRenderingFormatter.prototype.addExports = function (output, entryPointBasePath, exports, importManager, file) {
+            var umdModule = this.umdHost.getUmdModule(file);
+            if (!umdModule) {
+                return;
+            }
+            var factoryFunction = umdModule.factoryFn;
+            var lastStatement = factoryFunction.body.statements[factoryFunction.body.statements.length - 1];
+            var insertionPoint = lastStatement ? lastStatement.getEnd() : factoryFunction.body.getEnd() - 1;
+            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.appendRight(insertionPoint, exportStr);
+            });
+        };
+        /**
+         * Add the constants to the top of the UMD factory function.
+         */
+        UmdRenderingFormatter.prototype.addConstants = function (output, constants, file) {
+            if (constants === '') {
+                return;
+            }
+            var umdModule = this.umdHost.getUmdModule(file);
+            if (!umdModule) {
+                return;
+            }
+            var factoryFunction = umdModule.factoryFn;
+            var firstStatement = factoryFunction.body.statements[0];
+            var insertionPoint = firstStatement ? firstStatement.getStart() : factoryFunction.body.getStart() + 1;
+            output.appendLeft(insertionPoint, '\n' + constants + '\n');
+        };
+        return UmdRenderingFormatter;
+    }(esm5_rendering_formatter_1.Esm5RenderingFormatter));
+    exports.UmdRenderingFormatter = UmdRenderingFormatter;
+    /**
+     * Add dependencies to the CommonJS part of the UMD wrapper function.
+     */
+    function renderCommonJsDependencies(output, wrapperFunction, imports) {
+        var conditional = find(wrapperFunction.body.statements[0], isCommonJSConditional);
+        if (!conditional) {
+            return;
+        }
+        var factoryCall = conditional.whenTrue;
+        var injectionPoint = factoryCall.getEnd() -
+            1; // Backup one char to account for the closing parenthesis on the call
+        imports.forEach(function (i) { return output.appendLeft(injectionPoint, ",require('" + i.specifier + "')"); });
+    }
+    /**
+     * Add dependencies to the AMD part of the UMD wrapper function.
+     */
+    function renderAmdDependencies(output, wrapperFunction, imports) {
+        var conditional = find(wrapperFunction.body.statements[0], isAmdConditional);
+        if (!conditional) {
+            return;
+        }
+        var dependencyArray = conditional.whenTrue.arguments[1];
+        if (!dependencyArray || !ts.isArrayLiteralExpression(dependencyArray)) {
+            return;
+        }
+        var injectionPoint = dependencyArray.getEnd() -
+            1; // Backup one char to account for the closing square bracket on the array
+        imports.forEach(function (i) { return output.appendLeft(injectionPoint, ",'" + i.specifier + "'"); });
+    }
+    /**
+     * Add dependencies to the global part of the UMD wrapper function.
+     */
+    function renderGlobalDependencies(output, wrapperFunction, imports) {
+        var globalFactoryCall = find(wrapperFunction.body.statements[0], isGlobalFactoryCall);
+        if (!globalFactoryCall) {
+            return;
+        }
+        // Backup one char to account for the closing parenthesis after the argument list of the call.
+        var injectionPoint = globalFactoryCall.getEnd() - 1;
+        imports.forEach(function (i) { return output.appendLeft(injectionPoint, ",global." + getGlobalIdentifier(i)); });
+    }
+    /**
+     * Add dependency parameters to the UMD factory function.
+     */
+    function renderFactoryParameters(output, wrapperFunction, imports) {
+        var wrapperCall = wrapperFunction.parent;
+        var secondArgument = wrapperCall.arguments[1];
+        if (!secondArgument) {
+            return;
+        }
+        // Be resilient to the factory being inside parentheses
+        var factoryFunction = ts.isParenthesizedExpression(secondArgument) ? secondArgument.expression : secondArgument;
+        if (!ts.isFunctionExpression(factoryFunction)) {
+            return;
+        }
+        var parameters = factoryFunction.parameters;
+        var injectionPoint = parameters[parameters.length - 1].getEnd();
+        imports.forEach(function (i) { return output.appendLeft(injectionPoint, "," + i.qualifier); });
+    }
+    /**
+     * Is this node the CommonJS conditional expression in the UMD wrapper?
+     */
+    function isCommonJSConditional(value) {
+        if (!ts.isConditionalExpression(value)) {
+            return false;
+        }
+        if (!ts.isBinaryExpression(value.condition) ||
+            value.condition.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) {
+            return false;
+        }
+        if (!oneOfBinaryConditions(value.condition, function (exp) { return isTypeOf(exp, 'exports', 'module'); })) {
+            return false;
+        }
+        if (!ts.isCallExpression(value.whenTrue) || !ts.isIdentifier(value.whenTrue.expression)) {
+            return false;
+        }
+        return value.whenTrue.expression.text === 'factory';
+    }
+    /**
+     * Is this node the AMD conditional expression in the UMD wrapper?
+     */
+    function isAmdConditional(value) {
+        if (!ts.isConditionalExpression(value)) {
+            return false;
+        }
+        if (!ts.isBinaryExpression(value.condition) ||
+            value.condition.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) {
+            return false;
+        }
+        if (!oneOfBinaryConditions(value.condition, function (exp) { return isTypeOf(exp, 'define'); })) {
+            return false;
+        }
+        if (!ts.isCallExpression(value.whenTrue) || !ts.isIdentifier(value.whenTrue.expression)) {
+            return false;
+        }
+        return value.whenTrue.expression.text === 'define';
+    }
+    /**
+     * Is this node the call to setup the global dependencies in the UMD wrapper?
+     */
+    function isGlobalFactoryCall(value) {
+        if (ts.isCallExpression(value) && !!value.parent) {
+            // Be resilient to the value being inside parentheses
+            var expression = ts.isParenthesizedExpression(value.parent) ? value.parent : value;
+            return !!expression.parent && ts.isConditionalExpression(expression.parent) &&
+                expression.parent.whenFalse === expression;
+        }
+        else {
+            return false;
+        }
+    }
+    function getGlobalIdentifier(i) {
+        return i.specifier.replace('@angular/', 'ng.').replace(/^\//, '');
+    }
+    function find(node, test) {
+        return test(node) ? node : node.forEachChild(function (child) { return find(child, test); });
+    }
+    function oneOfBinaryConditions(node, test) {
+        return test(node.left) || test(node.right);
+    }
+    function isTypeOf(node) {
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        return ts.isBinaryExpression(node) && ts.isTypeOfExpression(node.left) &&
+            ts.isIdentifier(node.left.expression) && types.indexOf(node.left.expression.text) !== -1;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"umd_rendering_formatter.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/rendering/umd_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 {dirname, relative} from 'canonical-path';\nimport * as ts from 'typescript';\nimport MagicString from 'magic-string';\nimport {Import, ImportManager} from '../../../src/ngtsc/translator';\nimport {ExportInfo} from '../analysis/private_declarations_analyzer';\nimport {UmdReflectionHost} from '../host/umd_host';\nimport {Esm5RenderingFormatter} from './esm5_rendering_formatter';\nimport {stripExtension} from './utils';\n\ntype CommonJsConditional = ts.ConditionalExpression & {whenTrue: ts.CallExpression};\ntype AmdConditional = ts.ConditionalExpression & {whenTrue: ts.CallExpression};\n\n/**\n * A RenderingFormatter that works with UMD files, instead of `import` and `export` statements\n * the module is an IIFE with a factory function call with dependencies, which are defined in a\n * wrapper function for AMD, CommonJS and global module formats.\n */\nexport class UmdRenderingFormatter extends Esm5RenderingFormatter {\n  constructor(protected umdHost: UmdReflectionHost, isCore: boolean) { super(umdHost, isCore); }\n\n  /**\n   *  Add the imports to the UMD module IIFE.\n   */\n  addImports(output: MagicString, imports: Import[], file: ts.SourceFile): void {\n    // Assume there is only one UMD module in the file\n    const umdModule = this.umdHost.getUmdModule(file);\n    if (!umdModule) {\n      return;\n    }\n\n    const wrapperFunction = umdModule.wrapperFn;\n\n    // We need to add new `require()` calls for each import in the CommonJS initializer\n    renderCommonJsDependencies(output, wrapperFunction, imports);\n    renderAmdDependencies(output, wrapperFunction, imports);\n    renderGlobalDependencies(output, wrapperFunction, imports);\n    renderFactoryParameters(output, wrapperFunction, imports);\n  }\n\n  /**\n   * Add the exports to the bottom of the UMD module factory function.\n   */\n  addExports(\n      output: MagicString, entryPointBasePath: string, exports: ExportInfo[],\n      importManager: ImportManager, file: ts.SourceFile): void {\n    const umdModule = this.umdHost.getUmdModule(file);\n    if (!umdModule) {\n      return;\n    }\n    const factoryFunction = umdModule.factoryFn;\n    const lastStatement =\n        factoryFunction.body.statements[factoryFunction.body.statements.length - 1];\n    const insertionPoint =\n        lastStatement ? lastStatement.getEnd() : factoryFunction.body.getEnd() - 1;\n    exports.forEach(e => {\n      const basePath = stripExtension(e.from);\n      const relativePath = './' + relative(dirname(entryPointBasePath), basePath);\n      const namedImport = entryPointBasePath !== basePath ?\n          importManager.generateNamedImport(relativePath, e.identifier) :\n          {symbol: e.identifier, moduleImport: null};\n      const importNamespace = namedImport.moduleImport ? `${namedImport.moduleImport}.` : '';\n      const exportStr = `\\nexports.${e.identifier} = ${importNamespace}${namedImport.symbol};`;\n      output.appendRight(insertionPoint, exportStr);\n    });\n  }\n\n  /**\n   * Add the constants to the top of the UMD factory function.\n   */\n  addConstants(output: MagicString, constants: string, file: ts.SourceFile): void {\n    if (constants === '') {\n      return;\n    }\n    const umdModule = this.umdHost.getUmdModule(file);\n    if (!umdModule) {\n      return;\n    }\n    const factoryFunction = umdModule.factoryFn;\n    const firstStatement = factoryFunction.body.statements[0];\n    const insertionPoint =\n        firstStatement ? firstStatement.getStart() : factoryFunction.body.getStart() + 1;\n    output.appendLeft(insertionPoint, '\\n' + constants + '\\n');\n  }\n}\n\n/**\n * Add dependencies to the CommonJS part of the UMD wrapper function.\n */\nfunction renderCommonJsDependencies(\n    output: MagicString, wrapperFunction: ts.FunctionExpression, imports: Import[]) {\n  const conditional = find(wrapperFunction.body.statements[0], isCommonJSConditional);\n  if (!conditional) {\n    return;\n  }\n  const factoryCall = conditional.whenTrue;\n  const injectionPoint = factoryCall.getEnd() -\n      1;  // Backup one char to account for the closing parenthesis on the call\n  imports.forEach(i => output.appendLeft(injectionPoint, `,require('${i.specifier}')`));\n}\n\n/**\n * Add dependencies to the AMD part of the UMD wrapper function.\n */\nfunction renderAmdDependencies(\n    output: MagicString, wrapperFunction: ts.FunctionExpression, imports: Import[]) {\n  const conditional = find(wrapperFunction.body.statements[0], isAmdConditional);\n  if (!conditional) {\n    return;\n  }\n  const dependencyArray = conditional.whenTrue.arguments[1];\n  if (!dependencyArray || !ts.isArrayLiteralExpression(dependencyArray)) {\n    return;\n  }\n  const injectionPoint = dependencyArray.getEnd() -\n      1;  // Backup one char to account for the closing square bracket on the array\n  imports.forEach(i => output.appendLeft(injectionPoint, `,'${i.specifier}'`));\n}\n\n/**\n * Add dependencies to the global part of the UMD wrapper function.\n */\nfunction renderGlobalDependencies(\n    output: MagicString, wrapperFunction: ts.FunctionExpression, imports: Import[]) {\n  const globalFactoryCall = find(wrapperFunction.body.statements[0], isGlobalFactoryCall);\n  if (!globalFactoryCall) {\n    return;\n  }\n  // Backup one char to account for the closing parenthesis after the argument list of the call.\n  const injectionPoint = globalFactoryCall.getEnd() - 1;\n  imports.forEach(i => output.appendLeft(injectionPoint, `,global.${getGlobalIdentifier(i)}`));\n}\n\n/**\n * Add dependency parameters to the UMD factory function.\n */\nfunction renderFactoryParameters(\n    output: MagicString, wrapperFunction: ts.FunctionExpression, imports: Import[]) {\n  const wrapperCall = wrapperFunction.parent as ts.CallExpression;\n  const secondArgument = wrapperCall.arguments[1];\n  if (!secondArgument) {\n    return;\n  }\n\n  // Be resilient to the factory being inside parentheses\n  const factoryFunction =\n      ts.isParenthesizedExpression(secondArgument) ? secondArgument.expression : secondArgument;\n  if (!ts.isFunctionExpression(factoryFunction)) {\n    return;\n  }\n  const parameters = factoryFunction.parameters;\n  const injectionPoint = parameters[parameters.length - 1].getEnd();\n  imports.forEach(i => output.appendLeft(injectionPoint, `,${i.qualifier}`));\n}\n\n/**\n * Is this node the CommonJS conditional expression in the UMD wrapper?\n */\nfunction isCommonJSConditional(value: ts.Node): value is CommonJsConditional {\n  if (!ts.isConditionalExpression(value)) {\n    return false;\n  }\n  if (!ts.isBinaryExpression(value.condition) ||\n      value.condition.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) {\n    return false;\n  }\n  if (!oneOfBinaryConditions(value.condition, (exp) => isTypeOf(exp, 'exports', 'module'))) {\n    return false;\n  }\n  if (!ts.isCallExpression(value.whenTrue) || !ts.isIdentifier(value.whenTrue.expression)) {\n    return false;\n  }\n  return value.whenTrue.expression.text === 'factory';\n}\n\n/**\n * Is this node the AMD conditional expression in the UMD wrapper?\n */\nfunction isAmdConditional(value: ts.Node): value is AmdConditional {\n  if (!ts.isConditionalExpression(value)) {\n    return false;\n  }\n  if (!ts.isBinaryExpression(value.condition) ||\n      value.condition.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) {\n    return false;\n  }\n  if (!oneOfBinaryConditions(value.condition, (exp) => isTypeOf(exp, 'define'))) {\n    return false;\n  }\n  if (!ts.isCallExpression(value.whenTrue) || !ts.isIdentifier(value.whenTrue.expression)) {\n    return false;\n  }\n  return value.whenTrue.expression.text === 'define';\n}\n\n/**\n * Is this node the call to setup the global dependencies in the UMD wrapper?\n */\nfunction isGlobalFactoryCall(value: ts.Node): value is ts.CallExpression {\n  if (ts.isCallExpression(value) && !!value.parent) {\n    // Be resilient to the value being inside parentheses\n    const expression = ts.isParenthesizedExpression(value.parent) ? value.parent : value;\n    return !!expression.parent && ts.isConditionalExpression(expression.parent) &&\n        expression.parent.whenFalse === expression;\n  } else {\n    return false;\n  }\n}\n\nfunction getGlobalIdentifier(i: Import) {\n  return i.specifier.replace('@angular/', 'ng.').replace(/^\\//, '');\n}\n\nfunction find<T>(node: ts.Node, test: (node: ts.Node) => node is ts.Node & T): T|undefined {\n  return test(node) ? node : node.forEachChild(child => find<T>(child, test));\n}\n\nfunction oneOfBinaryConditions(\n    node: ts.BinaryExpression, test: (expression: ts.Expression) => boolean) {\n  return test(node.left) || test(node.right);\n}\n\nfunction isTypeOf(node: ts.Expression, ...types: string[]): boolean {\n  return ts.isBinaryExpression(node) && ts.isTypeOfExpression(node.left) &&\n      ts.isIdentifier(node.left.expression) && types.indexOf(node.left.expression.text) !== -1;\n}\n"]}

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

@@ -0,0 +1,25 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/rendering/utils" />
+/**
+ * @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 * as ts from 'typescript';
+import { ImportRewriter } from '../../../src/ngtsc/imports';
+import { AbsoluteFsPath } from '../../../src/ngtsc/path';
+/**
+ * Information about a file that has been rendered.
+ */
+export interface FileToWrite {
+    /** Path to where the file should be written. */
+    path: AbsoluteFsPath;
+    /** The contents of the file to be be written. */
+    contents: string;
+}
+/**
+ * Create an appropriate ImportRewriter given the parameters.
+ */
+export declare function getImportRewriter(r3SymbolsFile: ts.SourceFile | null, isCore: boolean, isFlat: boolean): ImportRewriter;
+export declare function stripExtension<T extends string>(filePath: T): T;

package/ngcc/src/rendering/utils.js

@@ -0,0 +1,34 @@
+(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/utils", ["require", "exports", "@angular/compiler-cli/src/ngtsc/imports", "@angular/compiler-cli/ngcc/src/rendering/ngcc_import_rewriter"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var imports_1 = require("@angular/compiler-cli/src/ngtsc/imports");
+    var ngcc_import_rewriter_1 = require("@angular/compiler-cli/ngcc/src/rendering/ngcc_import_rewriter");
+    /**
+     * Create an appropriate ImportRewriter given the parameters.
+     */
+    function getImportRewriter(r3SymbolsFile, isCore, isFlat) {
+        if (isCore && isFlat) {
+            return new ngcc_import_rewriter_1.NgccFlatImportRewriter();
+        }
+        else if (isCore) {
+            return new imports_1.R3SymbolsImportRewriter(r3SymbolsFile.fileName);
+        }
+        else {
+            return new imports_1.NoopImportRewriter();
+        }
+    }
+    exports.getImportRewriter = getImportRewriter;
+    function stripExtension(filePath) {
+        return filePath.replace(/\.(js|d\.ts)$/, '');
+    }
+    exports.stripExtension = stripExtension;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/utils.d.ts

@@ -25,3 +25,15 @@ export declare function findAll<T>(node: ts.Node, test: (node: ts.Node) => node
 export declare function hasNameIdentifier(declaration: ts.Declaration): declaration is ts.Declaration & {
     name: ts.Identifier;
 };
+export declare type PathMappings = {
+    baseUrl: string;
+    paths: {
+        [key: string]: string[];
+    };
+};
+/**
+ * Test whether a path is "relative".
+ *
+ * Relative paths start with `/`, `./` or `../`; or are simply `.` or `..`.
+ */
+export declare function isRelativePath(path: string): boolean;

package/ngcc/src/utils.js

@@ -61,5 +61,14 @@
         return namedDeclaration.name !== undefined && ts.isIdentifier(namedDeclaration.name);
     }
     exports.hasNameIdentifier = hasNameIdentifier;
+    /**
+     * Test whether a path is "relative".
+     *
+     * Relative paths start with `/`, `./` or `../`; or are simply `.` or `..`.
+     */
+    function isRelativePath(path) {
+        return /^\/|^\.\.?($|\/)/.test(path);
+    }
+    exports.isRelativePath = isRelativePath;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/writing/file_writer.d.ts

@@ -8,10 +8,10 @@
  */
 import { EntryPoint } from '../packages/entry_point';
 import { EntryPointBundle } from '../packages/entry_point_bundle';
-import { FileInfo } from '../rendering/renderer';
+import { FileToWrite } from '../rendering/utils';
 /**
  * Responsible for writing out the transformed files to disk.
  */
 export interface FileWriter {
-    writeBundle(entryPoint: EntryPoint, bundle: EntryPointBundle, transformedFiles: FileInfo[]): void;
+    writeBundle(entryPoint: EntryPoint, bundle: EntryPointBundle, transformedFiles: FileToWrite[]): void;
 }

package/ngcc/src/writing/file_writer.js

@@ -10,4 +10,4 @@
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV93cml0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvd3JpdGluZy9maWxlX3dyaXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXG4vKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge0VudHJ5UG9pbnR9IGZyb20gJy4uL3BhY2thZ2VzL2VudHJ5X3BvaW50JztcbmltcG9ydCB7RW50cnlQb2ludEJ1bmRsZX0gZnJvbSAnLi4vcGFja2FnZXMvZW50cnlfcG9pbnRfYnVuZGxlJztcbmltcG9ydCB7RmlsZUluZm99IGZyb20gJy4uL3JlbmRlcmluZy9yZW5kZXJlcic7XG5cblxuLyoqXG4gKiBSZXNwb25zaWJsZSBmb3Igd3JpdGluZyBvdXQgdGhlIHRyYW5zZm9ybWVkIGZpbGVzIHRvIGRpc2suXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmlsZVdyaXRlciB7XG4gIHdyaXRlQnVuZGxlKGVudHJ5UG9pbnQ6IEVudHJ5UG9pbnQsIGJ1bmRsZTogRW50cnlQb2ludEJ1bmRsZSwgdHJhbnNmb3JtZWRGaWxlczogRmlsZUluZm9bXSk6IHZvaWQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZV93cml0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvd3JpdGluZy9maWxlX3dyaXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXG4vKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge0VudHJ5UG9pbnR9IGZyb20gJy4uL3BhY2thZ2VzL2VudHJ5X3BvaW50JztcbmltcG9ydCB7RW50cnlQb2ludEJ1bmRsZX0gZnJvbSAnLi4vcGFja2FnZXMvZW50cnlfcG9pbnRfYnVuZGxlJztcbmltcG9ydCB7RmlsZVRvV3JpdGV9IGZyb20gJy4uL3JlbmRlcmluZy91dGlscyc7XG5cblxuLyoqXG4gKiBSZXNwb25zaWJsZSBmb3Igd3JpdGluZyBvdXQgdGhlIHRyYW5zZm9ybWVkIGZpbGVzIHRvIGRpc2suXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmlsZVdyaXRlciB7XG4gIHdyaXRlQnVuZGxlKGVudHJ5UG9pbnQ6IEVudHJ5UG9pbnQsIGJ1bmRsZTogRW50cnlQb2ludEJ1bmRsZSwgdHJhbnNmb3JtZWRGaWxlczogRmlsZVRvV3JpdGVbXSk6XG4gICAgICB2b2lkO1xufVxuIl19