@angular/compiler-cli 7.2.0-beta.0 → 7.2.0

package/src/ngcc/src/packages/entry_point.d.ts

@@ -7,20 +7,24 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngcc/src/packages/entry_point" />
 /**
- * The possible values for the format of an entry-point.
+ * An object containing paths to the entry-points for each format.
  */
-export declare type EntryPointFormat = 'esm5' | 'fesm5' | 'esm2015' | 'fesm2015' | 'umd';
+export interface EntryPointPaths {
+    esm5?: string;
+    fesm5?: string;
+    esm2015?: string;
+    fesm2015?: string;
+    umd?: string;
+}
 /**
- * An object containing paths to the entry-points for each format.
+ * The possible values for the format of an entry-point.
  */
-export declare type EntryPointPaths = {
-    [Format in EntryPointFormat]?: string;
-};
+export declare type EntryPointFormat = keyof (EntryPointPaths);
 /**
  * An object containing information about an entry-point, including paths
  * to each of the possible entry-point formats.
  */
-export declare type EntryPoint = EntryPointPaths & {
+export interface EntryPoint extends EntryPointPaths {
     /** The name of the package (e.g. `@angular/core`). */
     name: string;
     /** The path to the package that contains this entry-point. */
@@ -29,11 +33,11 @@ export declare type EntryPoint = EntryPointPaths & {
     path: string;
     /** The path to a typings (.d.ts) file for this entry-point. */
     typings: string;
-};
+}
 /**
- * Try to get entry point info from the given path.
- * @param pkgPath the absolute path to the containing npm package
- * @param entryPoint the absolute path to the potential entry point.
+ * Try to get an entry point from the given path.
+ * @param packagePath the absolute path to the containing npm package
+ * @param entryPointPath the absolute path to the potential entry point.
  * @returns Info about the entry point if it is valid, `null` otherwise.
  */
-export declare function getEntryPointInfo(pkgPath: string, entryPoint: string): EntryPoint | null;
+export declare function getEntryPointInfo(packagePath: string, entryPointPath: string): EntryPoint | null;

package/src/ngcc/src/packages/entry_point.js

@@ -34,13 +34,13 @@
         }
     }
     /**
-     * Try to get entry point info from the given path.
-     * @param pkgPath the absolute path to the containing npm package
-     * @param entryPoint the absolute path to the potential entry point.
+     * Try to get an entry point from the given path.
+     * @param packagePath the absolute path to the containing npm package
+     * @param entryPointPath the absolute path to the potential entry point.
      * @returns Info about the entry point if it is valid, `null` otherwise.
      */
