@angular/compiler-cli 9.1.0 → 9.1.4

package/ngcc/src/sourcemaps/source_file_loader.d.ts

@@ -1,5 +1,6 @@
 /// <amd-module name="@angular/compiler-cli/ngcc/src/sourcemaps/source_file_loader" />
 import { AbsoluteFsPath, FileSystem } from '../../../src/ngtsc/file_system';
+import { Logger } from '../logging/logger';
 import { RawSourceMap } from './raw_source_map';
 import { SourceFile } from './source_file';
 /**
@@ -13,23 +14,32 @@ import { SourceFile } from './source_file';
  */
 export declare class SourceFileLoader {
     private fs;
-    constructor(fs: FileSystem);
+    private logger;
+    private currentPaths;
+    constructor(fs: FileSystem, logger: Logger);
     /**
      * Load a source file, compute its source map, and recursively load any referenced source files.
      *
      * @param sourcePath The path to the source file to load.
-     * @param contents The contents of the source file to load (if known).
-     * The contents may be known because the source file was inlined into a source map.
+     * @param contents The contents of the source file to load.
+     * @param mapAndPath The raw source-map and the path to the source-map file.
+     * @returns a SourceFile object created from the `contents` and provided source-map info.
+     */
+    loadSourceFile(sourcePath: AbsoluteFsPath, contents: string, mapAndPath: MapAndPath): SourceFile;
+    /**
+     * The overload used internally to load source files referenced in a source-map.
+     *
+     * In this case there is no guarantee that it will return a non-null SourceMap.
+     *
+     * @param sourcePath The path to the source file to load.
+     * @param contents The contents of the source file to load, if provided inline.
      * If it is not known the contents will be read from the file at the `sourcePath`.
-     * @param mapAndPath The raw source-map and the path to the source-map file, if known.
-     * @param previousPaths An internal parameter used for cyclic dependency tracking.
+     * @param mapAndPath The raw source-map and the path to the source-map file.
+     *
      * @returns a SourceFile if the content for one was provided or able to be loaded from disk,
      * `null` otherwise.
      */
-    loadSourceFile(sourcePath: AbsoluteFsPath, contents: string, mapAndPath: MapAndPath): SourceFile;
-    loadSourceFile(sourcePath: AbsoluteFsPath, contents: string | null): SourceFile | null;
-    loadSourceFile(sourcePath: AbsoluteFsPath): SourceFile | null;
-    loadSourceFile(sourcePath: AbsoluteFsPath, contents: string | null, mapAndPath: null, previousPaths: AbsoluteFsPath[]): SourceFile | null;
+    loadSourceFile(sourcePath: AbsoluteFsPath, contents?: string | null, mapAndPath?: null): SourceFile | null;
     /**
      * Find the source map associated with the source file whose `sourcePath` and `contents` are
      * provided.
@@ -43,11 +53,24 @@ export declare class SourceFileLoader {
      * source file and its associated source map.
      */
     private processSources;
+    /**
+     * Load the contents of the source file from disk.
+     *
+     * @param sourcePath The path to the source file.
+     */
+    private readSourceFile;
     /**
      * Load the source map from the file at `mapPath`, parsing its JSON contents into a `RawSourceMap`
      * object.
+     *
+     * @param mapPath The path to the source-map file.
+     */
+    private readRawSourceMap;
+    /**
+     * Track source file paths if we have loaded them from disk so that we don't get into an infinite
+     * recursion.
      */
-    private loadRawSourceMap;
+    private trackPath;
 }
 /** A small helper structure that is returned from `loadSourceMap()`. */
 interface MapAndPath {

package/ngcc/src/sourcemaps/source_file_loader.js

@@ -29,39 +29,45 @@
      * mappings to other `SourceFile` objects as necessary.
      */
     var SourceFileLoader = /** @class */ (function () {
-        function SourceFileLoader(fs) {
+        function SourceFileLoader(fs, logger) {
             this.fs = fs;
+            this.logger = logger;
+            this.currentPaths = [];
         }
-        SourceFileLoader.prototype.loadSourceFile = function (sourcePath, contents, mapAndPath, previousPaths) {
+        SourceFileLoader.prototype.loadSourceFile = function (sourcePath, contents, mapAndPath) {
             if (contents === void 0) { contents = null; }
             if (mapAndPath === void 0) { mapAndPath = null; }
-            if (previousPaths === void 0) { previousPaths = []; }
-            if (contents === null) {
-                if (!this.fs.exists(sourcePath)) {
-                    return null;
+            var previousPaths = this.currentPaths.slice();
+            try {
+                if (contents === null) {
+                    if (!this.fs.exists(sourcePath)) {
+                        return null;
+                    }
+                    contents = this.readSourceFile(sourcePath);
+                }
+                // If not provided try to load the source map based on the source itself
+                if (mapAndPath === null) {
+                    mapAndPath = this.loadSourceMap(sourcePath, contents);
                 }
-                // Track source file paths if we have loaded them from disk so that we don't get into an
-                // infinite recursion
-                if (previousPaths.includes(sourcePath)) {
-                    throw new Error("Circular source file mapping dependency: " + previousPaths.join(' -> ') + " -> " + sourcePath);
+                var map = null;
+                var inline = true;
+                var sources = [];
+                if (mapAndPath !== null) {
+                    var basePath = mapAndPath.mapPath || sourcePath;
+                    sources = this.processSources(basePath, mapAndPath.map);
+                    map = mapAndPath.map;
+                    inline = mapAndPath.mapPath === null;
                 }
-                previousPaths = previousPaths.concat([sourcePath]);
-                contents = this.fs.readFile(sourcePath);
+                return new source_file_1.SourceFile(sourcePath, contents, map, inline, sources);
             }
-            // If not provided try to load the source map based on the source itself
-            if (mapAndPath === null) {
-                mapAndPath = this.loadSourceMap(sourcePath, contents);
+            catch (e) {
+                this.logger.warn("Unable to fully load " + sourcePath + " for source-map flattening: " + e.message);
+                return null;
             }
-            var map = null;
-            var inline = true;
-            var sources = [];
-            if (mapAndPath !== null) {
-                var basePath = mapAndPath.mapPath || sourcePath;
-                sources = this.processSources(basePath, mapAndPath.map, previousPaths);
-                map = mapAndPath.map;
-                inline = mapAndPath.mapPath === null;
+            finally {
+                // We are finished with this recursion so revert the paths being tracked
+                this.currentPaths = previousPaths;
             }
-            return new source_file_1.SourceFile(sourcePath, contents, map, inline, sources);
         };
         /**
          * Find the source map associated with the source file whose `sourcePath` and `contents` are
@@ -80,15 +86,16 @@
                 try {
                     var fileName = external[1] || external[2];
                     var externalMapPath = this.fs.resolve(this.fs.dirname(sourcePath), fileName);
-                    return { map: this.loadRawSourceMap(externalMapPath), mapPath: externalMapPath };
+                    return { map: this.readRawSourceMap(externalMapPath), mapPath: externalMapPath };
                 }
-                catch (_a) {
+                catch (e) {
+                    this.logger.warn("Unable to fully load " + sourcePath + " for source-map flattening: " + e.message);
                     return null;
                 }
             }
             var impliedMapPath = file_system_1.absoluteFrom(sourcePath + '.map');
             if (this.fs.exists(impliedMapPath)) {
-                return { map: this.loadRawSourceMap(impliedMapPath), mapPath: impliedMapPath };
+                return { map: this.readRawSourceMap(impliedMapPath), mapPath: impliedMapPath };
             }
             return null;
         };
@@ -96,24 +103,46 @@
          * Iterate over each of the "sources" for this source file's source map, recursively loading each
          * source file and its associated source map.
          */
-        SourceFileLoader.prototype.processSources = function (basePath, map, previousPaths) {
+        SourceFileLoader.prototype.processSources = function (basePath, map) {
             var _this = this;
             var sourceRoot = this.fs.resolve(this.fs.dirname(basePath), map.sourceRoot || '');
             return map.sources.map(function (source, index) {
                 var path = _this.fs.resolve(sourceRoot, source);
                 var content = map.sourcesContent && map.sourcesContent[index] || null;
-                return _this.loadSourceFile(path, content, null, previousPaths);
+                return _this.loadSourceFile(path, content, null);
             });
         };
+        /**
+         * Load the contents of the source file from disk.
+         *
+         * @param sourcePath The path to the source file.
+         */
+        SourceFileLoader.prototype.readSourceFile = function (sourcePath) {
+            this.trackPath(sourcePath);
+            return this.fs.readFile(sourcePath);
+        };
         /**
          * Load the source map from the file at `mapPath`, parsing its JSON contents into a `RawSourceMap`
          * object.
+         *
+         * @param mapPath The path to the source-map file.
          */
-        SourceFileLoader.prototype.loadRawSourceMap = function (mapPath) {
+        SourceFileLoader.prototype.readRawSourceMap = function (mapPath) {
+            this.trackPath(mapPath);
             return JSON.parse(this.fs.readFile(mapPath));
         };
+        /**
+         * Track source file paths if we have loaded them from disk so that we don't get into an infinite
+         * recursion.
+         */
+        SourceFileLoader.prototype.trackPath = function (path) {
+            if (this.currentPaths.includes(path)) {
+                throw new Error("Circular source file mapping dependency: " + this.currentPaths.join(' -> ') + " -> " + path);
+            }
+            this.currentPaths.push(path);
+        };
         return SourceFileLoader;
     }());
     exports.SourceFileLoader = SourceFileLoader;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_file_loader.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/sourcemaps/source_file_loader.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 {commentRegex, fromComment, mapFileCommentRegex} from 'convert-source-map';\nimport {AbsoluteFsPath, FileSystem, absoluteFrom} from '../../../src/ngtsc/file_system';\nimport {RawSourceMap} from './raw_source_map';\nimport {SourceFile} from './source_file';\n\n/**\n * This class can be used to load a source file, its associated source map and any upstream sources.\n *\n * Since a source file might reference (or include) a source map, this class can load those too.\n * Since a source map might reference other source files, these are also loaded as needed.\n *\n * This is done recursively. The result is a \"tree\" of `SourceFile` objects, each containing\n * mappings to other `SourceFile` objects as necessary.\n */\nexport class SourceFileLoader {\n  constructor(private fs: FileSystem) {}\n\n  /**\n   * Load a source file, compute its source map, and recursively load any referenced source files.\n   *\n   * @param sourcePath The path to the source file to load.\n   * @param contents The contents of the source file to load (if known).\n   * The contents may be known because the source file was inlined into a source map.\n   * If it is not known the contents will be read from the file at the `sourcePath`.\n   * @param mapAndPath The raw source-map and the path to the source-map file, if known.\n   * @param previousPaths An internal parameter used for cyclic dependency tracking.\n   * @returns a SourceFile if the content for one was provided or able to be loaded from disk,\n   * `null` otherwise.\n   */\n  loadSourceFile(sourcePath: AbsoluteFsPath, contents: string, mapAndPath: MapAndPath): SourceFile;\n  loadSourceFile(sourcePath: AbsoluteFsPath, contents: string|null): SourceFile|null;\n  loadSourceFile(sourcePath: AbsoluteFsPath): SourceFile|null;\n  loadSourceFile(\n      sourcePath: AbsoluteFsPath, contents: string|null, mapAndPath: null,\n      previousPaths: AbsoluteFsPath[]): SourceFile|null;\n  loadSourceFile(\n      sourcePath: AbsoluteFsPath, contents: string|null = null, mapAndPath: MapAndPath|null = null,\n      previousPaths: AbsoluteFsPath[] = []): SourceFile|null {\n    if (contents === null) {\n      if (!this.fs.exists(sourcePath)) {\n        return null;\n      }\n\n      // Track source file paths if we have loaded them from disk so that we don't get into an\n      // infinite recursion\n      if (previousPaths.includes(sourcePath)) {\n        throw new Error(\n            `Circular source file mapping dependency: ${previousPaths.join(' -> ')} -> ${sourcePath}`);\n      }\n      previousPaths = previousPaths.concat([sourcePath]);\n\n      contents = this.fs.readFile(sourcePath);\n    }\n\n    // If not provided try to load the source map based on the source itself\n    if (mapAndPath === null) {\n      mapAndPath = this.loadSourceMap(sourcePath, contents);\n    }\n\n    let map: RawSourceMap|null = null;\n    let inline = true;\n    let sources: (SourceFile | null)[] = [];\n    if (mapAndPath !== null) {\n      const basePath = mapAndPath.mapPath || sourcePath;\n      sources = this.processSources(basePath, mapAndPath.map, previousPaths);\n      map = mapAndPath.map;\n      inline = mapAndPath.mapPath === null;\n    }\n\n    return new SourceFile(sourcePath, contents, map, inline, sources);\n  }\n\n  /**\n   * Find the source map associated with the source file whose `sourcePath` and `contents` are\n   * provided.\n   *\n   * Source maps can be inline, as part of a base64 encoded comment, or external as a separate file\n   * whose path is indicated in a comment or implied from the name of the source file itself.\n   */\n  private loadSourceMap(sourcePath: AbsoluteFsPath, contents: string): MapAndPath|null {\n    const inline = commentRegex.exec(contents);\n    if (inline !== null) {\n      return {map: fromComment(inline.pop() !).sourcemap, mapPath: null};\n    }\n\n    const external = mapFileCommentRegex.exec(contents);\n    if (external) {\n      try {\n        const fileName = external[1] || external[2];\n        const externalMapPath = this.fs.resolve(this.fs.dirname(sourcePath), fileName);\n        return {map: this.loadRawSourceMap(externalMapPath), mapPath: externalMapPath};\n      } catch {\n        return null;\n      }\n    }\n\n    const impliedMapPath = absoluteFrom(sourcePath + '.map');\n    if (this.fs.exists(impliedMapPath)) {\n      return {map: this.loadRawSourceMap(impliedMapPath), mapPath: impliedMapPath};\n    }\n\n    return null;\n  }\n\n  /**\n   * Iterate over each of the \"sources\" for this source file's source map, recursively loading each\n   * source file and its associated source map.\n   */\n  private processSources(\n      basePath: AbsoluteFsPath, map: RawSourceMap,\n      previousPaths: AbsoluteFsPath[]): (SourceFile|null)[] {\n    const sourceRoot = this.fs.resolve(this.fs.dirname(basePath), map.sourceRoot || '');\n    return map.sources.map((source, index) => {\n      const path = this.fs.resolve(sourceRoot, source);\n      const content = map.sourcesContent && map.sourcesContent[index] || null;\n      return this.loadSourceFile(path, content, null, previousPaths);\n    });\n  }\n\n  /**\n   * Load the source map from the file at `mapPath`, parsing its JSON contents into a `RawSourceMap`\n   * object.\n   */\n  private loadRawSourceMap(mapPath: AbsoluteFsPath): RawSourceMap {\n    return JSON.parse(this.fs.readFile(mapPath));\n  }\n}\n\n/** A small helper structure that is returned from `loadSourceMap()`. */\ninterface MapAndPath {\n  /** The path to the source map if it was external or `null` if it was inline. */\n  mapPath: AbsoluteFsPath|null;\n  /** The raw source map itself. */\n  map: RawSourceMap;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source_file_loader.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/sourcemaps/source_file_loader.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 {commentRegex, fromComment, mapFileCommentRegex} from 'convert-source-map';\n\nimport {absoluteFrom, AbsoluteFsPath, FileSystem} from '../../../src/ngtsc/file_system';\nimport {Logger} from '../logging/logger';\n\nimport {RawSourceMap} from './raw_source_map';\nimport {SourceFile} from './source_file';\n\n/**\n * This class can be used to load a source file, its associated source map and any upstream sources.\n *\n * Since a source file might reference (or include) a source map, this class can load those too.\n * Since a source map might reference other source files, these are also loaded as needed.\n *\n * This is done recursively. The result is a \"tree\" of `SourceFile` objects, each containing\n * mappings to other `SourceFile` objects as necessary.\n */\nexport class SourceFileLoader {\n  private currentPaths: AbsoluteFsPath[] = [];\n\n  constructor(private fs: FileSystem, private logger: Logger) {}\n\n  /**\n   * Load a source file, compute its source map, and recursively load any referenced source files.\n   *\n   * @param sourcePath The path to the source file to load.\n   * @param contents The contents of the source file to load.\n   * @param mapAndPath The raw source-map and the path to the source-map file.\n   * @returns a SourceFile object created from the `contents` and provided source-map info.\n   */\n  loadSourceFile(sourcePath: AbsoluteFsPath, contents: string, mapAndPath: MapAndPath): SourceFile;\n  /**\n   * The overload used internally to load source files referenced in a source-map.\n   *\n   * In this case there is no guarantee that it will return a non-null SourceMap.\n   *\n   * @param sourcePath The path to the source file to load.\n   * @param contents The contents of the source file to load, if provided inline.\n   * If it is not known the contents will be read from the file at the `sourcePath`.\n   * @param mapAndPath The raw source-map and the path to the source-map file.\n   *\n   * @returns a SourceFile if the content for one was provided or able to be loaded from disk,\n   * `null` otherwise.\n   */\n  loadSourceFile(sourcePath: AbsoluteFsPath, contents?: string|null, mapAndPath?: null): SourceFile\n      |null;\n  loadSourceFile(\n      sourcePath: AbsoluteFsPath, contents: string|null = null,\n      mapAndPath: MapAndPath|null = null): SourceFile|null {\n    const previousPaths = this.currentPaths.slice();\n    try {\n      if (contents === null) {\n        if (!this.fs.exists(sourcePath)) {\n          return null;\n        }\n        contents = this.readSourceFile(sourcePath);\n      }\n\n      // If not provided try to load the source map based on the source itself\n      if (mapAndPath === null) {\n        mapAndPath = this.loadSourceMap(sourcePath, contents);\n      }\n\n      let map: RawSourceMap|null = null;\n      let inline = true;\n      let sources: (SourceFile|null)[] = [];\n      if (mapAndPath !== null) {\n        const basePath = mapAndPath.mapPath || sourcePath;\n        sources = this.processSources(basePath, mapAndPath.map);\n        map = mapAndPath.map;\n        inline = mapAndPath.mapPath === null;\n      }\n\n      return new SourceFile(sourcePath, contents, map, inline, sources);\n    } catch (e) {\n      this.logger.warn(\n          `Unable to fully load ${sourcePath} for source-map flattening: ${e.message}`);\n      return null;\n    } finally {\n      // We are finished with this recursion so revert the paths being tracked\n      this.currentPaths = previousPaths;\n    }\n  }\n\n  /**\n   * Find the source map associated with the source file whose `sourcePath` and `contents` are\n   * provided.\n   *\n   * Source maps can be inline, as part of a base64 encoded comment, or external as a separate file\n   * whose path is indicated in a comment or implied from the name of the source file itself.\n   */\n  private loadSourceMap(sourcePath: AbsoluteFsPath, contents: string): MapAndPath|null {\n    const inline = commentRegex.exec(contents);\n    if (inline !== null) {\n      return {map: fromComment(inline.pop()!).sourcemap, mapPath: null};\n    }\n\n    const external = mapFileCommentRegex.exec(contents);\n    if (external) {\n      try {\n        const fileName = external[1] || external[2];\n        const externalMapPath = this.fs.resolve(this.fs.dirname(sourcePath), fileName);\n        return {map: this.readRawSourceMap(externalMapPath), mapPath: externalMapPath};\n      } catch (e) {\n        this.logger.warn(\n            `Unable to fully load ${sourcePath} for source-map flattening: ${e.message}`);\n        return null;\n      }\n    }\n\n    const impliedMapPath = absoluteFrom(sourcePath + '.map');\n    if (this.fs.exists(impliedMapPath)) {\n      return {map: this.readRawSourceMap(impliedMapPath), mapPath: impliedMapPath};\n    }\n\n    return null;\n  }\n\n  /**\n   * Iterate over each of the \"sources\" for this source file's source map, recursively loading each\n   * source file and its associated source map.\n   */\n  private processSources(basePath: AbsoluteFsPath, map: RawSourceMap): (SourceFile|null)[] {\n    const sourceRoot = this.fs.resolve(this.fs.dirname(basePath), map.sourceRoot || '');\n    return map.sources.map((source, index) => {\n      const path = this.fs.resolve(sourceRoot, source);\n      const content = map.sourcesContent && map.sourcesContent[index] || null;\n      return this.loadSourceFile(path, content, null);\n    });\n  }\n\n  /**\n   * Load the contents of the source file from disk.\n   *\n   * @param sourcePath The path to the source file.\n   */\n  private readSourceFile(sourcePath: AbsoluteFsPath): string {\n    this.trackPath(sourcePath);\n    return this.fs.readFile(sourcePath);\n  }\n\n  /**\n   * Load the source map from the file at `mapPath`, parsing its JSON contents into a `RawSourceMap`\n   * object.\n   *\n   * @param mapPath The path to the source-map file.\n   */\n  private readRawSourceMap(mapPath: AbsoluteFsPath): RawSourceMap {\n    this.trackPath(mapPath);\n    return JSON.parse(this.fs.readFile(mapPath));\n  }\n\n  /**\n   * Track source file paths if we have loaded them from disk so that we don't get into an infinite\n   * recursion.\n   */\n  private trackPath(path: AbsoluteFsPath): void {\n    if (this.currentPaths.includes(path)) {\n      throw new Error(\n          `Circular source file mapping dependency: ${this.currentPaths.join(' -> ')} -> ${path}`);\n    }\n    this.currentPaths.push(path);\n  }\n}\n\n/** A small helper structure that is returned from `loadSourceMap()`. */\ninterface MapAndPath {\n  /** The path to the source map if it was external or `null` if it was inline. */\n  mapPath: AbsoluteFsPath|null;\n  /** The raw source map itself. */\n  map: RawSourceMap;\n}\n"]}

package/ngcc/src/utils.d.ts

@@ -46,16 +46,11 @@ 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 `..`.
+ * Relative paths start with `/`, `./` or `../` (or the Windows equivalents); or are simply `.` or
+ * `..`.
  */
 export declare function isRelativePath(path: string): boolean;
 /**

package/ngcc/src/utils.js

@@ -67,10 +67,11 @@
     /**
      * Test whether a path is "relative".
      *
-     * Relative paths start with `/`, `./` or `../`; or are simply `.` or `..`.
+     * Relative paths start with `/`, `./` or `../` (or the Windows equivalents); or are simply `.` or
+     * `..`.
      */
     function isRelativePath(path) {
-        return /^\/|^\.\.?($|\/)/.test(path);
+        return file_system_1.isRooted(path) || /^\.\.?(\/|\\|$)/.test(path);
     }
     exports.isRelativePath = isRelativePath;
     /**
@@ -93,7 +94,9 @@
             }
             return this.internalMap.get(key);
         };
-        FactoryMap.prototype.set = function (key, value) { this.internalMap.set(key, value); };
+        FactoryMap.prototype.set = function (key, value) {
+            this.internalMap.set(key, value);
+        };
         return FactoryMap;
     }());
     exports.FactoryMap = FactoryMap;
@@ -171,4 +174,4 @@
     }
     exports.stripExtension = stripExtension;
 });
-//# 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';\nimport {KnownDeclaration} from '../../src/ngtsc/reflection';\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 * Determine whether a function declaration corresponds with a TypeScript helper function, returning\n * its kind if so or null if the declaration does not seem to correspond with such a helper.\n */\nexport function getTsHelperFnFromDeclaration(decl: ts.Declaration): KnownDeclaration|null {\n  if (!ts.isFunctionDeclaration(decl) && !ts.isVariableDeclaration(decl)) {\n    return null;\n  }\n\n  if (decl.name === undefined || !ts.isIdentifier(decl.name)) {\n    return null;\n  }\n\n  return getTsHelperFnFromIdentifier(decl.name);\n}\n\n/**\n * Determine whether an identifier corresponds with a TypeScript helper function (based on its\n * name), returning its kind if so or null if the identifier does not seem to correspond with such a\n * helper.\n */\nexport function getTsHelperFnFromIdentifier(id: ts.Identifier): KnownDeclaration|null {\n  switch (stripDollarSuffix(id.text)) {\n    case '__assign':\n      return KnownDeclaration.TsHelperAssign;\n    case '__spread':\n      return KnownDeclaration.TsHelperSpread;\n    case '__spreadArrays':\n      return KnownDeclaration.TsHelperSpreadArrays;\n    default:\n      return null;\n  }\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"]}
+//# 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';\n\nimport {absoluteFrom, AbsoluteFsPath, FileSystem, isRooted} from '../../src/ngtsc/file_system';\nimport {KnownDeclaration} from '../../src/ngtsc/reflection';\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\n/**\n * Test whether a path is \"relative\".\n *\n * Relative paths start with `/`, `./` or `../` (or the Windows equivalents); or are simply `.` or\n * `..`.\n */\nexport function isRelativePath(path: string): boolean {\n  return isRooted(path) || /^\\.\\.?(\\/|\\\\|$)/.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 {\n    this.internalMap.set(key, value);\n  }\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 * Determine whether a function declaration corresponds with a TypeScript helper function, returning\n * its kind if so or null if the declaration does not seem to correspond with such a helper.\n */\nexport function getTsHelperFnFromDeclaration(decl: ts.Declaration): KnownDeclaration|null {\n  if (!ts.isFunctionDeclaration(decl) && !ts.isVariableDeclaration(decl)) {\n    return null;\n  }\n\n  if (decl.name === undefined || !ts.isIdentifier(decl.name)) {\n    return null;\n  }\n\n  return getTsHelperFnFromIdentifier(decl.name);\n}\n\n/**\n * Determine whether an identifier corresponds with a TypeScript helper function (based on its\n * name), returning its kind if so or null if the identifier does not seem to correspond with such a\n * helper.\n */\nexport function getTsHelperFnFromIdentifier(id: ts.Identifier): KnownDeclaration|null {\n  switch (stripDollarSuffix(id.text)) {\n    case '__assign':\n      return KnownDeclaration.TsHelperAssign;\n    case '__spread':\n      return KnownDeclaration.TsHelperSpread;\n    case '__spreadArrays':\n      return KnownDeclaration.TsHelperSpreadArrays;\n    default:\n      return null;\n  }\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

@@ -8,8 +8,8 @@
  */
 import { AbsoluteFsPath, FileSystem, PathSegment } from '../../../../src/ngtsc/file_system';
 /**
-* Implement this interface to extend the cleaning strategies of the `PackageCleaner`.
-*/
+ * 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;

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

@@ -51,7 +51,9 @@
         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); };
+        NgccDirectoryCleaner.prototype.clean = function (path, _basename) {
+            this.fs.removeDeep(path);
+        };
         return NgccDirectoryCleaner;
     }());
     exports.NgccDirectoryCleaner = NgccDirectoryCleaner;
@@ -74,4 +76,4 @@
     }());
     exports.BackupFileCleaner = BackupFileCleaner;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/writing/in_place_file_writer.js

@@ -56,4 +56,4 @@
     }());
     exports.InPlaceFileWriter = InPlaceFileWriter;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/ngcc/src/writing/new_entry_point_file_writer.js

@@ -109,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 {Logger} from '../logging/logger';\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(\n      fs: FileSystem, logger: Logger, errorOnFailedEntryPoint: boolean,\n      private pkgJsonUpdater: PackageJsonUpdater) {\n    super(fs, logger, errorOnFailedEntryPoint);\n  }\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"]}
+//# 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":";;;;;;;;;;;;IACA;;;;;;OAMG;IACH,2EAA2H;IAC3H,kFAAiE;IAMjE,oGAAyD;IAG5C,QAAA,cAAc,GAAG,cAAc,CAAC;IAChC,QAAA,uBAAuB,GAAG,WAAW,CAAC;IAEnD;;;;;;;OAOG;IACH;QAA6C,mDAAiB;QAC5D,iCACI,EAAc,EAAE,MAAc,EAAE,uBAAgC,EACxD,cAAkC;YAF9C,YAGE,kBAAM,EAAE,EAAE,MAAM,EAAE,uBAAuB,CAAC,SAC3C;YAFW,oBAAc,GAAd,cAAc,CAAoB;;QAE9C,CAAC;QAED,6CAAW,GAAX,UACI,MAAwB,EAAE,gBAA+B,EACzD,gBAA0C;YAF9C,iBASC;YANC,uDAAuD;YACvD,IAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;YACrC,IAAM,UAAU,GAAG,kBAAI,CAAC,UAAU,CAAC,OAAO,EAAE,sBAAc,CAAC,CAAC;YAC5D,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YACxD,gBAAgB,CAAC,OAAO,CAAC,UAAA,IAAI,IAAI,OAAA,KAAI,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,EAApD,CAAoD,CAAC,CAAC;YACvF,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QACnE,CAAC;QAES,4CAAU,GAApB,UACI,MAAwB,EAAE,WAA2B,EAAE,UAA0B;YADrF,iBAWC;YATC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,OAAO,CAAC,UAAA,UAAU;gBACpD,IAAM,YAAY,GAAG,sBAAQ,CAAC,WAAW,EAAE,oCAAsB,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC/E,IAAM,gBAAgB,GAAG,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBACvD,IAAI,CAAC,UAAU,CAAC,iBAAiB,IAAI,CAAC,gBAAgB,EAAE;oBACtD,IAAM,WAAW,GAAG,kBAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;oBACnD,KAAI,CAAC,EAAE,CAAC,SAAS,CAAC,qBAAO,CAAC,WAAW,CAAC,CAAC,CAAC;oBACxC,KAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,oCAAsB,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,CAAC;iBACnE;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAES,2CAAS,GAAnB,UAAoB,IAAiB,EAAE,WAA2B,EAAE,UAA0B;YAE5F,IAAI,sBAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,EAAE;gBAC9C,6CAA6C;gBAC7C,iBAAM,kBAAkB,YAAC,IAAI,CAAC,CAAC;aAChC;iBAAM;gBACL,IAAM,YAAY,GAAG,sBAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtD,IAAM,WAAW,GAAG,kBAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;gBACnD,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,qBAAO,CAAC,WAAW,CAAC,CAAC,CAAC;gBACxC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC/C;QACH,CAAC;QAES,mDAAiB,GAA3B,UACI,UAAsB,EAAE,gBAA0C,EAClE,UAA0B;;YAC5B,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE;gBACjC,sCAAsC;gBACtC,OAAO;aACR;YAED,IAAM,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;YAC3C,IAAM,eAAe,GAAG,kBAAI,CAAC,UAAU,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;YAE9D,uDAAuD;YACvD,IAAM,aAAa,GAAG,gBAAgB,CAAC,CAAC,CAAE,CAAC;YAC3C,IAAM,aAAa,GAAG,WAAW,CAAC,aAAa,CAAE,CAAC;YAClD,IAAM,gBAAgB,GAAG,kBAAI,CAAC,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;YAC9D,IAAM,gBAAgB,GAAG,kBAAI,CAAC,UAAU,EAAE,sBAAQ,CAAC,UAAU,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC;YAC1F,IAAM,aAAa,GAAG,sBAAQ,CAAC,UAAU,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;YAElE,wEAAwE;YACxE,IAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;;gBAElD,KAA6B,IAAA,qBAAA,iBAAA,gBAAgB,CAAA,kDAAA,gFAAE;oBAA1C,IAAM,cAAc,6BAAA;oBACvB,IAAI,WAAW,CAAC,cAAc,CAAC,KAAK,aAAa,EAAE;wBACjD,MAAM,IAAI,KAAK,CACX,uBAAqB,eAAe,0BAAuB;6BAC3D,MAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,wCAAqC,CAAA,CAAC,CAAC;qBAC3E;oBAED,MAAM,CAAC,SAAS,CACZ,CAAC,KAAG,cAAc,GAAG,+BAAyB,CAAC,EAAE,aAAa,EAAE,EAAC,MAAM,EAAE,cAAc,EAAC,CAAC,CAAC;iBAC/F;;;;;;;;;YAED,MAAM,CAAC,YAAY,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QACpD,CAAC;QACH,8BAAC;IAAD,CAAC,AA9ED,CAA6C,wCAAiB,GA8E7D;IA9EY,0DAAuB","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 {absoluteFromSourceFile, AbsoluteFsPath, dirname, FileSystem, join, relative} from '../../../src/ngtsc/file_system';\nimport {isDtsPath} from '../../../src/ngtsc/util/src/typescript';\nimport {Logger} from '../logging/logger';\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(\n      fs: FileSystem, logger: Logger, errorOnFailedEntryPoint: boolean,\n      private pkgJsonUpdater: PackageJsonUpdater) {\n    super(fs, logger, errorOnFailedEntryPoint);\n  }\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"]}

package/ngcc/src/writing/package_json_updater.js

@@ -176,4 +176,4 @@
         }
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"package_json_updater.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/writing/package_json_updater.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 */\n\nimport {AbsoluteFsPath, FileSystem, dirname} from '../../../src/ngtsc/file_system';\nimport {JsonObject, JsonValue} from '../packages/entry_point';\n\n\nexport type PackageJsonChange = [string[], JsonValue, PackageJsonPropertyPositioning];\nexport type PackageJsonPropertyPositioning = 'unimportant' | 'alphabetic' | {before: string};\nexport type WritePackageJsonChangesFn =\n    (changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject) =>\n        void;\n\n/**\n * A utility object that can be used to safely update values in a `package.json` file.\n *\n * Example usage:\n * ```ts\n * const updatePackageJson = packageJsonUpdater\n *     .createUpdate()\n *     .addChange(['name'], 'package-foo')\n *     .addChange(['scripts', 'foo'], 'echo FOOOO...', 'unimportant')\n *     .addChange(['dependencies', 'baz'], '1.0.0', 'alphabetic')\n *     .addChange(['dependencies', 'bar'], '2.0.0', {before: 'baz'})\n *     .writeChanges('/foo/package.json');\n *     // or\n *     // .writeChanges('/foo/package.json', inMemoryParsedJson);\n * ```\n */\nexport interface PackageJsonUpdater {\n  /**\n   * Create a `PackageJsonUpdate` object, which provides a fluent API for batching updates to a\n   * `package.json` file. (Batching the updates is useful, because it avoids unnecessary I/O\n   * operations.)\n   */\n  createUpdate(): PackageJsonUpdate;\n\n  /**\n   * Write a set of changes to the specified `package.json` file (and optionally a pre-existing,\n   * in-memory representation of it).\n   *\n   * @param changes The set of changes to apply.\n   * @param packageJsonPath The path to the `package.json` file that needs to be updated.\n   * @param parsedJson A pre-existing, in-memory representation of the `package.json` file that\n   *                   needs to be updated as well.\n   */\n  writeChanges(\n      changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject): void;\n}\n\n/**\n * A utility class providing a fluent API for recording multiple changes to a `package.json` file\n * (and optionally its in-memory parsed representation).\n *\n * NOTE: This class should generally not be instantiated directly; instances are implicitly created\n *       via `PackageJsonUpdater#createUpdate()`.\n */\nexport class PackageJsonUpdate {\n  private changes: PackageJsonChange[] = [];\n  private applied = false;\n\n  constructor(private writeChangesImpl: WritePackageJsonChangesFn) {}\n\n  /**\n   * Record a change to a `package.json` property.\n   *\n   * If the ancestor objects do not yet exist in the `package.json` file, they will be created. The\n   * positioning of the property can also be specified. (If the property already exists, it will be\n   * moved accordingly.)\n   *\n   * NOTE: Property positioning is only guaranteed to be respected in the serialized `package.json`\n   *       file. Positioning will not be taken into account when updating in-memory representations.\n   *\n   * NOTE 2: Property positioning only affects the last property in `propertyPath`. Ancestor\n   *         objects' positioning will not be affected.\n   *\n   * @param propertyPath The path of a (possibly nested) property to add/update.\n   * @param value The new value to set the property to.\n   * @param position The desired position for the added/updated property.\n   */\n  addChange(\n      propertyPath: string[], value: JsonValue,\n      positioning: PackageJsonPropertyPositioning = 'unimportant'): this {\n    this.ensureNotApplied();\n    this.changes.push([propertyPath, value, positioning]);\n    return this;\n  }\n\n  /**\n   * Write the recorded changes to the associated `package.json` file (and optionally a\n   * pre-existing, in-memory representation of it).\n   *\n   * @param packageJsonPath The path to the `package.json` file that needs to be updated.\n   * @param parsedJson A pre-existing, in-memory representation of the `package.json` file that\n   *                   needs to be updated as well.\n   */\n  writeChanges(packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject): void {\n    this.ensureNotApplied();\n    this.writeChangesImpl(this.changes, packageJsonPath, parsedJson);\n    this.applied = true;\n  }\n\n  private ensureNotApplied() {\n    if (this.applied) {\n      throw new Error('Trying to apply a `PackageJsonUpdate` that has already been applied.');\n    }\n  }\n}\n\n/** A `PackageJsonUpdater` that writes directly to the file-system. */\nexport class DirectPackageJsonUpdater implements PackageJsonUpdater {\n  constructor(private fs: FileSystem) {}\n\n  createUpdate(): PackageJsonUpdate {\n    return new PackageJsonUpdate((...args) => this.writeChanges(...args));\n  }\n\n  writeChanges(\n      changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath,\n      preExistingParsedJson?: JsonObject): void {\n    if (changes.length === 0) {\n      throw new Error(`No changes to write to '${packageJsonPath}'.`);\n    }\n\n    // Read and parse the `package.json` content.\n    // NOTE: We are not using `preExistingParsedJson` (even if specified) to avoid corrupting the\n    //       content on disk in case `preExistingParsedJson` is outdated.\n    const parsedJson =\n        this.fs.exists(packageJsonPath) ? JSON.parse(this.fs.readFile(packageJsonPath)) : {};\n\n    // Apply all changes to both the canonical representation (read from disk) and any pre-existing,\n    // in-memory representation.\n    for (const [propPath, value, positioning] of changes) {\n      if (propPath.length === 0) {\n        throw new Error(`Missing property path for writing value to '${packageJsonPath}'.`);\n      }\n\n      applyChange(parsedJson, propPath, value, positioning);\n\n      if (preExistingParsedJson) {\n        // No need to take property positioning into account for in-memory representations.\n        applyChange(preExistingParsedJson, propPath, value, 'unimportant');\n      }\n    }\n\n    // Ensure the containing directory exists (in case this is a synthesized `package.json` due to a\n    // custom configuration) and write the updated content to disk.\n    this.fs.ensureDir(dirname(packageJsonPath));\n    this.fs.writeFile(packageJsonPath, `${JSON.stringify(parsedJson, null, 2)}\\n`);\n  }\n}\n\n// Helpers\nexport function applyChange(\n    ctx: JsonObject, propPath: string[], value: JsonValue,\n    positioning: PackageJsonPropertyPositioning): void {\n  const lastPropIdx = propPath.length - 1;\n  const lastProp = propPath[lastPropIdx];\n\n  for (let i = 0; i < lastPropIdx; i++) {\n    const key = propPath[i];\n    const newCtx = ctx.hasOwnProperty(key) ? ctx[key] : (ctx[key] = {});\n\n    if ((typeof newCtx !== 'object') || (newCtx === null) || Array.isArray(newCtx)) {\n      throw new Error(`Property path '${propPath.join('.')}' does not point to an object.`);\n    }\n\n    ctx = newCtx;\n  }\n\n  ctx[lastProp] = value;\n  positionProperty(ctx, lastProp, positioning);\n}\n\nfunction movePropBefore(ctx: JsonObject, prop: string, isNextProp: (p: string) => boolean): void {\n  const allProps = Object.keys(ctx);\n  const otherProps = allProps.filter(p => p !== prop);\n  const nextPropIdx = otherProps.findIndex(isNextProp);\n  const propsToShift = (nextPropIdx === -1) ? [] : otherProps.slice(nextPropIdx);\n\n  movePropToEnd(ctx, prop);\n  propsToShift.forEach(p => movePropToEnd(ctx, p));\n}\n\nfunction movePropToEnd(ctx: JsonObject, prop: string): void {\n  const value = ctx[prop];\n  delete ctx[prop];\n  ctx[prop] = value;\n}\n\nfunction positionProperty(\n    ctx: JsonObject, prop: string, positioning: PackageJsonPropertyPositioning): void {\n  switch (positioning) {\n    case 'alphabetic':\n      movePropBefore(ctx, prop, p => p > prop);\n      break;\n    case 'unimportant':\n      // Leave the property order unchanged; i.e. newly added properties will be last and existing\n      // ones will remain in their old position.\n      break;\n    default:\n      if ((typeof positioning !== 'object') || (positioning.before === undefined)) {\n        throw new Error(\n            `Unknown positioning (${JSON.stringify(positioning)}) for property '${prop}'.`);\n      }\n\n      movePropBefore(ctx, prop, p => p === positioning.before);\n      break;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"package_json_updater.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler-cli/ngcc/src/writing/package_json_updater.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 */\n\nimport {AbsoluteFsPath, dirname, FileSystem} from '../../../src/ngtsc/file_system';\nimport {JsonObject, JsonValue} from '../packages/entry_point';\n\n\nexport type PackageJsonChange = [string[], JsonValue, PackageJsonPropertyPositioning];\nexport type PackageJsonPropertyPositioning = 'unimportant'|'alphabetic'|{before: string};\nexport type WritePackageJsonChangesFn =\n    (changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject) =>\n        void;\n\n/**\n * A utility object that can be used to safely update values in a `package.json` file.\n *\n * Example usage:\n * ```ts\n * const updatePackageJson = packageJsonUpdater\n *     .createUpdate()\n *     .addChange(['name'], 'package-foo')\n *     .addChange(['scripts', 'foo'], 'echo FOOOO...', 'unimportant')\n *     .addChange(['dependencies', 'baz'], '1.0.0', 'alphabetic')\n *     .addChange(['dependencies', 'bar'], '2.0.0', {before: 'baz'})\n *     .writeChanges('/foo/package.json');\n *     // or\n *     // .writeChanges('/foo/package.json', inMemoryParsedJson);\n * ```\n */\nexport interface PackageJsonUpdater {\n  /**\n   * Create a `PackageJsonUpdate` object, which provides a fluent API for batching updates to a\n   * `package.json` file. (Batching the updates is useful, because it avoids unnecessary I/O\n   * operations.)\n   */\n  createUpdate(): PackageJsonUpdate;\n\n  /**\n   * Write a set of changes to the specified `package.json` file (and optionally a pre-existing,\n   * in-memory representation of it).\n   *\n   * @param changes The set of changes to apply.\n   * @param packageJsonPath The path to the `package.json` file that needs to be updated.\n   * @param parsedJson A pre-existing, in-memory representation of the `package.json` file that\n   *                   needs to be updated as well.\n   */\n  writeChanges(\n      changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject): void;\n}\n\n/**\n * A utility class providing a fluent API for recording multiple changes to a `package.json` file\n * (and optionally its in-memory parsed representation).\n *\n * NOTE: This class should generally not be instantiated directly; instances are implicitly created\n *       via `PackageJsonUpdater#createUpdate()`.\n */\nexport class PackageJsonUpdate {\n  private changes: PackageJsonChange[] = [];\n  private applied = false;\n\n  constructor(private writeChangesImpl: WritePackageJsonChangesFn) {}\n\n  /**\n   * Record a change to a `package.json` property.\n   *\n   * If the ancestor objects do not yet exist in the `package.json` file, they will be created. The\n   * positioning of the property can also be specified. (If the property already exists, it will be\n   * moved accordingly.)\n   *\n   * NOTE: Property positioning is only guaranteed to be respected in the serialized `package.json`\n   *       file. Positioning will not be taken into account when updating in-memory representations.\n   *\n   * NOTE 2: Property positioning only affects the last property in `propertyPath`. Ancestor\n   *         objects' positioning will not be affected.\n   *\n   * @param propertyPath The path of a (possibly nested) property to add/update.\n   * @param value The new value to set the property to.\n   * @param position The desired position for the added/updated property.\n   */\n  addChange(\n      propertyPath: string[], value: JsonValue,\n      positioning: PackageJsonPropertyPositioning = 'unimportant'): this {\n    this.ensureNotApplied();\n    this.changes.push([propertyPath, value, positioning]);\n    return this;\n  }\n\n  /**\n   * Write the recorded changes to the associated `package.json` file (and optionally a\n   * pre-existing, in-memory representation of it).\n   *\n   * @param packageJsonPath The path to the `package.json` file that needs to be updated.\n   * @param parsedJson A pre-existing, in-memory representation of the `package.json` file that\n   *                   needs to be updated as well.\n   */\n  writeChanges(packageJsonPath: AbsoluteFsPath, parsedJson?: JsonObject): void {\n    this.ensureNotApplied();\n    this.writeChangesImpl(this.changes, packageJsonPath, parsedJson);\n    this.applied = true;\n  }\n\n  private ensureNotApplied() {\n    if (this.applied) {\n      throw new Error('Trying to apply a `PackageJsonUpdate` that has already been applied.');\n    }\n  }\n}\n\n/** A `PackageJsonUpdater` that writes directly to the file-system. */\nexport class DirectPackageJsonUpdater implements PackageJsonUpdater {\n  constructor(private fs: FileSystem) {}\n\n  createUpdate(): PackageJsonUpdate {\n    return new PackageJsonUpdate((...args) => this.writeChanges(...args));\n  }\n\n  writeChanges(\n      changes: PackageJsonChange[], packageJsonPath: AbsoluteFsPath,\n      preExistingParsedJson?: JsonObject): void {\n    if (changes.length === 0) {\n      throw new Error(`No changes to write to '${packageJsonPath}'.`);\n    }\n\n    // Read and parse the `package.json` content.\n    // NOTE: We are not using `preExistingParsedJson` (even if specified) to avoid corrupting the\n    //       content on disk in case `preExistingParsedJson` is outdated.\n    const parsedJson =\n        this.fs.exists(packageJsonPath) ? JSON.parse(this.fs.readFile(packageJsonPath)) : {};\n\n    // Apply all changes to both the canonical representation (read from disk) and any pre-existing,\n    // in-memory representation.\n    for (const [propPath, value, positioning] of changes) {\n      if (propPath.length === 0) {\n        throw new Error(`Missing property path for writing value to '${packageJsonPath}'.`);\n      }\n\n      applyChange(parsedJson, propPath, value, positioning);\n\n      if (preExistingParsedJson) {\n        // No need to take property positioning into account for in-memory representations.\n        applyChange(preExistingParsedJson, propPath, value, 'unimportant');\n      }\n    }\n\n    // Ensure the containing directory exists (in case this is a synthesized `package.json` due to a\n    // custom configuration) and write the updated content to disk.\n    this.fs.ensureDir(dirname(packageJsonPath));\n    this.fs.writeFile(packageJsonPath, `${JSON.stringify(parsedJson, null, 2)}\\n`);\n  }\n}\n\n// Helpers\nexport function applyChange(\n    ctx: JsonObject, propPath: string[], value: JsonValue,\n    positioning: PackageJsonPropertyPositioning): void {\n  const lastPropIdx = propPath.length - 1;\n  const lastProp = propPath[lastPropIdx];\n\n  for (let i = 0; i < lastPropIdx; i++) {\n    const key = propPath[i];\n    const newCtx = ctx.hasOwnProperty(key) ? ctx[key] : (ctx[key] = {});\n\n    if ((typeof newCtx !== 'object') || (newCtx === null) || Array.isArray(newCtx)) {\n      throw new Error(`Property path '${propPath.join('.')}' does not point to an object.`);\n    }\n\n    ctx = newCtx;\n  }\n\n  ctx[lastProp] = value;\n  positionProperty(ctx, lastProp, positioning);\n}\n\nfunction movePropBefore(ctx: JsonObject, prop: string, isNextProp: (p: string) => boolean): void {\n  const allProps = Object.keys(ctx);\n  const otherProps = allProps.filter(p => p !== prop);\n  const nextPropIdx = otherProps.findIndex(isNextProp);\n  const propsToShift = (nextPropIdx === -1) ? [] : otherProps.slice(nextPropIdx);\n\n  movePropToEnd(ctx, prop);\n  propsToShift.forEach(p => movePropToEnd(ctx, p));\n}\n\nfunction movePropToEnd(ctx: JsonObject, prop: string): void {\n  const value = ctx[prop];\n  delete ctx[prop];\n  ctx[prop] = value;\n}\n\nfunction positionProperty(\n    ctx: JsonObject, prop: string, positioning: PackageJsonPropertyPositioning): void {\n  switch (positioning) {\n    case 'alphabetic':\n      movePropBefore(ctx, prop, p => p > prop);\n      break;\n    case 'unimportant':\n      // Leave the property order unchanged; i.e. newly added properties will be last and existing\n      // ones will remain in their old position.\n      break;\n    default:\n      if ((typeof positioning !== 'object') || (positioning.before === undefined)) {\n        throw new Error(\n            `Unknown positioning (${JSON.stringify(positioning)}) for property '${prop}'.`);\n      }\n\n      movePropBefore(ctx, prop, p => p === positioning.before);\n      break;\n  }\n}\n"]}