@ngtools/webpack/src/ngcc_processor.js

"use strict";
/**
 * @license
 * Copyright Google LLC 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.NgccProcessor = void 0;
const child_process_1 = require("child_process");
const crypto_1 = require("crypto");
const fs_1 = require("fs");
const path = __importStar(require("path"));
const benchmark_1 = require("./benchmark");
// We cannot create a plugin for this, because NGTSC requires addition type
// information which ngcc creates when processing a package which was compiled with NGC.
// Example of such errors:
// ERROR in node_modules/@angular/platform-browser/platform-browser.d.ts(42,22):
// error TS-996002: Appears in the NgModule.imports of AppModule,
// but could not be resolved to an NgModule class
// We now transform a package and it's typings when NGTSC is resolving a module.
class NgccProcessor {
    constructor(compilerNgcc, propertiesToConsider, compilationWarnings, compilationErrors, basePath, tsConfigPath, inputFileSystem, resolver) {
        this.compilerNgcc = compilerNgcc;
        this.propertiesToConsider = propertiesToConsider;
        this.compilationWarnings = compilationWarnings;
        this.compilationErrors = compilationErrors;
        this.basePath = basePath;
        this.tsConfigPath = tsConfigPath;
        this.inputFileSystem = inputFileSystem;
        this.resolver = resolver;
        this._processedModules = new Set();
        this._logger = new NgccLogger(this.compilationWarnings, this.compilationErrors, compilerNgcc.LogLevel.info);
        this._nodeModulesDirectory = this.findNodeModulesDirectory(this.basePath);
    }
    /** Process the entire node modules tree. */
    process() {
        // Under Bazel when running in sandbox mode parts of the filesystem is read-only, or when using
        // Yarn PnP there may not be a node_modules directory. ngcc can't run in those cases, so the
        // processing is skipped.
        if (process.env.BAZEL_TARGET || !this._nodeModulesDirectory) {
            return;
        }
        // Skip if node_modules are read-only
        const corePackage = this.tryResolvePackage('@angular/core', this._nodeModulesDirectory);
        if (corePackage && isReadOnlyFile(corePackage)) {
            return;
        }
        // Perform a ngcc run check to determine if an initial execution is required.
        // If a run hash file exists that matches the current package manager lock file and the
        // project's tsconfig, then an initial ngcc run has already been performed.
        let skipProcessing = false;
        let runHashFilePath;
        const runHashBasePath = path.join(this._nodeModulesDirectory, '.cli-ngcc');
        const projectBasePath = path.join(this._nodeModulesDirectory, '..');
        try {
            let ngccConfigData;
            try {
                ngccConfigData = (0, fs_1.readFileSync)(path.join(projectBasePath, 'ngcc.config.js'));
            }
            catch (_a) {
                ngccConfigData = '';
            }
            const relativeTsconfigPath = path.relative(projectBasePath, this.tsConfigPath);
            const tsconfigData = (0, fs_1.readFileSync)(this.tsConfigPath);
            const { lockFileData, lockFilePath } = this.findPackageManagerLockFile(projectBasePath);
            // Generate a hash that represents the state of the package lock file and used tsconfig
            const runHash = (0, crypto_1.createHash)('sha256')
                .update(lockFileData)
                .update(lockFilePath)
                .update(ngccConfigData)
                .update(tsconfigData)
                .update(relativeTsconfigPath)
                .digest('hex');
            // The hash is used directly in the file name to mitigate potential read/write race
            // conditions as well as to only require a file existence check
            runHashFilePath = path.join(runHashBasePath, runHash + '.lock');
            // If the run hash lock file exists, then ngcc was already run against this project state
            if ((0, fs_1.existsSync)(runHashFilePath)) {
                skipProcessing = true;
            }
        }
        catch (_b) {
            // Any error means an ngcc execution is needed
        }
        if (skipProcessing) {
            return;
        }
        const timeLabel = 'NgccProcessor.process';
        (0, benchmark_1.time)(timeLabel);
        // We spawn instead of using the API because:
        // - NGCC Async uses clustering which is problematic when used via the API which means
        // that we cannot setup multiple cluster masters with different options.
        // - We will not be able to have concurrent builds otherwise Ex: App-Shell,
        // as NGCC will create a lock file for both builds and it will cause builds to fails.
        const originalProcessTitle = process.title;
        try {
            const { status, error } = (0, child_process_1.spawnSync)(process.execPath, [
                this.compilerNgcc.ngccMainFilePath,
                '--source' /** basePath */,
                this._nodeModulesDirectory,
                '--properties' /** propertiesToConsider */,
                ...this.propertiesToConsider,
                '--first-only' /** compileAllFormats */,
                '--create-ivy-entry-points' /** createNewEntryPointFormats */,
                '--async',
                '--tsconfig' /** tsConfigPath */,
                this.tsConfigPath,
                '--use-program-dependencies',
            ], {
                stdio: ['inherit', process.stderr, process.stderr],
            });
            if (status !== 0) {
                const errorMessage = (error === null || error === void 0 ? void 0 : error.message) || '';
                throw new Error(errorMessage + `NGCC failed${errorMessage ? ', see above' : ''}.`);
            }
        }
        finally {
            process.title = originalProcessTitle;
        }
        (0, benchmark_1.timeEnd)(timeLabel);
        // ngcc was successful so if a run hash was generated, write it for next time
        if (runHashFilePath) {
            try {
                if (!(0, fs_1.existsSync)(runHashBasePath)) {
                    (0, fs_1.mkdirSync)(runHashBasePath, { recursive: true });
                }
                (0, fs_1.writeFileSync)(runHashFilePath, '');
            }
            catch (_c) {
                // Errors are non-fatal
            }
        }
    }
    /** Process a module and its dependencies. */
    processModule(moduleName, resolvedModule) {
        var _a, _b;
        const resolvedFileName = resolvedModule.resolvedFileName;
        if (!this._nodeModulesDirectory ||
            !resolvedFileName ||
            moduleName.startsWith('.') ||
            this._processedModules.has(resolvedFileName)) {
            // Skip when module_modules directory is not present, module is unknown, relative or the
            // NGCC compiler is not found or already processed.
            return;
        }
        const packageJsonPath = this.tryResolvePackage(moduleName, resolvedFileName);
        // If the package.json is read only we should skip calling NGCC.
        // With Bazel when running under sandbox the filesystem is read-only.
        if (!packageJsonPath || isReadOnlyFile(packageJsonPath)) {
            // add it to processed so the second time round we skip this.
            this._processedModules.add(resolvedFileName);
            return;
        }
        const timeLabel = `NgccProcessor.processModule.ngcc.process+${moduleName}`;
        (0, benchmark_1.time)(timeLabel);
        this.compilerNgcc.process({
            basePath: this._nodeModulesDirectory,
            targetEntryPointPath: path.dirname(packageJsonPath),
            propertiesToConsider: this.propertiesToConsider,
            compileAllFormats: false,
            createNewEntryPointFormats: true,
            logger: this._logger,
            tsConfigPath: this.tsConfigPath,
        });
        (0, benchmark_1.timeEnd)(timeLabel);
        // Purge this file from cache, since NGCC add new mainFields. Ex: module_ivy_ngcc
        // which are unknown in the cached file.
        (_b = (_a = this.inputFileSystem).purge) === null || _b === void 0 ? void 0 : _b.call(_a, packageJsonPath);
        this._processedModules.add(resolvedFileName);
    }
    invalidate(fileName) {
        this._processedModules.delete(fileName);
    }
    /**
     * Try resolve a package.json file from the resolved .d.ts file.
     */
    tryResolvePackage(moduleName, resolvedFileName) {
        try {
            const resolvedPath = this.resolver.resolveSync({}, resolvedFileName, `${moduleName}/package.json`);
            return resolvedPath || undefined;
        }
        catch (_a) {
            // Ex: @angular/compiler/src/i18n/i18n_ast/package.json
            // or local libraries which don't reside in node_modules
            const packageJsonPath = path.resolve(resolvedFileName, '../package.json');
            return (0, fs_1.existsSync)(packageJsonPath) ? packageJsonPath : undefined;
        }
    }
    findNodeModulesDirectory(startPoint) {
        let current = startPoint;
        while (path.dirname(current) !== current) {
            const nodePath = path.join(current, 'node_modules');
            if ((0, fs_1.existsSync)(nodePath)) {
                return nodePath;
            }
            current = path.dirname(current);
        }
        return null;
    }
    findPackageManagerLockFile(projectBasePath) {
        for (const lockFile of ['yarn.lock', 'pnpm-lock.yaml', 'package-lock.json']) {
            const lockFilePath = path.join(projectBasePath, lockFile);
            try {
                return {
                    lockFilePath,
                    lockFileData: (0, fs_1.readFileSync)(lockFilePath),
                };
            }
            catch (_a) { }
        }
        throw new Error('Cannot locate a package manager lock file.');
    }
}
exports.NgccProcessor = NgccProcessor;
class NgccLogger {
    constructor(compilationWarnings, compilationErrors, level) {
        this.compilationWarnings = compilationWarnings;
        this.compilationErrors = compilationErrors;
        this.level = level;
    }
    // eslint-disable-next-line @typescript-eslint/no-empty-function
    debug() { }
    info(...args) {
        // Log to stderr because it's a progress-like info message.
        process.stderr.write(`\n${args.join(' ')}\n`);
    }
    warn(...args) {
        this.compilationWarnings.push(args.join(' '));
    }
    error(...args) {
        this.compilationErrors.push(new Error(args.join(' ')));
    }
}
function isReadOnlyFile(fileName) {
    try {
        (0, fs_1.accessSync)(fileName, fs_1.constants.W_OK);
        return false;
    }
    catch (_a) {
        return true;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngcc_processor.js","sourceRoot":"","sources":["../../../../../../../packages/ngtools/webpack/src/ngcc_processor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 type { LogLevel, Logger } from '@angular/compiler-cli/ngcc';\nimport { spawnSync } from 'child_process';\nimport { createHash } from 'crypto';\nimport { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';\nimport * as path from 'path';\nimport * as ts from 'typescript';\nimport type { Compiler } from 'webpack';\nimport { time, timeEnd } from './benchmark';\nimport { InputFileSystem } from './ivy/system';\n\n// Extract Resolver type from Webpack types since it is not directly exported\ntype ResolverWithOptions = ReturnType<Compiler['resolverFactory']['get']>;\n\n// We cannot create a plugin for this, because NGTSC requires addition type\n// information which ngcc creates when processing a package which was compiled with NGC.\n\n// Example of such errors:\n// ERROR in node_modules/@angular/platform-browser/platform-browser.d.ts(42,22):\n// error TS-996002: Appears in the NgModule.imports of AppModule,\n// but could not be resolved to an NgModule class\n\n// We now transform a package and it's typings when NGTSC is resolving a module.\n\nexport class NgccProcessor {\n  private _processedModules = new Set<string>();\n  private _logger: NgccLogger;\n  private _nodeModulesDirectory: string | null;\n\n  constructor(\n    private readonly compilerNgcc: typeof import('@angular/compiler-cli/ngcc'),\n    private readonly propertiesToConsider: string[],\n    private readonly compilationWarnings: (Error | string)[],\n    private readonly compilationErrors: (Error | string)[],\n    private readonly basePath: string,\n    private readonly tsConfigPath: string,\n    private readonly inputFileSystem: InputFileSystem,\n    private readonly resolver: ResolverWithOptions,\n  ) {\n    this._logger = new NgccLogger(\n      this.compilationWarnings,\n      this.compilationErrors,\n      compilerNgcc.LogLevel.info,\n    );\n    this._nodeModulesDirectory = this.findNodeModulesDirectory(this.basePath);\n  }\n\n  /** Process the entire node modules tree. */\n  process() {\n    // Under Bazel when running in sandbox mode parts of the filesystem is read-only, or when using\n    // Yarn PnP there may not be a node_modules directory. ngcc can't run in those cases, so the\n    // processing is skipped.\n    if (process.env.BAZEL_TARGET || !this._nodeModulesDirectory) {\n      return;\n    }\n\n    // Skip if node_modules are read-only\n    const corePackage = this.tryResolvePackage('@angular/core', this._nodeModulesDirectory);\n    if (corePackage && isReadOnlyFile(corePackage)) {\n      return;\n    }\n\n    // Perform a ngcc run check to determine if an initial execution is required.\n    // If a run hash file exists that matches the current package manager lock file and the\n    // project's tsconfig, then an initial ngcc run has already been performed.\n    let skipProcessing = false;\n    let runHashFilePath: string | undefined;\n    const runHashBasePath = path.join(this._nodeModulesDirectory, '.cli-ngcc');\n    const projectBasePath = path.join(this._nodeModulesDirectory, '..');\n    try {\n      let ngccConfigData;\n      try {\n        ngccConfigData = readFileSync(path.join(projectBasePath, 'ngcc.config.js'));\n      } catch {\n        ngccConfigData = '';\n      }\n\n      const relativeTsconfigPath = path.relative(projectBasePath, this.tsConfigPath);\n      const tsconfigData = readFileSync(this.tsConfigPath);\n      const { lockFileData, lockFilePath } = this.findPackageManagerLockFile(projectBasePath);\n\n      // Generate a hash that represents the state of the package lock file and used tsconfig\n      const runHash = createHash('sha256')\n        .update(lockFileData)\n        .update(lockFilePath)\n        .update(ngccConfigData)\n        .update(tsconfigData)\n        .update(relativeTsconfigPath)\n        .digest('hex');\n\n      // The hash is used directly in the file name to mitigate potential read/write race\n      // conditions as well as to only require a file existence check\n      runHashFilePath = path.join(runHashBasePath, runHash + '.lock');\n\n      // If the run hash lock file exists, then ngcc was already run against this project state\n      if (existsSync(runHashFilePath)) {\n        skipProcessing = true;\n      }\n    } catch {\n      // Any error means an ngcc execution is needed\n    }\n\n    if (skipProcessing) {\n      return;\n    }\n\n    const timeLabel = 'NgccProcessor.process';\n    time(timeLabel);\n\n    // We spawn instead of using the API because:\n    // - NGCC Async uses clustering which is problematic when used via the API which means\n    // that we cannot setup multiple cluster masters with different options.\n    // - We will not be able to have concurrent builds otherwise Ex: App-Shell,\n    // as NGCC will create a lock file for both builds and it will cause builds to fails.\n    const originalProcessTitle = process.title;\n    try {\n      const { status, error } = spawnSync(\n        process.execPath,\n        [\n          this.compilerNgcc.ngccMainFilePath,\n          '--source' /** basePath */,\n          this._nodeModulesDirectory,\n          '--properties' /** propertiesToConsider */,\n          ...this.propertiesToConsider,\n          '--first-only' /** compileAllFormats */,\n          '--create-ivy-entry-points' /** createNewEntryPointFormats */,\n          '--async',\n          '--tsconfig' /** tsConfigPath */,\n          this.tsConfigPath,\n          '--use-program-dependencies',\n        ],\n        {\n          stdio: ['inherit', process.stderr, process.stderr],\n        },\n      );\n\n      if (status !== 0) {\n        const errorMessage = error?.message || '';\n        throw new Error(errorMessage + `NGCC failed${errorMessage ? ', see above' : ''}.`);\n      }\n    } finally {\n      process.title = originalProcessTitle;\n    }\n\n    timeEnd(timeLabel);\n\n    // ngcc was successful so if a run hash was generated, write it for next time\n    if (runHashFilePath) {\n      try {\n        if (!existsSync(runHashBasePath)) {\n          mkdirSync(runHashBasePath, { recursive: true });\n        }\n        writeFileSync(runHashFilePath, '');\n      } catch {\n        // Errors are non-fatal\n      }\n    }\n  }\n\n  /** Process a module and its dependencies. */\n  processModule(\n    moduleName: string,\n    resolvedModule: ts.ResolvedModule | ts.ResolvedTypeReferenceDirective,\n  ): void {\n    const resolvedFileName = resolvedModule.resolvedFileName;\n    if (\n      !this._nodeModulesDirectory ||\n      !resolvedFileName ||\n      moduleName.startsWith('.') ||\n      this._processedModules.has(resolvedFileName)\n    ) {\n      // Skip when module_modules directory is not present, module is unknown, relative or the\n      // NGCC compiler is not found or already processed.\n      return;\n    }\n\n    const packageJsonPath = this.tryResolvePackage(moduleName, resolvedFileName);\n    // If the package.json is read only we should skip calling NGCC.\n    // With Bazel when running under sandbox the filesystem is read-only.\n    if (!packageJsonPath || isReadOnlyFile(packageJsonPath)) {\n      // add it to processed so the second time round we skip this.\n      this._processedModules.add(resolvedFileName);\n\n      return;\n    }\n\n    const timeLabel = `NgccProcessor.processModule.ngcc.process+${moduleName}`;\n    time(timeLabel);\n    this.compilerNgcc.process({\n      basePath: this._nodeModulesDirectory,\n      targetEntryPointPath: path.dirname(packageJsonPath),\n      propertiesToConsider: this.propertiesToConsider,\n      compileAllFormats: false,\n      createNewEntryPointFormats: true,\n      logger: this._logger,\n      tsConfigPath: this.tsConfigPath,\n    });\n    timeEnd(timeLabel);\n\n    // Purge this file from cache, since NGCC add new mainFields. Ex: module_ivy_ngcc\n    // which are unknown in the cached file.\n    this.inputFileSystem.purge?.(packageJsonPath);\n\n    this._processedModules.add(resolvedFileName);\n  }\n\n  invalidate(fileName: string) {\n    this._processedModules.delete(fileName);\n  }\n\n  /**\n   * Try resolve a package.json file from the resolved .d.ts file.\n   */\n  private tryResolvePackage(moduleName: string, resolvedFileName: string): string | undefined {\n    try {\n      const resolvedPath = this.resolver.resolveSync(\n        {},\n        resolvedFileName,\n        `${moduleName}/package.json`,\n      );\n\n      return resolvedPath || undefined;\n    } catch {\n      // Ex: @angular/compiler/src/i18n/i18n_ast/package.json\n      // or local libraries which don't reside in node_modules\n      const packageJsonPath = path.resolve(resolvedFileName, '../package.json');\n\n      return existsSync(packageJsonPath) ? packageJsonPath : undefined;\n    }\n  }\n\n  private findNodeModulesDirectory(startPoint: string): string | null {\n    let current = startPoint;\n    while (path.dirname(current) !== current) {\n      const nodePath = path.join(current, 'node_modules');\n      if (existsSync(nodePath)) {\n        return nodePath;\n      }\n\n      current = path.dirname(current);\n    }\n\n    return null;\n  }\n\n  private findPackageManagerLockFile(projectBasePath: string): {\n    lockFilePath: string;\n    lockFileData: Buffer;\n  } {\n    for (const lockFile of ['yarn.lock', 'pnpm-lock.yaml', 'package-lock.json']) {\n      const lockFilePath = path.join(projectBasePath, lockFile);\n\n      try {\n        return {\n          lockFilePath,\n          lockFileData: readFileSync(lockFilePath),\n        };\n      } catch {}\n    }\n\n    throw new Error('Cannot locate a package manager lock file.');\n  }\n}\n\nclass NgccLogger implements Logger {\n  constructor(\n    private readonly compilationWarnings: (Error | string)[],\n    private readonly compilationErrors: (Error | string)[],\n    public level: LogLevel,\n  ) {}\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  debug() {}\n\n  info(...args: string[]) {\n    // Log to stderr because it's a progress-like info message.\n    process.stderr.write(`\\n${args.join(' ')}\\n`);\n  }\n\n  warn(...args: string[]) {\n    this.compilationWarnings.push(args.join(' '));\n  }\n\n  error(...args: string[]) {\n    this.compilationErrors.push(new Error(args.join(' ')));\n  }\n}\n\nfunction isReadOnlyFile(fileName: string): boolean {\n  try {\n    accessSync(fileName, constants.W_OK);\n\n    return false;\n  } catch {\n    return true;\n  }\n}\n"]}