-    function getEntryPointInfo(pkgPath, entryPoint) {
-        var packageJsonPath = path.resolve(entryPoint, 'package.json');
+    function getEntryPointInfo(packagePath, entryPointPath) {
+        var packageJsonPath = path.resolve(entryPointPath, 'package.json');
         if (!fs.existsSync(packageJsonPath)) {
             return null;
         }
@@ -59,34 +59,34 @@
         if (!typings || !(fesm2015 || esm2015)) {
             return null;
         }
-        // Also we need to have a metadata.json file
-        var metadataPath = path.resolve(entryPoint, typings.replace(/\.d\.ts$/, '') + '.metadata.json');
+        // Also there must exist a `metadata.json` file next to the typings entry-point.
+        var metadataPath = path.resolve(entryPointPath, typings.replace(/\.d\.ts$/, '') + '.metadata.json');
         if (!fs.existsSync(metadataPath)) {
             return null;
         }
         var entryPointInfo = {
             name: name,
-            package: pkgPath,
-            path: entryPoint,
-            typings: path.resolve(entryPoint, typings),
+            package: packagePath,
+            path: entryPointPath,
+            typings: path.resolve(entryPointPath, typings),
         };
         if (esm2015) {
-            entryPointInfo.esm2015 = path.resolve(entryPoint, esm2015);
+            entryPointInfo.esm2015 = path.resolve(entryPointPath, esm2015);
         }
         if (fesm2015) {
-            entryPointInfo.fesm2015 = path.resolve(entryPoint, fesm2015);
+            entryPointInfo.fesm2015 = path.resolve(entryPointPath, fesm2015);
         }
         if (fesm5) {
-            entryPointInfo.fesm5 = path.resolve(entryPoint, fesm5);
+            entryPointInfo.fesm5 = path.resolve(entryPointPath, fesm5);
         }
         if (esm5) {
-            entryPointInfo.esm5 = path.resolve(entryPoint, esm5);
+            entryPointInfo.esm5 = path.resolve(entryPointPath, esm5);
         }
         if (main) {
-            entryPointInfo.umd = path.resolve(entryPoint, main);
+            entryPointInfo.umd = path.resolve(entryPointPath, main);
         }
         return entryPointInfo;
     }
     exports.getEntryPointInfo = getEntryPointInfo;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngcc/src/packages/entry_point.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAEH,qCAAuC;IACvC,uBAAyB;IA2CzB;;;;OAIG;IACH,SAAS,qBAAqB,CAAC,eAAuB;QACpD,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;SAC7D;QAAC,OAAO,CAAC,EAAE;YACV,8DAA8D;YAC9D,OAAO,CAAC,IAAI,CAAC,0CAAwC,eAAe,oBAAe,CAAC,MAAG,CAAC,CAAC;YACzF,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED;;;;;OAKG;IACH,SAAgB,iBAAiB,CAAC,OAAe,EAAE,UAAkB;QACnE,IAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;QACjE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;YACnC,OAAO,IAAI,CAAC;SACb;QAED,IAAM,qBAAqB,GAAG,qBAAqB,CAAC,eAAe,CAAC,CAAC;QACrE,IAAI,CAAC,qBAAqB,EAAE;YAC1B,OAAO,IAAI,CAAC;SACb;QAED,2EAA2E;QAC3E,6EAA6E;QAE3E,IAAA,iCAAI,EACJ,yCAAkB,EAClB,mCAAK,EACL,kCAAe,EAAf,oCAAe,EAAG,aAAa;QAC/B,qCAAM,EACN,mCAAiB,EAAjB,sCAAiB,EAAI,aAAa;QAClC,gCAAkB,EADG,aAAa;QAClC,uCAAkB,EAAG,aAAa;QAClC,uCAAO,EACP,iCAAI,EACJ,iCAAI,CACoB;QAC1B,sFAAsF;QACtF,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,QAAQ,IAAI,OAAO,CAAC,EAAE;YACtC,OAAO,IAAI,CAAC;SACb;QAED,4CAA4C;QAC5C,IAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC;QAClG,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;YAChC,OAAO,IAAI,CAAC;SACb;QAED,IAAM,cAAc,GAAe;YACjC,IAAI,MAAA;YACJ,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,UAAU;YAChB,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC;SAC3C,CAAC;QAEF,IAAI,OAAO,EAAE;YACX,cAAc,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;SAC5D;QACD,IAAI,QAAQ,EAAE;YACZ,cAAc,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;SAC9D;QACD,IAAI,KAAK,EAAE;YACT,cAAc,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;SACxD;QACD,IAAI,IAAI,EAAE;YACR,cAAc,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;SACtD;QACD,IAAI,IAAI,EAAE;YACR,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;SACrD;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IA5DD,8CA4DC","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 * as path from 'canonical-path';\nimport * as fs from 'fs';\n\n\n/**\n * The possible values for the format of an entry-point.\n */\nexport type EntryPointFormat = 'esm5' | 'fesm5' | 'esm2015' | 'fesm2015' | 'umd';\n\n/**\n * An object containing paths to the entry-points for each format.\n */\nexport type EntryPointPaths = {\n  [Format in EntryPointFormat]?: string;\n};\n\n/**\n * An object containing information about an entry-point, including paths\n * to each of the possible entry-point formats.\n */\nexport type EntryPoint = EntryPointPaths & {\n  /** The name of the package (e.g. `@angular/core`). */\n  name: string;\n  /** The path to the package that contains this entry-point. */\n  package: string;\n  /** The path to this entry point. */\n  path: string;\n  /** The path to a typings (.d.ts) file for this entry-point. */\n  typings: string;\n};\n\ninterface EntryPointPackageJson {\n  name: string;\n  fesm2015?: string;\n  fesm5?: string;\n  es2015?: string;  // if exists then it is actually FESM2015\n  esm2015?: string;\n  esm5?: string;\n  main?: string;     // UMD\n  module?: string;   // if exists then it is actually FESM5\n  types?: string;    // Synonymous to `typings` property - see https://bit.ly/2OgWp2H\n  typings?: string;  // TypeScript .d.ts files\n}\n\n/**\n * Parses the JSON from a package.json file.\n * @param packageJsonPath the absolute path to the package.json file.\n * @returns JSON from the package.json file if it is valid, `null` otherwise.\n */\nfunction loadEntryPointPackage(packageJsonPath: string): {[key: string]: any}|null {\n  try {\n    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));\n  } catch (e) {\n    // We may have run into a package.json with unexpected symbols\n    console.warn(`Failed to read entry point info from ${packageJsonPath} with error ${e}.`);\n    return null;\n  }\n}\n\n/**\n * Try to get entry point info from the given path.\n * @param pkgPath the absolute path to the containing npm package\n * @param entryPoint the absolute path to the potential entry point.\n * @returns Info about the entry point if it is valid, `null` otherwise.\n */\nexport function getEntryPointInfo(pkgPath: string, entryPoint: string): EntryPoint|null {\n  const packageJsonPath = path.resolve(entryPoint, 'package.json');\n  if (!fs.existsSync(packageJsonPath)) {\n    return null;\n  }\n\n  const entryPointPackageJson = loadEntryPointPackage(packageJsonPath);\n  if (!entryPointPackageJson) {\n    return null;\n  }\n\n  // If there is `esm2015` then `es2015` will be FESM2015, otherwise ESM2015.\n  // If there is `esm5` then `module` will be FESM5, otherwise it will be ESM5.\n  const {\n    name,\n    module: modulePath,\n    types,\n    typings = types,  // synonymous\n    es2015,\n    fesm2015 = es2015,   // synonymous\n    fesm5 = modulePath,  // synonymous\n    esm2015,\n    esm5,\n    main\n  } = entryPointPackageJson;\n  // Minimum requirement is that we have typings and one of esm2015 or fesm2015 formats.\n  if (!typings || !(fesm2015 || esm2015)) {\n    return null;\n  }\n\n  // Also we need to have a metadata.json file\n  const metadataPath = path.resolve(entryPoint, typings.replace(/\\.d\\.ts$/, '') + '.metadata.json');\n  if (!fs.existsSync(metadataPath)) {\n    return null;\n  }\n\n  const entryPointInfo: EntryPoint = {\n    name,\n    package: pkgPath,\n    path: entryPoint,\n    typings: path.resolve(entryPoint, typings),\n  };\n\n  if (esm2015) {\n    entryPointInfo.esm2015 = path.resolve(entryPoint, esm2015);\n  }\n  if (fesm2015) {\n    entryPointInfo.fesm2015 = path.resolve(entryPoint, fesm2015);\n  }\n  if (fesm5) {\n    entryPointInfo.fesm5 = path.resolve(entryPoint, fesm5);\n  }\n  if (esm5) {\n    entryPointInfo.esm5 = path.resolve(entryPoint, esm5);\n  }\n  if (main) {\n    entryPointInfo.umd = path.resolve(entryPoint, main);\n  }\n\n  return entryPointInfo;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point.js","sourceRoot":"../../../../","sources":["packages/compiler-cli/src/ngcc/src/packages/entry_point.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAEH,qCAAuC;IACvC,uBAAyB;IAkDzB;;;;OAIG;IACH,SAAS,qBAAqB,CAAC,eAAuB;QACpD,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;SAC7D;QAAC,OAAO,CAAC,EAAE;YACV,8DAA8D;YAC9D,OAAO,CAAC,IAAI,CAAC,0CAAwC,eAAe,oBAAe,CAAC,MAAG,CAAC,CAAC;YACzF,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED;;;;;OAKG;IACH,SAAgB,iBAAiB,CAAC,WAAmB,EAAE,cAAsB;QAC3E,IAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;QACrE,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;YACnC,OAAO,IAAI,CAAC;SACb;QAED,IAAM,qBAAqB,GAAG,qBAAqB,CAAC,eAAe,CAAC,CAAC;QACrE,IAAI,CAAC,qBAAqB,EAAE;YAC1B,OAAO,IAAI,CAAC;SACb;QAED,2EAA2E;QAC3E,6EAA6E;QAE3E,IAAA,iCAAI,EACJ,yCAAkB,EAClB,mCAAK,EACL,kCAAe,EAAf,oCAAe,EAAG,aAAa;QAC/B,qCAAM,EACN,mCAAiB,EAAjB,sCAAiB,EAAI,aAAa;QAClC,gCAAkB,EADG,aAAa;QAClC,uCAAkB,EAAG,aAAa;QAClC,uCAAO,EACP,iCAAI,EACJ,iCAAI,CACoB;QAC1B,sFAAsF;QACtF,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,QAAQ,IAAI,OAAO,CAAC,EAAE;YACtC,OAAO,IAAI,CAAC;SACb;QAED,gFAAgF;QAChF,IAAM,YAAY,GACd,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,gBAAgB,CAAC,CAAC;QACrF,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE;YAChC,OAAO,IAAI,CAAC;SACb;QAED,IAAM,cAAc,GAAe;YACjC,IAAI,MAAA;YACJ,OAAO,EAAE,WAAW;YACpB,IAAI,EAAE,cAAc;YACpB,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC;SAC/C,CAAC;QAEF,IAAI,OAAO,EAAE;YACX,cAAc,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;SAChE;QACD,IAAI,QAAQ,EAAE;YACZ,cAAc,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;SAClE;QACD,IAAI,KAAK,EAAE;YACT,cAAc,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;SAC5D;QACD,IAAI,IAAI,EAAE;YACR,cAAc,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;SAC1D;QACD,IAAI,IAAI,EAAE;YACR,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;SACzD;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IA7DD,8CA6DC","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 * as path from 'canonical-path';\nimport * as fs from 'fs';\n\n\n/**\n * An object containing paths to the entry-points for each format.\n */\nexport interface EntryPointPaths {\n  esm5?: string;\n  fesm5?: string;\n  esm2015?: string;\n  fesm2015?: string;\n  umd?: string;\n}\n\n/**\n * The possible values for the format of an entry-point.\n */\nexport type EntryPointFormat = keyof(EntryPointPaths);\n\n/**\n * An object containing information about an entry-point, including paths\n * to each of the possible entry-point formats.\n */\nexport interface EntryPoint extends EntryPointPaths {\n  /** The name of the package (e.g. `@angular/core`). */\n  name: string;\n  /** The path to the package that contains this entry-point. */\n  package: string;\n  /** The path to this entry point. */\n  path: string;\n  /** The path to a typings (.d.ts) file for this entry-point. */\n  typings: string;\n}\n\n/**\n * The properties that may be loaded from the `package.json` file.\n */\ninterface EntryPointPackageJson {\n  name: string;\n  fesm2015?: string;\n  fesm5?: string;\n  es2015?: string;  // if exists then it is actually FESM2015\n  esm2015?: string;\n  esm5?: string;\n  main?: string;     // UMD\n  module?: string;   // if exists then it is actually FESM5\n  types?: string;    // Synonymous to `typings` property - see https://bit.ly/2OgWp2H\n  typings?: string;  // TypeScript .d.ts files\n}\n\n/**\n * Parses the JSON from a package.json file.\n * @param packageJsonPath the absolute path to the package.json file.\n * @returns JSON from the package.json file if it is valid, `null` otherwise.\n */\nfunction loadEntryPointPackage(packageJsonPath: string): EntryPointPackageJson|null {\n  try {\n    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));\n  } catch (e) {\n    // We may have run into a package.json with unexpected symbols\n    console.warn(`Failed to read entry point info from ${packageJsonPath} with error ${e}.`);\n    return null;\n  }\n}\n\n/**\n * Try to get an entry point from the given path.\n * @param packagePath the absolute path to the containing npm package\n * @param entryPointPath the absolute path to the potential entry point.\n * @returns Info about the entry point if it is valid, `null` otherwise.\n */\nexport function getEntryPointInfo(packagePath: string, entryPointPath: string): EntryPoint|null {\n  const packageJsonPath = path.resolve(entryPointPath, 'package.json');\n  if (!fs.existsSync(packageJsonPath)) {\n    return null;\n  }\n\n  const entryPointPackageJson = loadEntryPointPackage(packageJsonPath);\n  if (!entryPointPackageJson) {\n    return null;\n  }\n\n  // If there is `esm2015` then `es2015` will be FESM2015, otherwise ESM2015.\n  // If there is `esm5` then `module` will be FESM5, otherwise it will be ESM5.\n  const {\n    name,\n    module: modulePath,\n    types,\n    typings = types,  // synonymous\n    es2015,\n    fesm2015 = es2015,   // synonymous\n    fesm5 = modulePath,  // synonymous\n    esm2015,\n    esm5,\n    main\n  } = entryPointPackageJson;\n  // Minimum requirement is that we have typings and one of esm2015 or fesm2015 formats.\n  if (!typings || !(fesm2015 || esm2015)) {\n    return null;\n  }\n\n  // Also there must exist a `metadata.json` file next to the typings entry-point.\n  const metadataPath =\n      path.resolve(entryPointPath, typings.replace(/\\.d\\.ts$/, '') + '.metadata.json');\n  if (!fs.existsSync(metadataPath)) {\n    return null;\n  }\n\n  const entryPointInfo: EntryPoint = {\n    name,\n    package: packagePath,\n    path: entryPointPath,\n    typings: path.resolve(entryPointPath, typings),\n  };\n\n  if (esm2015) {\n    entryPointInfo.esm2015 = path.resolve(entryPointPath, esm2015);\n  }\n  if (fesm2015) {\n    entryPointInfo.fesm2015 = path.resolve(entryPointPath, fesm2015);\n  }\n  if (fesm5) {\n    entryPointInfo.fesm5 = path.resolve(entryPointPath, fesm5);\n  }\n  if (esm5) {\n    entryPointInfo.esm5 = path.resolve(entryPointPath, esm5);\n  }\n  if (main) {\n    entryPointInfo.umd = path.resolve(entryPointPath, main);\n  }\n\n  return entryPointInfo;\n}\n"]}

package/src/ngcc/src/packages/entry_point_bundle.d.ts

@@ -0,0 +1,21 @@
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/packages/entry_point_bundle" />
+import { BundleProgram } from './bundle_program';
+import { EntryPoint, EntryPointFormat } from './entry_point';
+/**
+ * A bundle of files and paths (and TS programs) that correspond to a particular
+ * format of a package entry-point.
+ */
+export interface EntryPointBundle {
+    format: EntryPointFormat;
+    isFlat: boolean;
+    rootDirs: string[];
+    src: BundleProgram;
+    dts: BundleProgram | null;
+}
+/**
+ * Get an object that describes a formatted bundle for an entry-point.
+ * @param entryPoint The entry-point that contains the bundle.
+ * @param format The format of the bundle.
+ * @param transformDts True if processing this bundle should also process its `.d.ts` files.
+ */
+export declare function makeEntryPointBundle(entryPoint: EntryPoint, isCore: boolean, format: EntryPointFormat, transformDts: boolean): EntryPointBundle | null;

package/src/ngcc/src/packages/entry_point_bundle.js

@@ -0,0 +1,51 @@
+(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/src/ngcc/src/packages/entry_point_bundle", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngcc/src/packages/bundle_program"], 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 ts = require("typescript");
+    var bundle_program_1 = require("@angular/compiler-cli/src/ngcc/src/packages/bundle_program");
+    /**
+     * Get an object that describes a formatted bundle for an entry-point.
+     * @param entryPoint The entry-point that contains the bundle.
+     * @param format The format of the bundle.
+     * @param transformDts True if processing this bundle should also process its `.d.ts` files.
+     */
+    function makeEntryPointBundle(entryPoint, isCore, format, transformDts) {
+        // Bail out if the entry-point does not have this format.
+        var path = entryPoint[format];
+        if (!path) {
+            return null;
+        }
+        // Create the TS program and necessary helpers.
+        var options = {
+            allowJs: true,
+            maxNodeModuleJsDepth: Infinity,
+            rootDir: entryPoint.path,
+        };
+        var host = ts.createCompilerHost(options);
+        var rootDirs = [entryPoint.path];
+        // Create the bundle programs, as necessary.
+        var src = bundle_program_1.makeBundleProgram(isCore, path, 'r3_symbols.js', options, host);
+        var dts = transformDts ?
+            bundle_program_1.makeBundleProgram(isCore, entryPoint.typings, 'r3_symbols.d.ts', options, host) :
+            null;
+        var isFlat = src.r3SymbolsFile === null;
+        return { format: format, rootDirs: rootDirs, isFlat: isFlat, src: src, dts: dts };
+    }
+    exports.makeEntryPointBundle = makeEntryPointBundle;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngcc/src/packages/entry_point_finder.js

@@ -116,4 +116,4 @@
         });
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point_finder.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngcc/src/packages/entry_point_finder.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 path from 'canonical-path';\nimport * as fs from 'fs';\n\nimport {DependencyResolver, SortedEntryPointsInfo} from './dependency_resolver';\nimport {EntryPoint, getEntryPointInfo} from './entry_point';\n\n\nexport class EntryPointFinder {\n  constructor(private resolver: DependencyResolver) {}\n  /**\n   * Search the given directory, and sub-directories, for Angular package entry points.\n   * @param sourceDirectory An absolute path to the directory to search for entry points.\n   */\n  findEntryPoints(sourceDirectory: string): SortedEntryPointsInfo {\n    const unsortedEntryPoints = walkDirectoryForEntryPoints(sourceDirectory);\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints);\n  }\n}\n\n/**\n * Look for entry points that need to be compiled, starting at the source directory.\n * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n * @param sourceDirectory An absolute path to the root directory where searching begins.\n */\nfunction walkDirectoryForEntryPoints(sourceDirectory: string): EntryPoint[] {\n  const entryPoints: EntryPoint[] = [];\n  fs.readdirSync(sourceDirectory)\n      // Not interested in hidden files\n      .filter(p => !p.startsWith('.'))\n      // Ignore node_modules\n      .filter(p => p !== 'node_modules')\n      // Only interested in directories (and only those that are not symlinks)\n      .filter(p => {\n        const stat = fs.lstatSync(path.resolve(sourceDirectory, p));\n        return stat.isDirectory() && !stat.isSymbolicLink();\n      })\n      .forEach(p => {\n        // Either the directory is a potential package or a namespace containing packages (e.g\n        // `@angular`).\n        const packagePath = path.join(sourceDirectory, p);\n        if (p.startsWith('@')) {\n          entryPoints.push(...walkDirectoryForEntryPoints(packagePath));\n        } else {\n          entryPoints.push(...getEntryPointsForPackage(packagePath));\n\n          // Also check for any nested node_modules in this package\n          const nestedNodeModulesPath = path.resolve(packagePath, 'node_modules');\n          if (fs.existsSync(nestedNodeModulesPath)) {\n            entryPoints.push(...walkDirectoryForEntryPoints(nestedNodeModulesPath));\n          }\n        }\n      });\n  return entryPoints;\n}\n\n/**\n * Recurse the folder structure looking for all the entry points\n * @param packagePath The absolute path to an npm package that may contain entry points\n * @returns An array of entry points that were discovered.\n */\nfunction getEntryPointsForPackage(packagePath: string): EntryPoint[] {\n  const entryPoints: EntryPoint[] = [];\n\n  // Try to get an entry point from the top level package directory\n  const topLevelEntryPoint = getEntryPointInfo(packagePath, packagePath);\n  if (topLevelEntryPoint !== null) {\n    entryPoints.push(topLevelEntryPoint);\n  }\n\n  // Now search all the directories of this package for possible entry points\n  walkDirectory(packagePath, subdir => {\n    const subEntryPoint = getEntryPointInfo(packagePath, subdir);\n    if (subEntryPoint !== null) {\n      entryPoints.push(subEntryPoint);\n    }\n  });\n\n  return entryPoints;\n}\n\n/**\n * Recursively walk a directory and its sub-directories, applying a given\n * function to each directory.\n * @param dir the directory to recursively walk.\n * @param fn the function to apply to each directory.\n */\nfunction walkDirectory(dir: string, fn: (dir: string) => void) {\n  return fs\n      .readdirSync(dir)\n      // Not interested in hidden files\n      .filter(p => !p.startsWith('.'))\n      // Ignore node_modules\n      .filter(p => p !== 'node_modules')\n      // Only interested in directories (and only those that are not symlinks)\n      .filter(p => {\n        const stat = fs.lstatSync(path.resolve(dir, p));\n        return stat.isDirectory() && !stat.isSymbolicLink();\n      })\n      .forEach(subdir => {\n        subdir = path.resolve(dir, subdir);\n        fn(subdir);\n        walkDirectory(subdir, fn);\n      });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entry_point_finder.js","sourceRoot":"../../../../","sources":["packages/compiler-cli/src/ngcc/src/packages/entry_point_finder.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 path from 'canonical-path';\nimport * as fs from 'fs';\n\nimport {DependencyResolver, SortedEntryPointsInfo} from './dependency_resolver';\nimport {EntryPoint, getEntryPointInfo} from './entry_point';\n\n\nexport class EntryPointFinder {\n  constructor(private resolver: DependencyResolver) {}\n  /**\n   * Search the given directory, and sub-directories, for Angular package entry points.\n   * @param sourceDirectory An absolute path to the directory to search for entry points.\n   */\n  findEntryPoints(sourceDirectory: string): SortedEntryPointsInfo {\n    const unsortedEntryPoints = walkDirectoryForEntryPoints(sourceDirectory);\n    return this.resolver.sortEntryPointsByDependency(unsortedEntryPoints);\n  }\n}\n\n/**\n * Look for entry points that need to be compiled, starting at the source directory.\n * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.\n * @param sourceDirectory An absolute path to the root directory where searching begins.\n */\nfunction walkDirectoryForEntryPoints(sourceDirectory: string): EntryPoint[] {\n  const entryPoints: EntryPoint[] = [];\n  fs.readdirSync(sourceDirectory)\n      // Not interested in hidden files\n      .filter(p => !p.startsWith('.'))\n      // Ignore node_modules\n      .filter(p => p !== 'node_modules')\n      // Only interested in directories (and only those that are not symlinks)\n      .filter(p => {\n        const stat = fs.lstatSync(path.resolve(sourceDirectory, p));\n        return stat.isDirectory() && !stat.isSymbolicLink();\n      })\n      .forEach(p => {\n        // Either the directory is a potential package or a namespace containing packages (e.g\n        // `@angular`).\n        const packagePath = path.join(sourceDirectory, p);\n        if (p.startsWith('@')) {\n          entryPoints.push(...walkDirectoryForEntryPoints(packagePath));\n        } else {\n          entryPoints.push(...getEntryPointsForPackage(packagePath));\n\n          // Also check for any nested node_modules in this package\n          const nestedNodeModulesPath = path.resolve(packagePath, 'node_modules');\n          if (fs.existsSync(nestedNodeModulesPath)) {\n            entryPoints.push(...walkDirectoryForEntryPoints(nestedNodeModulesPath));\n          }\n        }\n      });\n  return entryPoints;\n}\n\n/**\n * Recurse the folder structure looking for all the entry points\n * @param packagePath The absolute path to an npm package that may contain entry points\n * @returns An array of entry points that were discovered.\n */\nfunction getEntryPointsForPackage(packagePath: string): EntryPoint[] {\n  const entryPoints: EntryPoint[] = [];\n\n  // Try to get an entry point from the top level package directory\n  const topLevelEntryPoint = getEntryPointInfo(packagePath, packagePath);\n  if (topLevelEntryPoint !== null) {\n    entryPoints.push(topLevelEntryPoint);\n  }\n\n  // Now search all the directories of this package for possible entry points\n  walkDirectory(packagePath, subdir => {\n    const subEntryPoint = getEntryPointInfo(packagePath, subdir);\n    if (subEntryPoint !== null) {\n      entryPoints.push(subEntryPoint);\n    }\n  });\n\n  return entryPoints;\n}\n\n/**\n * Recursively walk a directory and its sub-directories, applying a given\n * function to each directory.\n * @param dir the directory to recursively walk.\n * @param fn the function to apply to each directory.\n */\nfunction walkDirectory(dir: string, fn: (dir: string) => void) {\n  return fs\n      .readdirSync(dir)\n      // Not interested in hidden files\n      .filter(p => !p.startsWith('.'))\n      // Ignore node_modules\n      .filter(p => p !== 'node_modules')\n      // Only interested in directories (and only those that are not symlinks)\n      .filter(p => {\n        const stat = fs.lstatSync(path.resolve(dir, p));\n        return stat.isDirectory() && !stat.isSymbolicLink();\n      })\n      .forEach(subdir => {\n        subdir = path.resolve(dir, subdir);\n        fn(subdir);\n        walkDirectory(subdir, fn);\n      });\n}\n"]}

package/src/ngcc/src/packages/transformer.d.ts

@@ -1,9 +1,13 @@
 /// <amd-module name="@angular/compiler-cli/src/ngcc/src/packages/transformer" />
 import * as ts from 'typescript';
+import { CompiledFile } from '../analysis/decoration_analyzer';
+import { ModuleWithProvidersAnalyses } from '../analysis/module_with_providers_analyzer';
+import { ExportInfo } from '../analysis/private_declarations_analyzer';
+import { SwitchMarkerAnalyses } from '../analysis/switch_marker_analyzer';
 import { NgccReflectionHost } from '../host/ngcc_host';
 import { FileInfo, Renderer } from '../rendering/renderer';
-import { BundleInfo } from './bundle';
-import { EntryPoint, EntryPointFormat } from './entry_point';
+import { EntryPoint } from './entry_point';
+import { EntryPointBundle } from './entry_point_bundle';
 /**
  * A Package is stored in a directory on disk and that directory can contain one or more package
  * formats - e.g. fesm2015, UMD, etc. Additionally, each package provides typings (`.d.ts` files).
@@ -12,9 +16,11 @@ import { EntryPoint, EntryPointFormat } from './entry_point';
  * parsed to identify the decorated exported classes that need to be analyzed and compiled by one or
  * more `DecoratorHandler` objects.
  *
- * Each entry point to a package is identified by a `SourceFile` that can be parsed and analyzed to
+ * Each entry point to a package is identified by a `package.json` which contains properties that
+ * indicate what formatted bundles are accessible via this end-point.
+ *
+ * Each bundle is identified by a root `SourceFile` that can be parsed and analyzed to
  * identify classes that need to be transformed; and then finally rendered and written to disk.
- * The actual file which needs to be transformed depends upon the package format.
  *
  * Along with the source files, the corresponding source maps (either inline or external) and
  * `.d.ts` files are transformed accordingly.
@@ -27,14 +33,20 @@ export declare class Transformer {
     private sourcePath;
     private targetPath;
     constructor(sourcePath: string, targetPath: string);
-    transform(entryPoint: EntryPoint, format: EntryPointFormat, transformDts: boolean): void;
-    getRootDirs(host: ts.CompilerHost, options: ts.CompilerOptions): string[];
-    getHost(isCore: boolean, format: string, program: ts.Program, dtsFilePath: string, dtsProgram: ts.Program | null): NgccReflectionHost;
-    getRenderer(format: string, program: ts.Program, host: NgccReflectionHost, bundle: BundleInfo, transformDts: boolean): Renderer;
-    analyzeProgram(program: ts.Program, reflectionHost: NgccReflectionHost, rootDirs: string[], isCore: boolean): {
-        decorationAnalyses: Map<ts.SourceFile, import("@angular/compiler-cli/src/ngcc/src/analysis/decoration_analyzer").CompiledFile>;
-        switchMarkerAnalyses: Map<ts.SourceFile, import("@angular/compiler-cli/src/ngcc/src/analysis/switch_marker_analyzer").SwitchMarkerAnalysis>;
-    };
+    /**
+     * Transform the source (and typings) files of a bundle.
+     * @param bundle the bundle to transform.
+     */
+    transform(entryPoint: EntryPoint, isCore: boolean, bundle: EntryPointBundle): void;
+    getHost(isCore: boolean, bundle: EntryPointBundle): NgccReflectionHost;
+    getRenderer(host: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): Renderer;
+    analyzeProgram(reflectionHost: NgccReflectionHost, isCore: boolean, bundle: EntryPointBundle): ProgramAnalyses;
     writeFile(file: FileInfo): void;
-    findR3SymbolsPath(directory: string, fileName: string): string | null;
 }
+interface ProgramAnalyses {
+    decorationAnalyses: Map<ts.SourceFile, CompiledFile>;
+    switchMarkerAnalyses: SwitchMarkerAnalyses;
+    privateDeclarationsAnalyses: ExportInfo[];
+    moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses | null;
+}
+export {};