@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

package/ngcc/src/utils.js

@@ -72,6 +72,30 @@
         return /^\/|^\.\.?($|\/)/.test(path);
     }
     exports.isRelativePath = isRelativePath;
+    /**
+     * A `Map`-like object that can compute and memoize a missing value for any key.
+     *
+     * The computed values are memoized, so the factory function is not called more than once per key.
+     * This is useful for storing values that are expensive to compute and may be used multiple times.
+     */
+    // NOTE:
+    // Ideally, this class should extend `Map`, but that causes errors in ES5 transpiled code:
+    // `TypeError: Constructor Map requires 'new'`
+    var FactoryMap = /** @class */ (function () {
+        function FactoryMap(factory, entries) {
+            this.factory = factory;
+            this.internalMap = new Map(entries);
+        }
+        FactoryMap.prototype.get = function (key) {
+            if (!this.internalMap.has(key)) {
+                this.internalMap.set(key, this.factory(key));
+            }
+            return this.internalMap.get(key);
+        };
+        FactoryMap.prototype.set = function (key, value) { this.internalMap.set(key, value); };
+        return FactoryMap;
+    }());
+    exports.FactoryMap = FactoryMap;
     /**
      * Attempt to resolve a `path` to a file by appending the provided `postFixes`
      * to the `path` and checking if the file exists on disk.
@@ -109,5 +133,9 @@
         return value.replace(/\$\d+$/, '');
     }
     exports.stripDollarSuffix = stripDollarSuffix;
+    function stripExtension(fileName) {
+        return fileName.replace(/\..+$/, '');
+    }
+    exports.stripExtension = stripExtension;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/ngcc/src/utils.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,+BAAiC;IACjC,2EAAqF;IAwBrF,SAAgB,iBAAiB,CAAC,OAAuB;QACvD,OAAO,UAAS,MAAiB;YAC/B,OAAO,EAAE,CAAC,WAAW,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACzF,CAAC,CAAC;IACJ,CAAC;IAJD,8CAIC;IAED,SAAgB,SAAS,CAAI,KAA2B;QACtD,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IACnD,CAAC;IAFD,8BAEC;IAED,SAAgB,WAAW,CAAC,IAAsC;QAChE,OAAO,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC5F,CAAC;IAFD,kCAEC;IAED;;;;;OAKG;IACH,SAAgB,OAAO,CAAI,IAAa,EAAE,IAA4C;QACpF,IAAM,KAAK,GAAQ,EAAE,CAAC;QACtB,cAAc,CAAC,IAAI,CAAC,CAAC;QACrB,OAAO,KAAK,CAAC;QAEb,SAAS,cAAc,CAAC,CAAU;YAChC,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE;gBACX,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACf;iBAAM;gBACL,CAAC,CAAC,YAAY,CAAC,UAAA,KAAK,IAAI,OAAA,cAAc,CAAC,KAAK,CAAC,EAArB,CAAqB,CAAC,CAAC;aAChD;QACH,CAAC;IACH,CAAC;IAZD,0BAYC;IAED;;;;OAIG;IACH,SAAgB,iBAAiB,CAAC,WAA2B;QAE3D,IAAM,gBAAgB,GAAoC,WAAW,CAAC;QACtE,OAAO,gBAAgB,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACvF,CAAC;IAJD,8CAIC;IAOD;;;;OAIG;IACH,SAAgB,cAAc,CAAC,IAAY;QACzC,OAAO,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAFD,wCAEC;IAED;;;;OAIG;IACH,SAAgB,wBAAwB,CACpC,EAAc,EAAE,IAAoB,EAAE,SAAmB;;;YAC3D,KAAsB,IAAA,cAAA,iBAAA,SAAS,CAAA,oCAAA,2DAAE;gBAA5B,IAAM,OAAO,sBAAA;gBAChB,IAAM,QAAQ,GAAG,0BAAY,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC;gBAC9C,IAAI,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,EAAE;oBACrD,OAAO,QAAQ,CAAC;iBACjB;aACF;;;;;;;;;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IATD,4DASC;IAED;;;;;;OAMG;IACH,SAAgB,iBAAiB,CAAC,KAAa;QAC7C,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACrC,CAAC;IAFD,8CAEC","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 * as ts from 'typescript';\nimport {AbsoluteFsPath, FileSystem, absoluteFrom} from '../../src/ngtsc/file_system';\n\n/**\n * A list (`Array`) of partially ordered `T` items.\n *\n * The items in the list are partially ordered in the sense that any element has either the same or\n * higher precedence than any element which appears later in the list. What \"higher precedence\"\n * means and how it is determined is implementation-dependent.\n *\n * See [PartiallyOrderedSet](https://en.wikipedia.org/wiki/Partially_ordered_set) for more details.\n * (Refraining from using the term \"set\" here, to avoid confusion with JavaScript's\n * [Set](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set).)\n *\n * NOTE: A plain `Array<T>` is not assignable to a `PartiallyOrderedList<T>`, but a\n *       `PartiallyOrderedList<T>` is assignable to an `Array<T>`.\n */\nexport interface PartiallyOrderedList<T> extends Array<T> {\n  _partiallyOrdered: true;\n\n  map<U>(callbackfn: (value: T, index: number, array: PartiallyOrderedList<T>) => U, thisArg?: any):\n      PartiallyOrderedList<U>;\n  slice(...args: Parameters<Array<T>['slice']>): PartiallyOrderedList<T>;\n}\n\nexport function getOriginalSymbol(checker: ts.TypeChecker): (symbol: ts.Symbol) => ts.Symbol {\n  return function(symbol: ts.Symbol) {\n    return ts.SymbolFlags.Alias & symbol.flags ? checker.getAliasedSymbol(symbol) : symbol;\n  };\n}\n\nexport function isDefined<T>(value: T | undefined | null): value is T {\n  return (value !== undefined) && (value !== null);\n}\n\nexport function getNameText(name: ts.PropertyName | ts.BindingName): string {\n  return ts.isIdentifier(name) || ts.isLiteralExpression(name) ? name.text : name.getText();\n}\n\n/**\n * Parse down the AST and capture all the nodes that satisfy the test.\n * @param node The start node.\n * @param test The function that tests whether a node should be included.\n * @returns a collection of nodes that satisfy the test.\n */\nexport function findAll<T>(node: ts.Node, test: (node: ts.Node) => node is ts.Node & T): T[] {\n  const nodes: T[] = [];\n  findAllVisitor(node);\n  return nodes;\n\n  function findAllVisitor(n: ts.Node) {\n    if (test(n)) {\n      nodes.push(n);\n    } else {\n      n.forEachChild(child => findAllVisitor(child));\n    }\n  }\n}\n\n/**\n * Does the given declaration have a name which is an identifier?\n * @param declaration The declaration to test.\n * @returns true if the declaration has an identifier for a name.\n */\nexport function hasNameIdentifier(declaration: ts.Declaration): declaration is ts.Declaration&\n    {name: ts.Identifier} {\n  const namedDeclaration: ts.Declaration&{name?: ts.Node} = declaration;\n  return namedDeclaration.name !== undefined && ts.isIdentifier(namedDeclaration.name);\n}\n\nexport type PathMappings = {\n  baseUrl: string,\n  paths: {[key: string]: string[]}\n};\n\n/**\n * Test whether a path is \"relative\".\n *\n * Relative paths start with `/`, `./` or `../`; or are simply `.` or `..`.\n */\nexport function isRelativePath(path: string): boolean {\n  return /^\\/|^\\.\\.?($|\\/)/.test(path);\n}\n\n/**\n * Attempt to resolve a `path` to a file by appending the provided `postFixes`\n * to the `path` and checking if the file exists on disk.\n * @returns An absolute path to the first matching existing file, or `null` if none exist.\n */\nexport function resolveFileWithPostfixes(\n    fs: FileSystem, path: AbsoluteFsPath, postFixes: string[]): AbsoluteFsPath|null {\n  for (const postFix of postFixes) {\n    const testPath = absoluteFrom(path + postFix);\n    if (fs.exists(testPath) && fs.stat(testPath).isFile()) {\n      return testPath;\n    }\n  }\n  return null;\n}\n\n/**\n * An identifier may become repeated when bundling multiple source files into a single bundle, so\n * bundlers have a strategy of suffixing non-unique identifiers with a suffix like $2. This function\n * strips off such suffixes, so that ngcc deals with the canonical name of an identifier.\n * @param value The value to strip any suffix of, if applicable.\n * @returns The canonical representation of the value, without any suffix.\n */\nexport function stripDollarSuffix(value: string): string {\n  return value.replace(/\\$\\d+$/, '');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/ngcc/src/utils.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 * as ts from 'typescript';\nimport {AbsoluteFsPath, FileSystem, absoluteFrom} from '../../src/ngtsc/file_system';\n\n/**\n * A list (`Array`) of partially ordered `T` items.\n *\n * The items in the list are partially ordered in the sense that any element has either the same or\n * higher precedence than any element which appears later in the list. What \"higher precedence\"\n * means and how it is determined is implementation-dependent.\n *\n * See [PartiallyOrderedSet](https://en.wikipedia.org/wiki/Partially_ordered_set) for more details.\n * (Refraining from using the term \"set\" here, to avoid confusion with JavaScript's\n * [Set](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set).)\n *\n * NOTE: A plain `Array<T>` is not assignable to a `PartiallyOrderedList<T>`, but a\n *       `PartiallyOrderedList<T>` is assignable to an `Array<T>`.\n */\nexport interface PartiallyOrderedList<T> extends Array<T> {\n  _partiallyOrdered: true;\n\n  map<U>(callbackfn: (value: T, index: number, array: PartiallyOrderedList<T>) => U, thisArg?: any):\n      PartiallyOrderedList<U>;\n  slice(...args: Parameters<Array<T>['slice']>): PartiallyOrderedList<T>;\n}\n\nexport function getOriginalSymbol(checker: ts.TypeChecker): (symbol: ts.Symbol) => ts.Symbol {\n  return function(symbol: ts.Symbol) {\n    return ts.SymbolFlags.Alias & symbol.flags ? checker.getAliasedSymbol(symbol) : symbol;\n  };\n}\n\nexport function isDefined<T>(value: T | undefined | null): value is T {\n  return (value !== undefined) && (value !== null);\n}\n\nexport function getNameText(name: ts.PropertyName | ts.BindingName): string {\n  return ts.isIdentifier(name) || ts.isLiteralExpression(name) ? name.text : name.getText();\n}\n\n/**\n * Parse down the AST and capture all the nodes that satisfy the test.\n * @param node The start node.\n * @param test The function that tests whether a node should be included.\n * @returns a collection of nodes that satisfy the test.\n */\nexport function findAll<T>(node: ts.Node, test: (node: ts.Node) => node is ts.Node & T): T[] {\n  const nodes: T[] = [];\n  findAllVisitor(node);\n  return nodes;\n\n  function findAllVisitor(n: ts.Node) {\n    if (test(n)) {\n      nodes.push(n);\n    } else {\n      n.forEachChild(child => findAllVisitor(child));\n    }\n  }\n}\n\n/**\n * Does the given declaration have a name which is an identifier?\n * @param declaration The declaration to test.\n * @returns true if the declaration has an identifier for a name.\n */\nexport function hasNameIdentifier(declaration: ts.Declaration): declaration is ts.Declaration&\n    {name: ts.Identifier} {\n  const namedDeclaration: ts.Declaration&{name?: ts.Node} = declaration;\n  return namedDeclaration.name !== undefined && ts.isIdentifier(namedDeclaration.name);\n}\n\nexport type PathMappings = {\n  baseUrl: string,\n  paths: {[key: string]: string[]}\n};\n\n/**\n * Test whether a path is \"relative\".\n *\n * Relative paths start with `/`, `./` or `../`; or are simply `.` or `..`.\n */\nexport function isRelativePath(path: string): boolean {\n  return /^\\/|^\\.\\.?($|\\/)/.test(path);\n}\n\n/**\n * A `Map`-like object that can compute and memoize a missing value for any key.\n *\n * The computed values are memoized, so the factory function is not called more than once per key.\n * This is useful for storing values that are expensive to compute and may be used multiple times.\n */\n// NOTE:\n// Ideally, this class should extend `Map`, but that causes errors in ES5 transpiled code:\n// `TypeError: Constructor Map requires 'new'`\nexport class FactoryMap<K, V> {\n  private internalMap: Map<K, V>;\n\n  constructor(private factory: (key: K) => V, entries?: readonly(readonly[K, V])[]|null) {\n    this.internalMap = new Map(entries);\n  }\n\n  get(key: K): V {\n    if (!this.internalMap.has(key)) {\n      this.internalMap.set(key, this.factory(key));\n    }\n\n    return this.internalMap.get(key) !;\n  }\n\n  set(key: K, value: V): void { this.internalMap.set(key, value); }\n}\n\n/**\n * Attempt to resolve a `path` to a file by appending the provided `postFixes`\n * to the `path` and checking if the file exists on disk.\n * @returns An absolute path to the first matching existing file, or `null` if none exist.\n */\nexport function resolveFileWithPostfixes(\n    fs: FileSystem, path: AbsoluteFsPath, postFixes: string[]): AbsoluteFsPath|null {\n  for (const postFix of postFixes) {\n    const testPath = absoluteFrom(path + postFix);\n    if (fs.exists(testPath) && fs.stat(testPath).isFile()) {\n      return testPath;\n    }\n  }\n  return null;\n}\n\n/**\n * An identifier may become repeated when bundling multiple source files into a single bundle, so\n * bundlers have a strategy of suffixing non-unique identifiers with a suffix like $2. This function\n * strips off such suffixes, so that ngcc deals with the canonical name of an identifier.\n * @param value The value to strip any suffix of, if applicable.\n * @returns The canonical representation of the value, without any suffix.\n */\nexport function stripDollarSuffix(value: string): string {\n  return value.replace(/\\$\\d+$/, '');\n}\n\nexport function stripExtension(fileName: string): string {\n  return fileName.replace(/\\..+$/, '');\n}\n"]}

package/ngcc/src/writing/cleaning/cleaning_strategies.d.ts

@@ -0,0 +1,45 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/writing/cleaning/cleaning_strategies" />
+/**
+ * @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 { AbsoluteFsPath, FileSystem, PathSegment } from '../../../../src/ngtsc/file_system';
+/**
+* Implement this interface to extend the cleaning strategies of the `PackageCleaner`.
+*/
+export interface CleaningStrategy {
+    canClean(path: AbsoluteFsPath, basename: PathSegment): boolean;
+    clean(path: AbsoluteFsPath, basename: PathSegment): void;
+}
+/**
+ * A CleaningStrategy that reverts changes to package.json files by removing the build marker and
+ * other properties.
+ */
+export declare class PackageJsonCleaner implements CleaningStrategy {
+    private fs;
+    constructor(fs: FileSystem);
+    canClean(_path: AbsoluteFsPath, basename: PathSegment): boolean;
+    clean(path: AbsoluteFsPath, _basename: PathSegment): void;
+}
+/**
+ * A CleaningStrategy that removes the extra directory containing generated entry-point formats.
+ */
+export declare class NgccDirectoryCleaner implements CleaningStrategy {
+    private fs;
+    constructor(fs: FileSystem);
+    canClean(path: AbsoluteFsPath, basename: PathSegment): boolean;
+    clean(path: AbsoluteFsPath, _basename: PathSegment): void;
+}
+/**
+ * A CleaningStrategy that reverts files that were overwritten and removes the backup files that
+ * ngcc created.
+ */
+export declare class BackupFileCleaner implements CleaningStrategy {
+    private fs;
+    constructor(fs: FileSystem);
+    canClean(path: AbsoluteFsPath, basename: PathSegment): boolean;
+    clean(path: AbsoluteFsPath, _basename: PathSegment): void;
+}

package/ngcc/src/writing/cleaning/cleaning_strategies.js

@@ -0,0 +1,77 @@
+(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/writing/cleaning/cleaning_strategies", ["require", "exports", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/ngcc/src/packages/build_marker", "@angular/compiler-cli/ngcc/src/writing/in_place_file_writer", "@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer", "@angular/compiler-cli/ngcc/src/writing/cleaning/utils"], 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 file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var build_marker_1 = require("@angular/compiler-cli/ngcc/src/packages/build_marker");
+    var in_place_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/in_place_file_writer");
+    var new_entry_point_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/new_entry_point_file_writer");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/writing/cleaning/utils");
+    /**
+     * A CleaningStrategy that reverts changes to package.json files by removing the build marker and
+     * other properties.
+     */
+    var PackageJsonCleaner = /** @class */ (function () {
+        function PackageJsonCleaner(fs) {
+            this.fs = fs;
+        }
+        PackageJsonCleaner.prototype.canClean = function (_path, basename) {
+            return basename === 'package.json';
+        };
+        PackageJsonCleaner.prototype.clean = function (path, _basename) {
+            var packageJson = JSON.parse(this.fs.readFile(path));
+            if (build_marker_1.cleanPackageJson(packageJson)) {
+                this.fs.writeFile(path, JSON.stringify(packageJson, null, 2) + "\n");
+            }
+        };
+        return PackageJsonCleaner;
+    }());
+    exports.PackageJsonCleaner = PackageJsonCleaner;
+    /**
+     * A CleaningStrategy that removes the extra directory containing generated entry-point formats.
+     */
+    var NgccDirectoryCleaner = /** @class */ (function () {
+        function NgccDirectoryCleaner(fs) {
+            this.fs = fs;
+        }
+        NgccDirectoryCleaner.prototype.canClean = function (path, basename) {
+            return basename === new_entry_point_file_writer_1.NGCC_DIRECTORY && utils_1.isLocalDirectory(this.fs, path);
+        };
+        NgccDirectoryCleaner.prototype.clean = function (path, _basename) { this.fs.removeDeep(path); };
+        return NgccDirectoryCleaner;
+    }());
+    exports.NgccDirectoryCleaner = NgccDirectoryCleaner;
+    /**
+     * A CleaningStrategy that reverts files that were overwritten and removes the backup files that
+     * ngcc created.
+     */
+    var BackupFileCleaner = /** @class */ (function () {
+        function BackupFileCleaner(fs) {
+            this.fs = fs;
+        }
+        BackupFileCleaner.prototype.canClean = function (path, basename) {
+            return this.fs.extname(basename) === in_place_file_writer_1.NGCC_BACKUP_EXTENSION &&
+                this.fs.exists(file_system_1.absoluteFrom(path.replace(in_place_file_writer_1.NGCC_BACKUP_EXTENSION, '')));
+        };
+        BackupFileCleaner.prototype.clean = function (path, _basename) {
+            this.fs.moveFile(path, file_system_1.absoluteFrom(path.replace(in_place_file_writer_1.NGCC_BACKUP_EXTENSION, '')));
+        };
+        return BackupFileCleaner;
+    }());
+    exports.BackupFileCleaner = BackupFileCleaner;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/writing/cleaning/package_cleaner.d.ts

@@ -0,0 +1,39 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/writing/cleaning/package_cleaner" />
+/**
+ * @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 { AbsoluteFsPath, FileSystem } from '../../../../src/ngtsc/file_system';
+import { EntryPoint } from '../../packages/entry_point';
+import { CleaningStrategy } from './cleaning_strategies';
+/**
+ * A class that can clean ngcc artifacts from a directory.
+ */
+export declare class PackageCleaner {
+    private fs;
+    private cleaners;
+    constructor(fs: FileSystem, cleaners: CleaningStrategy[]);
+    /**
+     * Recurse through the file-system cleaning files and directories as determined by the configured
+     * cleaning-strategies.
+     *
+     * @param directory the current directory to clean
+     */
+    clean(directory: AbsoluteFsPath): void;
+}
+/**
+ * Iterate through the given `entryPoints` identifying the package for each that has at least one
+ * outdated processed format, then cleaning those packages.
+ *
+ * Note that we have to clean entire packages because there is no clear file-system boundary
+ * between entry-points within a package. So if one entry-point is outdated we have to clean
+ * everything within that package.
+ *
+ * @param fileSystem the current file-system
+ * @param entryPoints the entry-points that have been collected for this run of ngcc
+ * @returns true if packages needed to be cleaned.
+ */
+export declare function cleanOutdatedPackages(fileSystem: FileSystem, entryPoints: EntryPoint[]): boolean;

package/ngcc/src/writing/cleaning/package_cleaner.js

@@ -0,0 +1,125 @@
+(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/writing/cleaning/package_cleaner", ["require", "exports", "tslib", "@angular/compiler-cli/ngcc/src/packages/build_marker", "@angular/compiler-cli/ngcc/src/writing/cleaning/cleaning_strategies", "@angular/compiler-cli/ngcc/src/writing/cleaning/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    var build_marker_1 = require("@angular/compiler-cli/ngcc/src/packages/build_marker");
+    var cleaning_strategies_1 = require("@angular/compiler-cli/ngcc/src/writing/cleaning/cleaning_strategies");
+    var utils_1 = require("@angular/compiler-cli/ngcc/src/writing/cleaning/utils");
+    /**
+     * A class that can clean ngcc artifacts from a directory.
+     */
+    var PackageCleaner = /** @class */ (function () {
+        function PackageCleaner(fs, cleaners) {
+            this.fs = fs;
+            this.cleaners = cleaners;
+        }
+        /**
+         * Recurse through the file-system cleaning files and directories as determined by the configured
+         * cleaning-strategies.
+         *
+         * @param directory the current directory to clean
+         */
+        PackageCleaner.prototype.clean = function (directory) {
+            var e_1, _a, e_2, _b;
+            var basenames = this.fs.readdir(directory);
+            try {
+                for (var basenames_1 = tslib_1.__values(basenames), basenames_1_1 = basenames_1.next(); !basenames_1_1.done; basenames_1_1 = basenames_1.next()) {
+                    var basename = basenames_1_1.value;
+                    if (basename === 'node_modules') {
+                        continue;
+                    }
+                    var path = this.fs.resolve(directory, basename);
+                    try {
+                        for (var _c = (e_2 = void 0, tslib_1.__values(this.cleaners)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var cleaner = _d.value;
+                            if (cleaner.canClean(path, basename)) {
+                                cleaner.clean(path, basename);
+                                break;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    // Recurse into subdirectories (note that a cleaner may have removed this path)
+                    if (utils_1.isLocalDirectory(this.fs, path)) {
+                        this.clean(path);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (basenames_1_1 && !basenames_1_1.done && (_a = basenames_1.return)) _a.call(basenames_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        return PackageCleaner;
+    }());
+    exports.PackageCleaner = PackageCleaner;
+    /**
+     * Iterate through the given `entryPoints` identifying the package for each that has at least one
+     * outdated processed format, then cleaning those packages.
+     *
+     * Note that we have to clean entire packages because there is no clear file-system boundary
+     * between entry-points within a package. So if one entry-point is outdated we have to clean
+     * everything within that package.
+     *
+     * @param fileSystem the current file-system
+     * @param entryPoints the entry-points that have been collected for this run of ngcc
+     * @returns true if packages needed to be cleaned.
+     */
+    function cleanOutdatedPackages(fileSystem, entryPoints) {
+        var e_3, _a, e_4, _b;
+        var packagesToClean = new Set();
+        try {
+            for (var entryPoints_1 = tslib_1.__values(entryPoints), entryPoints_1_1 = entryPoints_1.next(); !entryPoints_1_1.done; entryPoints_1_1 = entryPoints_1.next()) {
+                var entryPoint = entryPoints_1_1.value;
+                if (build_marker_1.needsCleaning(entryPoint.packageJson)) {
+                    packagesToClean.add(entryPoint.package);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (entryPoints_1_1 && !entryPoints_1_1.done && (_a = entryPoints_1.return)) _a.call(entryPoints_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        var cleaner = new PackageCleaner(fileSystem, [
+            new cleaning_strategies_1.PackageJsonCleaner(fileSystem),
+            new cleaning_strategies_1.NgccDirectoryCleaner(fileSystem),
+            new cleaning_strategies_1.BackupFileCleaner(fileSystem),
+        ]);
+        try {
+            for (var packagesToClean_1 = tslib_1.__values(packagesToClean), packagesToClean_1_1 = packagesToClean_1.next(); !packagesToClean_1_1.done; packagesToClean_1_1 = packagesToClean_1.next()) {
+                var packagePath = packagesToClean_1_1.value;
+                cleaner.clean(packagePath);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (packagesToClean_1_1 && !packagesToClean_1_1.done && (_b = packagesToClean_1.return)) _b.call(packagesToClean_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return packagesToClean.size > 0;
+    }
+    exports.cleanOutdatedPackages = cleanOutdatedPackages;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZV9jbGVhbmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL25nY2Mvc3JjL3dyaXRpbmcvY2xlYW5pbmcvcGFja2FnZV9jbGVhbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztJQVFBLHFGQUEwRDtJQUcxRCwyR0FBb0g7SUFDcEgsK0VBQXlDO0lBRXpDOztPQUVHO0lBQ0g7UUFDRSx3QkFBb0IsRUFBYyxFQUFVLFFBQTRCO1lBQXBELE9BQUUsR0FBRixFQUFFLENBQVk7WUFBVSxhQUFRLEdBQVIsUUFBUSxDQUFvQjtRQUFHLENBQUM7UUFFNUU7Ozs7O1dBS0c7UUFDSCw4QkFBSyxHQUFMLFVBQU0sU0FBeUI7O1lBQzdCLElBQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDOztnQkFDN0MsS0FBdUIsSUFBQSxjQUFBLGlCQUFBLFNBQVMsQ0FBQSxvQ0FBQSwyREFBRTtvQkFBN0IsSUFBTSxRQUFRLHNCQUFBO29CQUNqQixJQUFJLFFBQVEsS0FBSyxjQUFjLEVBQUU7d0JBQy9CLFNBQVM7cUJBQ1Y7b0JBRUQsSUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLFFBQVEsQ0FBQyxDQUFDOzt3QkFDbEQsS0FBc0IsSUFBQSxvQkFBQSxpQkFBQSxJQUFJLENBQUMsUUFBUSxDQUFBLENBQUEsZ0JBQUEsNEJBQUU7NEJBQWhDLElBQU0sT0FBTyxXQUFBOzRCQUNoQixJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxFQUFFO2dDQUNwQyxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztnQ0FDOUIsTUFBTTs2QkFDUDt5QkFDRjs7Ozs7Ozs7O29CQUNELCtFQUErRTtvQkFDL0UsSUFBSSx3QkFBZ0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFO3dCQUNuQyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO3FCQUNsQjtpQkFDRjs7Ozs7Ozs7O1FBQ0gsQ0FBQztRQUNILHFCQUFDO0lBQUQsQ0FBQyxBQTdCRCxJQTZCQztJQTdCWSx3Q0FBYztJQWdDM0I7Ozs7Ozs7Ozs7O09BV0c7SUFDSCxTQUFnQixxQkFBcUIsQ0FBQyxVQUFzQixFQUFFLFdBQXlCOztRQUNyRixJQUFNLGVBQWUsR0FBRyxJQUFJLEdBQUcsRUFBa0IsQ0FBQzs7WUFDbEQsS0FBeUIsSUFBQSxnQkFBQSxpQkFBQSxXQUFXLENBQUEsd0NBQUEsaUVBQUU7Z0JBQWpDLElBQU0sVUFBVSx3QkFBQTtnQkFDbkIsSUFBSSw0QkFBYSxDQUFDLFVBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRTtvQkFDekMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUM7aUJBQ3pDO2FBQ0Y7Ozs7Ozs7OztRQUVELElBQU0sT0FBTyxHQUFHLElBQUksY0FBYyxDQUFDLFVBQVUsRUFBRTtZQUM3QyxJQUFJLHdDQUFrQixDQUFDLFVBQVUsQ0FBQztZQUNsQyxJQUFJLDBDQUFvQixDQUFDLFVBQVUsQ0FBQztZQUNwQyxJQUFJLHVDQUFpQixDQUFDLFVBQVUsQ0FBQztTQUNsQyxDQUFDLENBQUM7O1lBQ0gsS0FBMEIsSUFBQSxvQkFBQSxpQkFBQSxlQUFlLENBQUEsZ0RBQUEsNkVBQUU7Z0JBQXRDLElBQU0sV0FBVyw0QkFBQTtnQkFDcEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQzthQUM1Qjs7Ozs7Ozs7O1FBRUQsT0FBTyxlQUFlLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBbEJELHNEQWtCQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7QWJzb2x1dGVGc1BhdGgsIEZpbGVTeXN0ZW19IGZyb20gJy4uLy4uLy4uLy4uL3NyYy9uZ3RzYy9maWxlX3N5c3RlbSc7XG5pbXBvcnQge25lZWRzQ2xlYW5pbmd9IGZyb20gJy4uLy4uL3BhY2thZ2VzL2J1aWxkX21hcmtlcic7XG5pbXBvcnQge0VudHJ5UG9pbnR9IGZyb20gJy4uLy4uL3BhY2thZ2VzL2VudHJ5X3BvaW50JztcblxuaW1wb3J0IHtCYWNrdXBGaWxlQ2xlYW5lciwgQ2xlYW5pbmdTdHJhdGVneSwgTmdjY0RpcmVjdG9yeUNsZWFuZXIsIFBhY2thZ2VKc29uQ2xlYW5lcn0gZnJvbSAnLi9jbGVhbmluZ19zdHJhdGVnaWVzJztcbmltcG9ydCB7aXNMb2NhbERpcmVjdG9yeX0gZnJvbSAnLi91dGlscyc7XG5cbi8qKlxuICogQSBjbGFzcyB0aGF0IGNhbiBjbGVhbiBuZ2NjIGFydGlmYWN0cyBmcm9tIGEgZGlyZWN0b3J5LlxuICovXG5leHBvcnQgY2xhc3MgUGFja2FnZUNsZWFuZXIge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGZzOiBGaWxlU3lzdGVtLCBwcml2YXRlIGNsZWFuZXJzOiBDbGVhbmluZ1N0cmF0ZWd5W10pIHt9XG5cbiAgLyoqXG4gICAqIFJlY3Vyc2UgdGhyb3VnaCB0aGUgZmlsZS1zeXN0ZW0gY2xlYW5pbmcgZmlsZXMgYW5kIGRpcmVjdG9yaWVzIGFzIGRldGVybWluZWQgYnkgdGhlIGNvbmZpZ3VyZWRcbiAgICogY2xlYW5pbmctc3RyYXRlZ2llcy5cbiAgICpcbiAgICogQHBhcmFtIGRpcmVjdG9yeSB0aGUgY3VycmVudCBkaXJlY3RvcnkgdG8gY2xlYW5cbiAgICovXG4gIGNsZWFuKGRpcmVjdG9yeTogQWJzb2x1dGVGc1BhdGgpIHtcbiAgICBjb25zdCBiYXNlbmFtZXMgPSB0aGlzLmZzLnJlYWRkaXIoZGlyZWN0b3J5KTtcbiAgICBmb3IgKGNvbnN0IGJhc2VuYW1lIG9mIGJhc2VuYW1lcykge1xuICAgICAgaWYgKGJhc2VuYW1lID09PSAnbm9kZV9tb2R1bGVzJykge1xuICAgICAgICBjb250aW51ZTtcbiAgICAgIH1cblxuICAgICAgY29uc3QgcGF0aCA9IHRoaXMuZnMucmVzb2x2ZShkaXJlY3RvcnksIGJhc2VuYW1lKTtcbiAgICAgIGZvciAoY29uc3QgY2xlYW5lciBvZiB0aGlzLmNsZWFuZXJzKSB7XG4gICAgICAgIGlmIChjbGVhbmVyLmNhbkNsZWFuKHBhdGgsIGJhc2VuYW1lKSkge1xuICAgICAgICAgIGNsZWFuZXIuY2xlYW4ocGF0aCwgYmFzZW5hbWUpO1xuICAgICAgICAgIGJyZWFrO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgICAvLyBSZWN1cnNlIGludG8gc3ViZGlyZWN0b3JpZXMgKG5vdGUgdGhhdCBhIGNsZWFuZXIgbWF5IGhhdmUgcmVtb3ZlZCB0aGlzIHBhdGgpXG4gICAgICBpZiAoaXNMb2NhbERpcmVjdG9yeSh0aGlzLmZzLCBwYXRoKSkge1xuICAgICAgICB0aGlzLmNsZWFuKHBhdGgpO1xuICAgICAgfVxuICAgIH1cbiAgfVxufVxuXG5cbi8qKlxuICogSXRlcmF0ZSB0aHJvdWdoIHRoZSBnaXZlbiBgZW50cnlQb2ludHNgIGlkZW50aWZ5aW5nIHRoZSBwYWNrYWdlIGZvciBlYWNoIHRoYXQgaGFzIGF0IGxlYXN0IG9uZVxuICogb3V0ZGF0ZWQgcHJvY2Vzc2VkIGZvcm1hdCwgdGhlbiBjbGVhbmluZyB0aG9zZSBwYWNrYWdlcy5cbiAqXG4gKiBOb3RlIHRoYXQgd2UgaGF2ZSB0byBjbGVhbiBlbnRpcmUgcGFja2FnZXMgYmVjYXVzZSB0aGVyZSBpcyBubyBjbGVhciBmaWxlLXN5c3RlbSBib3VuZGFyeVxuICogYmV0d2VlbiBlbnRyeS1wb2ludHMgd2l0aGluIGEgcGFja2FnZS4gU28gaWYgb25lIGVudHJ5LXBvaW50IGlzIG91dGRhdGVkIHdlIGhhdmUgdG8gY2xlYW5cbiAqIGV2ZXJ5dGhpbmcgd2l0aGluIHRoYXQgcGFja2FnZS5cbiAqXG4gKiBAcGFyYW0gZmlsZVN5c3RlbSB0aGUgY3VycmVudCBmaWxlLXN5c3RlbVxuICogQHBhcmFtIGVudHJ5UG9pbnRzIHRoZSBlbnRyeS1wb2ludHMgdGhhdCBoYXZlIGJlZW4gY29sbGVjdGVkIGZvciB0aGlzIHJ1biBvZiBuZ2NjXG4gKiBAcmV0dXJucyB0cnVlIGlmIHBhY2thZ2VzIG5lZWRlZCB0byBiZSBjbGVhbmVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY2xlYW5PdXRkYXRlZFBhY2thZ2VzKGZpbGVTeXN0ZW06IEZpbGVTeXN0ZW0sIGVudHJ5UG9pbnRzOiBFbnRyeVBvaW50W10pOiBib29sZWFuIHtcbiAgY29uc3QgcGFja2FnZXNUb0NsZWFuID0gbmV3IFNldDxBYnNvbHV0ZUZzUGF0aD4oKTtcbiAgZm9yIChjb25zdCBlbnRyeVBvaW50IG9mIGVudHJ5UG9pbnRzKSB7XG4gICAgaWYgKG5lZWRzQ2xlYW5pbmcoZW50cnlQb2ludC5wYWNrYWdlSnNvbikpIHtcbiAgICAgIHBhY2thZ2VzVG9DbGVhbi5hZGQoZW50cnlQb2ludC5wYWNrYWdlKTtcbiAgICB9XG4gIH1cblxuICBjb25zdCBjbGVhbmVyID0gbmV3IFBhY2thZ2VDbGVhbmVyKGZpbGVTeXN0ZW0sIFtcbiAgICBuZXcgUGFja2FnZUpzb25DbGVhbmVyKGZpbGVTeXN0ZW0pLFxuICAgIG5ldyBOZ2NjRGlyZWN0b3J5Q2xlYW5lcihmaWxlU3lzdGVtKSxcbiAgICBuZXcgQmFja3VwRmlsZUNsZWFuZXIoZmlsZVN5c3RlbSksXG4gIF0pO1xuICBmb3IgKGNvbnN0IHBhY2thZ2VQYXRoIG9mIHBhY2thZ2VzVG9DbGVhbikge1xuICAgIGNsZWFuZXIuY2xlYW4ocGFja2FnZVBhdGgpO1xuICB9XG5cbiAgcmV0dXJuIHBhY2thZ2VzVG9DbGVhbi5zaXplID4gMDtcbn1cbiJdfQ==

package/ngcc/src/writing/cleaning/utils.d.ts

@@ -0,0 +1,16 @@
+/// <amd-module name="@angular/compiler-cli/ngcc/src/writing/cleaning/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 { AbsoluteFsPath, FileSystem } from '../../../../src/ngtsc/file_system';
+/**
+ * Returns true if the given `path` is a directory (not a symlink) and actually exists.
+ *
+ * @param fs the current filesystem
+ * @param path the path to check
+ */
+export declare function isLocalDirectory(fs: FileSystem, path: AbsoluteFsPath): boolean;

package/ngcc/src/writing/cleaning/utils.js

@@ -0,0 +1,29 @@
+(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/writing/cleaning/utils", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * Returns true if the given `path` is a directory (not a symlink) and actually exists.
+     *
+     * @param fs the current filesystem
+     * @param path the path to check
+     */
+    function isLocalDirectory(fs, path) {
+        if (fs.exists(path)) {
+            var stat = fs.lstat(path);
+            return stat.isDirectory();
+        }
+        else {
+            return false;
+        }
+    }
+    exports.isLocalDirectory = isLocalDirectory;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvd3JpdGluZy9jbGVhbmluZy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQVNBOzs7OztPQUtHO0lBQ0gsU0FBZ0IsZ0JBQWdCLENBQUMsRUFBYyxFQUFFLElBQW9CO1FBQ25FLElBQUksRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUNuQixJQUFNLElBQUksR0FBRyxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzVCLE9BQU8sSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO1NBQzNCO2FBQU07WUFDTCxPQUFPLEtBQUssQ0FBQztTQUNkO0lBQ0gsQ0FBQztJQVBELDRDQU9DIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0IHtBYnNvbHV0ZUZzUGF0aCwgRmlsZVN5c3RlbX0gZnJvbSAnLi4vLi4vLi4vLi4vc3JjL25ndHNjL2ZpbGVfc3lzdGVtJztcblxuLyoqXG4gKiBSZXR1cm5zIHRydWUgaWYgdGhlIGdpdmVuIGBwYXRoYCBpcyBhIGRpcmVjdG9yeSAobm90IGEgc3ltbGluaykgYW5kIGFjdHVhbGx5IGV4aXN0cy5cbiAqXG4gKiBAcGFyYW0gZnMgdGhlIGN1cnJlbnQgZmlsZXN5c3RlbVxuICogQHBhcmFtIHBhdGggdGhlIHBhdGggdG8gY2hlY2tcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzTG9jYWxEaXJlY3RvcnkoZnM6IEZpbGVTeXN0ZW0sIHBhdGg6IEFic29sdXRlRnNQYXRoKTogYm9vbGVhbiB7XG4gIGlmIChmcy5leGlzdHMocGF0aCkpIHtcbiAgICBjb25zdCBzdGF0ID0gZnMubHN0YXQocGF0aCk7XG4gICAgcmV0dXJuIHN0YXQuaXNEaXJlY3RvcnkoKTtcbiAgfSBlbHNlIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cbiJdfQ==

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

@@ -11,6 +11,7 @@ import { EntryPointJsonProperty } from '../packages/entry_point';
 import { EntryPointBundle } from '../packages/entry_point_bundle';
 import { FileToWrite } from '../rendering/utils';
 import { FileWriter } from './file_writer';
+export declare const NGCC_BACKUP_EXTENSION = ".__ivy_ngcc_bak";
 /**
  * This FileWriter overwrites the transformed file, in-place, while creating
  * a back-up of the original file with an extra `.__ivy_ngcc_bak` extension.

package/ngcc/src/writing/in_place_file_writer.js

@@ -17,6 +17,7 @@
      * found in the LICENSE file at https://angular.io/license
      */
     var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    exports.NGCC_BACKUP_EXTENSION = '.__ivy_ngcc_bak';
     /**
      * This FileWriter overwrites the transformed file, in-place, while creating
      * a back-up of the original file with an extra `.__ivy_ngcc_bak` extension.
@@ -31,7 +32,7 @@
         };
         InPlaceFileWriter.prototype.writeFileAndBackup = function (file) {
             this.fs.ensureDir(file_system_1.dirname(file.path));
-            var backPath = file_system_1.absoluteFrom(file.path + ".__ivy_ngcc_bak");
+            var backPath = file_system_1.absoluteFrom("" + file.path + exports.NGCC_BACKUP_EXTENSION);
             if (this.fs.exists(backPath)) {
                 throw new Error("Tried to overwrite " + backPath + " with an ngcc back up file, which is disallowed.");
             }
@@ -44,4 +45,4 @@
     }());
     exports.InPlaceFileWriter = InPlaceFileWriter;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5fcGxhY2VfZmlsZV93cml0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbmdjYy9zcmMvd3JpdGluZy9pbl9wbGFjZV9maWxlX3dyaXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztJQUNBOzs7Ozs7T0FNRztJQUNILDJFQUFpRjtJQU1wRSxRQUFBLHFCQUFxQixHQUFHLGlCQUFpQixDQUFDO0lBQ3ZEOzs7T0FHRztJQUNIO1FBQ0UsMkJBQXNCLEVBQWM7WUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBQUcsQ0FBQztRQUV4Qyx1Q0FBVyxHQUFYLFVBQ0ksT0FBeUIsRUFBRSxnQkFBK0IsRUFDMUQsaUJBQTRDO1lBRmhELGlCQUlDO1lBREMsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLFVBQUEsSUFBSSxJQUFJLE9BQUEsS0FBSSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxFQUE3QixDQUE2QixDQUFDLENBQUM7UUFDbEUsQ0FBQztRQUVTLDhDQUFrQixHQUE1QixVQUE2QixJQUFpQjtZQUM1QyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxxQkFBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQ3RDLElBQU0sUUFBUSxHQUFHLDBCQUFZLENBQUMsS0FBRyxJQUFJLENBQUMsSUFBSSxHQUFHLDZCQUF1QixDQUFDLENBQUM7WUFDdEUsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsRUFBRTtnQkFDNUIsTUFBTSxJQUFJLEtBQUssQ0FDWCx3QkFBc0IsUUFBUSxxREFBa0QsQ0FBQyxDQUFDO2FBQ3ZGO1lBQ0QsSUFBSSxJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEVBQUU7Z0JBQzdCLElBQUksQ0FBQyxFQUFFLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsUUFBUSxDQUFDLENBQUM7YUFDdkM7WUFDRCxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUM5QyxDQUFDO1FBQ0gsd0JBQUM7SUFBRCxDQUFDLEFBckJELElBcUJDO0lBckJZLDhDQUFpQiIsInNvdXJjZXNDb250ZW50IjpbIlxuLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0IHtGaWxlU3lzdGVtLCBhYnNvbHV0ZUZyb20sIGRpcm5hbWV9IGZyb20gJy4uLy4uLy4uL3NyYy9uZ3RzYy9maWxlX3N5c3RlbSc7XG5pbXBvcnQge0VudHJ5UG9pbnRKc29uUHJvcGVydHl9IGZyb20gJy4uL3BhY2thZ2VzL2VudHJ5X3BvaW50JztcbmltcG9ydCB7RW50cnlQb2ludEJ1bmRsZX0gZnJvbSAnLi4vcGFja2FnZXMvZW50cnlfcG9pbnRfYnVuZGxlJztcbmltcG9ydCB7RmlsZVRvV3JpdGV9IGZyb20gJy4uL3JlbmRlcmluZy91dGlscyc7XG5pbXBvcnQge0ZpbGVXcml0ZXJ9IGZyb20gJy4vZmlsZV93cml0ZXInO1xuXG5leHBvcnQgY29uc3QgTkdDQ19CQUNLVVBfRVhURU5TSU9OID0gJy5fX2l2eV9uZ2NjX2Jhayc7XG4vKipcbiAqIFRoaXMgRmlsZVdyaXRlciBvdmVyd3JpdGVzIHRoZSB0cmFuc2Zvcm1lZCBmaWxlLCBpbi1wbGFjZSwgd2hpbGUgY3JlYXRpbmdcbiAqIGEgYmFjay11cCBvZiB0aGUgb3JpZ2luYWwgZmlsZSB3aXRoIGFuIGV4dHJhIGAuX19pdnlfbmdjY19iYWtgIGV4dGVuc2lvbi5cbiAqL1xuZXhwb3J0IGNsYXNzIEluUGxhY2VGaWxlV3JpdGVyIGltcGxlbWVudHMgRmlsZVdyaXRlciB7XG4gIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBmczogRmlsZVN5c3RlbSkge31cblxuICB3cml0ZUJ1bmRsZShcbiAgICAgIF9idW5kbGU6IEVudHJ5UG9pbnRCdW5kbGUsIHRyYW5zZm9ybWVkRmlsZXM6IEZpbGVUb1dyaXRlW10sXG4gICAgICBfZm9ybWF0UHJvcGVydGllcz86IEVudHJ5UG9pbnRKc29uUHJvcGVydHlbXSkge1xuICAgIHRyYW5zZm9ybWVkRmlsZXMuZm9yRWFjaChmaWxlID0+IHRoaXMud3JpdGVGaWxlQW5kQmFja3VwKGZpbGUpKTtcbiAgfVxuXG4gIHByb3RlY3RlZCB3cml0ZUZpbGVBbmRCYWNrdXAoZmlsZTogRmlsZVRvV3JpdGUpOiB2b2lkIHtcbiAgICB0aGlzLmZzLmVuc3VyZURpcihkaXJuYW1lKGZpbGUucGF0aCkpO1xuICAgIGNvbnN0IGJhY2tQYXRoID0gYWJzb2x1dGVGcm9tKGAke2ZpbGUucGF0aH0ke05HQ0NfQkFDS1VQX0VYVEVOU0lPTn1gKTtcbiAgICBpZiAodGhpcy5mcy5leGlzdHMoYmFja1BhdGgpKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAgICAgYFRyaWVkIHRvIG92ZXJ3cml0ZSAke2JhY2tQYXRofSB3aXRoIGFuIG5nY2MgYmFjayB1cCBmaWxlLCB3aGljaCBpcyBkaXNhbGxvd2VkLmApO1xuICAgIH1cbiAgICBpZiAodGhpcy5mcy5leGlzdHMoZmlsZS5wYXRoKSkge1xuICAgICAgdGhpcy5mcy5tb3ZlRmlsZShmaWxlLnBhdGgsIGJhY2tQYXRoKTtcbiAgICB9XG4gICAgdGhpcy5mcy53cml0ZUZpbGUoZmlsZS5wYXRoLCBmaWxlLmNvbnRlbnRzKTtcbiAgfVxufVxuIl19

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

@@ -12,6 +12,8 @@ import { EntryPointBundle } from '../packages/entry_point_bundle';
 import { FileToWrite } from '../rendering/utils';
 import { InPlaceFileWriter } from './in_place_file_writer';
 import { PackageJsonUpdater } from './package_json_updater';
+export declare const NGCC_DIRECTORY = "__ivy_ngcc__";
+export declare const NGCC_PROPERTY_EXTENSION = "_ivy_ngcc";
 /**
  * This FileWriter creates a copy of the original entry-point, then writes the transformed
  * files onto the files in this copy, and finally updates the package.json with a new

package/ngcc/src/writing/new_entry_point_file_writer.js

@@ -20,7 +20,8 @@
     var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
     var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
     var in_place_file_writer_1 = require("@angular/compiler-cli/ngcc/src/writing/in_place_file_writer");
-    var NGCC_DIRECTORY = '__ivy_ngcc__';
+    exports.NGCC_DIRECTORY = '__ivy_ngcc__';
+    exports.NGCC_PROPERTY_EXTENSION = '_ivy_ngcc';
     /**
      * This FileWriter creates a copy of the original entry-point, then writes the transformed
      * files onto the files in this copy, and finally updates the package.json with a new
@@ -40,7 +41,7 @@
             var _this = this;
             // The new folder is at the root of the overall package
             var entryPoint = bundle.entryPoint;
-            var ngccFolder = file_system_1.join(entryPoint.package, NGCC_DIRECTORY);
+            var ngccFolder = file_system_1.join(entryPoint.package, exports.NGCC_DIRECTORY);
             this.copyBundle(bundle, entryPoint.package, ngccFolder);
             transformedFiles.forEach(function (file) { return _this.writeFile(file, entryPoint.package, ngccFolder); });
             this.updatePackageJson(entryPoint, formatProperties, ngccFolder);
@@ -92,7 +93,7 @@
                         throw new Error("Unable to update '" + packageJsonPath + "': Format properties " +
                             ("(" + formatProperties.join(', ') + ") map to more than one format-path."));
                     }
-                    update.addChange([formatProperty + "_ivy_ngcc"], newFormatPath);
+                    update.addChange(["" + formatProperty + exports.NGCC_PROPERTY_EXTENSION], newFormatPath, { before: formatProperty });
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -108,4 +109,4 @@
     }(in_place_file_writer_1.InPlaceFileWriter));
     exports.NewEntryPointFileWriter = NewEntryPointFileWriter;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new_entry_point_file_writer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/writing/new_entry_point_file_writer.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {AbsoluteFsPath, FileSystem, absoluteFromSourceFile, dirname, join, relative} from '../../../src/ngtsc/file_system';\nimport {isDtsPath} from '../../../src/ngtsc/util/src/typescript';\nimport {EntryPoint, EntryPointJsonProperty} from '../packages/entry_point';\nimport {EntryPointBundle} from '../packages/entry_point_bundle';\nimport {FileToWrite} from '../rendering/utils';\n\nimport {InPlaceFileWriter} from './in_place_file_writer';\nimport {PackageJsonUpdater} from './package_json_updater';\n\nconst NGCC_DIRECTORY = '__ivy_ngcc__';\n\n/**\n * This FileWriter creates a copy of the original entry-point, then writes the transformed\n * files onto the files in this copy, and finally updates the package.json with a new\n * entry-point format property that points to this new entry-point.\n *\n * If there are transformed typings files in this bundle, they are updated in-place (see the\n * `InPlaceFileWriter`).\n */\nexport class NewEntryPointFileWriter extends InPlaceFileWriter {\n  constructor(fs: FileSystem, private pkgJsonUpdater: PackageJsonUpdater) { super(fs); }\n\n  writeBundle(\n      bundle: EntryPointBundle, transformedFiles: FileToWrite[],\n      formatProperties: EntryPointJsonProperty[]) {\n    // The new folder is at the root of the overall package\n    const entryPoint = bundle.entryPoint;\n    const ngccFolder = join(entryPoint.package, NGCC_DIRECTORY);\n    this.copyBundle(bundle, entryPoint.package, ngccFolder);\n    transformedFiles.forEach(file => this.writeFile(file, entryPoint.package, ngccFolder));\n    this.updatePackageJson(entryPoint, formatProperties, ngccFolder);\n  }\n\n  protected copyBundle(\n      bundle: EntryPointBundle, packagePath: AbsoluteFsPath, ngccFolder: AbsoluteFsPath) {\n    bundle.src.program.getSourceFiles().forEach(sourceFile => {\n      const relativePath = relative(packagePath, absoluteFromSourceFile(sourceFile));\n      const isOutsidePackage = relativePath.startsWith('..');\n      if (!sourceFile.isDeclarationFile && !isOutsidePackage) {\n        const newFilePath = join(ngccFolder, relativePath);\n        this.fs.ensureDir(dirname(newFilePath));\n        this.fs.copyFile(absoluteFromSourceFile(sourceFile), newFilePath);\n      }\n    });\n  }\n\n  protected writeFile(file: FileToWrite, packagePath: AbsoluteFsPath, ngccFolder: AbsoluteFsPath):\n      void {\n    if (isDtsPath(file.path.replace(/\\.map$/, ''))) {\n      // This is either `.d.ts` or `.d.ts.map` file\n      super.writeFileAndBackup(file);\n    } else {\n      const relativePath = relative(packagePath, file.path);\n      const newFilePath = join(ngccFolder, relativePath);\n      this.fs.ensureDir(dirname(newFilePath));\n      this.fs.writeFile(newFilePath, file.contents);\n    }\n  }\n\n  protected updatePackageJson(\n      entryPoint: EntryPoint, formatProperties: EntryPointJsonProperty[],\n      ngccFolder: AbsoluteFsPath) {\n    if (formatProperties.length === 0) {\n      // No format properties need updating.\n      return;\n    }\n\n    const packageJson = entryPoint.packageJson;\n    const packageJsonPath = join(entryPoint.path, 'package.json');\n\n    // All format properties point to the same format-path.\n    const oldFormatProp = formatProperties[0] !;\n    const oldFormatPath = packageJson[oldFormatProp] !;\n    const oldAbsFormatPath = join(entryPoint.path, oldFormatPath);\n    const newAbsFormatPath = join(ngccFolder, relative(entryPoint.package, oldAbsFormatPath));\n    const newFormatPath = relative(entryPoint.path, newAbsFormatPath);\n\n    // Update all properties in `package.json` (both in memory and on disk).\n    const update = this.pkgJsonUpdater.createUpdate();\n\n    for (const formatProperty of formatProperties) {\n      if (packageJson[formatProperty] !== oldFormatPath) {\n        throw new Error(\n            `Unable to update '${packageJsonPath}': Format properties ` +\n            `(${formatProperties.join(', ')}) map to more than one format-path.`);\n      }\n\n      update.addChange([`${formatProperty}_ivy_ngcc`], newFormatPath);\n    }\n\n    update.writeChanges(packageJsonPath, packageJson);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new_entry_point_file_writer.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/writing/new_entry_point_file_writer.ts"],"names":[],"mappings":"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","sourcesContent":["\n/**\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 {AbsoluteFsPath, FileSystem, absoluteFromSourceFile, dirname, join, relative} from '../../../src/ngtsc/file_system';\nimport {isDtsPath} from '../../../src/ngtsc/util/src/typescript';\nimport {EntryPoint, EntryPointJsonProperty} from '../packages/entry_point';\nimport {EntryPointBundle} from '../packages/entry_point_bundle';\nimport {FileToWrite} from '../rendering/utils';\n\nimport {InPlaceFileWriter} from './in_place_file_writer';\nimport {PackageJsonUpdater} from './package_json_updater';\n\nexport const NGCC_DIRECTORY = '__ivy_ngcc__';\nexport const NGCC_PROPERTY_EXTENSION = '_ivy_ngcc';\n\n/**\n * This FileWriter creates a copy of the original entry-point, then writes the transformed\n * files onto the files in this copy, and finally updates the package.json with a new\n * entry-point format property that points to this new entry-point.\n *\n * If there are transformed typings files in this bundle, they are updated in-place (see the\n * `InPlaceFileWriter`).\n */\nexport class NewEntryPointFileWriter extends InPlaceFileWriter {\n  constructor(fs: FileSystem, private pkgJsonUpdater: PackageJsonUpdater) { super(fs); }\n\n  writeBundle(\n      bundle: EntryPointBundle, transformedFiles: FileToWrite[],\n      formatProperties: EntryPointJsonProperty[]) {\n    // The new folder is at the root of the overall package\n    const entryPoint = bundle.entryPoint;\n    const ngccFolder = join(entryPoint.package, NGCC_DIRECTORY);\n    this.copyBundle(bundle, entryPoint.package, ngccFolder);\n    transformedFiles.forEach(file => this.writeFile(file, entryPoint.package, ngccFolder));\n    this.updatePackageJson(entryPoint, formatProperties, ngccFolder);\n  }\n\n  protected copyBundle(\n      bundle: EntryPointBundle, packagePath: AbsoluteFsPath, ngccFolder: AbsoluteFsPath) {\n    bundle.src.program.getSourceFiles().forEach(sourceFile => {\n      const relativePath = relative(packagePath, absoluteFromSourceFile(sourceFile));\n      const isOutsidePackage = relativePath.startsWith('..');\n      if (!sourceFile.isDeclarationFile && !isOutsidePackage) {\n        const newFilePath = join(ngccFolder, relativePath);\n        this.fs.ensureDir(dirname(newFilePath));\n        this.fs.copyFile(absoluteFromSourceFile(sourceFile), newFilePath);\n      }\n    });\n  }\n\n  protected writeFile(file: FileToWrite, packagePath: AbsoluteFsPath, ngccFolder: AbsoluteFsPath):\n      void {\n    if (isDtsPath(file.path.replace(/\\.map$/, ''))) {\n      // This is either `.d.ts` or `.d.ts.map` file\n      super.writeFileAndBackup(file);\n    } else {\n      const relativePath = relative(packagePath, file.path);\n      const newFilePath = join(ngccFolder, relativePath);\n      this.fs.ensureDir(dirname(newFilePath));\n      this.fs.writeFile(newFilePath, file.contents);\n    }\n  }\n\n  protected updatePackageJson(\n      entryPoint: EntryPoint, formatProperties: EntryPointJsonProperty[],\n      ngccFolder: AbsoluteFsPath) {\n    if (formatProperties.length === 0) {\n      // No format properties need updating.\n      return;\n    }\n\n    const packageJson = entryPoint.packageJson;\n    const packageJsonPath = join(entryPoint.path, 'package.json');\n\n    // All format properties point to the same format-path.\n    const oldFormatProp = formatProperties[0] !;\n    const oldFormatPath = packageJson[oldFormatProp] !;\n    const oldAbsFormatPath = join(entryPoint.path, oldFormatPath);\n    const newAbsFormatPath = join(ngccFolder, relative(entryPoint.package, oldAbsFormatPath));\n    const newFormatPath = relative(entryPoint.path, newAbsFormatPath);\n\n    // Update all properties in `package.json` (both in memory and on disk).\n    const update = this.pkgJsonUpdater.createUpdate();\n\n    for (const formatProperty of formatProperties) {\n      if (packageJson[formatProperty] !== oldFormatPath) {\n        throw new Error(\n            `Unable to update '${packageJsonPath}': Format properties ` +\n            `(${formatProperties.join(', ')}) map to more than one format-path.`);\n      }\n\n      update.addChange(\n          [`${formatProperty}${NGCC_PROPERTY_EXTENSION}`], newFormatPath, {before: formatProperty});\n    }\n\n    update.writeChanges(packageJsonPath, packageJson);\n  }\n}\n"]}