@angular/compiler-cli 15.2.0-rc.0 → 16.0.0-next.0

package/ngcc/src/host/esm5_host.d.ts

@@ -1,299 +0,0 @@
-/**
- * @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
- */
-import ts from 'typescript';
-import { ClassDeclaration, ClassMember, Declaration, Decorator, FunctionDefinition } from '../../../src/ngtsc/reflection';
-import { Esm2015ReflectionHost, ParamInfo } from './esm2015_host';
-import { NgccClassSymbol } from './ngcc_host';
-/**
- * ESM5 packages contain ECMAScript IIFE functions that act like classes. For example:
- *
- * ```
- * var CommonModule = (function () {
- *  function CommonModule() {
- *  }
- *  CommonModule.decorators = [ ... ];
- *  return CommonModule;
- * ```
- *
- * * "Classes" are decorated if they have a static property called `decorators`.
- * * Members are decorated if there is a matching key on a static property
- *   called `propDecorators`.
- * * Constructor parameters decorators are found on an object returned from
- *   a static method called `ctorParameters`.
- *
- */
-export declare class Esm5ReflectionHost extends Esm2015ReflectionHost {
-    getBaseClassExpression(clazz: ClassDeclaration): ts.Expression | null;
-    /**
-     * Trace an identifier to its declaration, if possible.
-     *
-     * This method attempts to resolve the declaration of the given identifier, tracing back through
-     * imports and re-exports until the original declaration statement is found. A `Declaration`
-     * object is returned if the original declaration is found, or `null` is returned otherwise.
-     *
-     * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE.
-     * If we are looking for the declaration of the identifier of the inner function expression, we
-     * will get hold of the outer "class" variable declaration and return its identifier instead. See
-     * `getClassDeclarationFromInnerFunctionDeclaration()` for more info.
-     *
-     * @param id a TypeScript `ts.Identifier` to trace back to a declaration.
-     *
-     * @returns metadata about the `Declaration` if the original declaration is found, or `null`
-     * otherwise.
-     */
-    getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
-    /**
-     * Parse a function declaration to find the relevant metadata about it.
-     *
-     * In ESM5 we need to do special work with optional arguments to the function, since they get
-     * their own initializer statement that needs to be parsed and then not included in the "body"
-     * statements of the function.
-     *
-     * @param node the function declaration to parse.
-     * @returns an object containing the node, statements and parameters of the function.
-     */
-    getDefinitionOfFunction(node: ts.Node): FunctionDefinition | null;
-    /**
-     * Check whether a `Declaration` corresponds with a known declaration, such as a TypeScript helper
-     * function, and set its `known` property to the appropriate `KnownDeclaration`.
-     *
-     * @param decl The `Declaration` to check.
-     * @return The passed in `Declaration` (potentially enhanced with a `KnownDeclaration`).
-     */
-    detectKnownDeclaration<T extends Declaration>(decl: T): T;
-    /**
-     * In ES5, the implementation of a class is a function expression that is hidden inside an IIFE,
-     * whose value is assigned to a variable (which represents the class to the rest of the program).
-     * So we might need to dig around to get hold of the "class" declaration.
-     *
-     * This method extracts a `NgccClassSymbol` if `declaration` is the function declaration inside
-     * the IIFE. Otherwise, undefined is returned.
-     *
-     * @param declaration the declaration whose symbol we are finding.
-     * @returns the symbol for the node or `undefined` if it is not a "class" or has no symbol.
-     */
-    protected getClassSymbolFromInnerDeclaration(declaration: ts.Node): NgccClassSymbol | undefined;
-    /**
-     * Find the declarations of the constructor parameters of a class identified by its symbol.
-     *
-     * In ESM5, there is no "class" so the constructor that we want is actually the inner function
-     * declaration inside the IIFE, whose return value is assigned to the outer variable declaration
-     * (that represents the class to the rest of the program).
-     *
-     * @param classSymbol the symbol of the class (i.e. the outer variable declaration) whose
-     * parameters we want to find.
-     * @returns an array of `ts.ParameterDeclaration` objects representing each of the parameters in
-     * the class's constructor or `null` if there is no constructor.
-     */
-    protected getConstructorParameterDeclarations(classSymbol: NgccClassSymbol): ts.ParameterDeclaration[] | null;
-    /**
-     * Get the parameter type and decorators for the constructor of a class,
-     * where the information is stored on a static method of the class.
-     *
-     * In this case the decorators are stored in the body of a method
-     * (`ctorParameters`) attached to the constructor function.
-     *
-     * Note that unlike ESM2015 this is a function expression rather than an arrow
-     * function:
-     *
-     * ```
-     * SomeDirective.ctorParameters = function() { return [
-     *   { type: ViewContainerRef, },
-     *   { type: TemplateRef, },
-     *   { type: IterableDiffers, },
-     *   { type: undefined, decorators: [{ type: Inject, args: [INJECTED_TOKEN,] },] },
-     * ]; };
-     * ```
-     *
-     * @param paramDecoratorsProperty the property that holds the parameter info we want to get.
-     * @returns an array of objects containing the type and decorators for each parameter.
-     */
-    protected getParamInfoFromStaticProperty(paramDecoratorsProperty: ts.Symbol): ParamInfo[] | null;
-    /**
-     * Reflect over a symbol and extract the member information, combining it with the
-     * provided decorator information, and whether it is a static member.
-     *
-     * If a class member uses accessors (e.g getters and/or setters) then it gets downleveled
-     * in ES5 to a single `Object.defineProperty()` call. In that case we must parse this
-     * call to extract the one or two ClassMember objects that represent the accessors.
-     *
-     * @param symbol the symbol for the member to reflect over.
-     * @param decorators an array of decorators associated with the member.
-     * @param isStatic true if this member is static, false if it is an instance property.
-     * @returns the reflected member information, or null if the symbol is not a member.
-     */
-    protected reflectMembers(symbol: ts.Symbol, decorators?: Decorator[], isStatic?: boolean): ClassMember[] | null;
-    /**
-     * Find statements related to the given class that may contain calls to a helper.
-     *
-     * In ESM5 code the helper calls are hidden inside the class's IIFE.
-     *
-     * @param classSymbol the class whose helper calls we are interested in. We expect this symbol
-     * to reference the inner identifier inside the IIFE.
-     * @returns an array of statements that may contain helper calls.
-     */
-    protected getStatementsForClass(classSymbol: NgccClassSymbol): ts.Statement[];
-    /**
-     * A constructor function may have been "synthesized" by TypeScript during JavaScript emit,
-     * in the case no user-defined constructor exists and e.g. property initializers are used.
-     * Those initializers need to be emitted into a constructor in JavaScript, so the TypeScript
-     * compiler generates a synthetic constructor.
-     *
-     * We need to identify such constructors as ngcc needs to be able to tell if a class did
-     * originally have a constructor in the TypeScript source. For ES5, we can not tell an
-     * empty constructor apart from a synthesized constructor, but fortunately that does not
-     * matter for the code generated by ngtsc.
-     *
-     * When a class has a superclass however, a synthesized constructor must not be considered
-     * as a user-defined constructor as that prevents a base factory call from being created by
-     * ngtsc, resulting in a factory function that does not inject the dependencies of the
-     * superclass. Hence, we identify a default synthesized super call in the constructor body,
-     * according to the structure that TypeScript's ES2015 to ES5 transformer generates in
-     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1082-L1098
-     *
-     * Additionally, we handle synthetic delegate constructors that are emitted when TypeScript
-     * downlevel's ES2015 synthetically generated to ES5. These vary slightly from the default
-     * structure mentioned above because the ES2015 output uses a spread operator, for delegating
-     * to the parent constructor, that is preserved through a TypeScript helper in ES5. e.g.
-     *
-     * ```
-     * return _super.apply(this, tslib.__spread(arguments)) || this;
-     * ```
-     *
-     * or, since TypeScript 4.2 it would be
-     *
-     * ```
-     * return _super.apply(this, tslib.__spreadArray([], tslib.__read(arguments))) || this;
-     * ```
-     *
-     * Such constructs can be still considered as synthetic delegate constructors as they are
-     * the product of a common TypeScript to ES5 synthetic constructor, just being downleveled
-     * to ES5 using `tsc`. See: https://github.com/angular/angular/issues/38453.
-     *
-     *
-     * @param constructor a constructor function to test
-     * @returns true if the constructor appears to have been synthesized
-     */
-    private isSynthesizedConstructor;
-    /**
-     * Identifies synthesized super calls which pass-through function arguments directly and are
-     * being assigned to a common `_this` variable. The following patterns we intend to match:
-     *
-     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
-     *   ```
-     *   var _this = _super !== null && _super.apply(this, arguments) || this;
-     *   ```
-     *
-     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
-     *   ```
-     *   var _this = _super.apply(this, tslib.__spread(arguments)) || this;
-     *   ```
-     *   or using the syntax emitted since TypeScript 4.2:
-     *   ```
-     *   return _super.apply(this, tslib.__spreadArray([], tslib.__read(arguments))) || this;
-     *   ```
-     *
-     * @param statement a statement that may be a synthesized super call
-     * @returns true if the statement looks like a synthesized super call
-     */
-    private isSynthesizedSuperThisAssignment;
-    /**
-     * Identifies synthesized super calls which pass-through function arguments directly and
-     * are being returned. The following patterns correspond to synthetic super return calls:
-     *
-     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
-     *   ```
-     *   return _super !== null && _super.apply(this, arguments) || this;
-     *   ```
-     *
-     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
-     *   ```
-     *   return _super.apply(this, tslib.__spread(arguments)) || this;
-     *   ```
-     *   or using the syntax emitted since TypeScript 4.2:
-     *   ```
-     *   return _super.apply(this, tslib.__spreadArray([], tslib.__read(arguments))) || this;
-     *   ```
-     *
-     * @param statement a statement that may be a synthesized super call
-     * @returns true if the statement looks like a synthesized super call
-     */
-    private isSynthesizedSuperReturnStatement;
-    /**
-     * Identifies synthesized super calls which pass-through function arguments directly. The
-     * synthetic delegate super call match the following patterns we intend to match:
-     *
-     * 1. Delegate call emitted by TypeScript when it emits ES5 directly.
-     *   ```
-     *   _super !== null && _super.apply(this, arguments) || this;
-     *   ```
-     *
-     * 2. Delegate call emitted by TypeScript when it downlevel's ES2015 to ES5.
-     *   ```
-     *   _super.apply(this, tslib.__spread(arguments)) || this;
-     *   ```
-     *   or using the syntax emitted since TypeScript 4.2:
-     *   ```
-     *   return _super.apply(this, tslib.__spreadArray([], tslib.__read(arguments))) || this;
-     *   ```
-     *
-     * @param expression an expression that may represent a default super call
-     * @returns true if the expression corresponds with the above form
-     */
-    private isSynthesizedDefaultSuperCall;
-    /**
-     * Tests whether the expression corresponds to a `super` call passing through
-     * function arguments without any modification. e.g.
-     *
-     * ```
-     * _super !== null && _super.apply(this, arguments) || this;
-     * ```
-     *
-     * This structure is generated by TypeScript when transforming ES2015 to ES5, see
-     * https://github.com/Microsoft/TypeScript/blob/v3.2.2/src/compiler/transformers/es2015.ts#L1148-L1163
-     *
-     * Additionally, we also handle cases where `arguments` are wrapped by a TypeScript spread
-     * helper.
-     * This can happen if ES2015 class output contain auto-generated constructors due to class
-     * members. The ES2015 output will be using `super(...arguments)` to delegate to the superclass,
-     * but once downleveled to ES5, the spread operator will be persisted through a TypeScript spread
-     * helper. For example:
-     *
-     * ```
-     * _super.apply(this, __spread(arguments)) || this;
-     * ```
-     *
-     * or, since TypeScript 4.2 it would be
-     *
-     * ```
-     * _super.apply(this, tslib.__spreadArray([], tslib.__read(arguments))) || this;
-     * ```
-     *
-     * More details can be found in: https://github.com/angular/angular/issues/38453.
-     *
-     * @param expression an expression that may represent a default super call
-     * @returns true if the expression corresponds with the above form
-     */
-    private isSuperApplyCall;
-    /**
-     * Determines if the provided expression is one of the following call expressions:
-     *
-     * 1. `__spread(arguments)`
-     * 2. `__spreadArray([], __read(arguments))`
-     * 3. `__spreadArray([], __read(arguments), false)`
-     *
-     * The tslib helpers may have been emitted inline as in the above example, or they may be read
-     * from a namespace import.
-     */
-    private isSpreadArgumentsExpression;
-    /**
-     * Inspects the provided expression and determines if it corresponds with a known helper function
-     * as receiver expression.
-     */
-    private extractKnownHelperCall;
-}

package/ngcc/src/host/ngcc_host.d.ts

@@ -1,87 +0,0 @@
-/**
- * @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
- */
-import ts from 'typescript';
-import { ClassDeclaration, Declaration, Decorator, ReflectionHost } from '../../../src/ngtsc/reflection';
-import { SymbolWithValueDeclaration } from '../../../src/ngtsc/util/src/typescript';
-/**
- * The symbol corresponding to a "class" declaration. I.e. a `ts.Symbol` whose `valueDeclaration` is
- * a `ClassDeclaration`.
- */
-export type ClassSymbol = ts.Symbol & {
-    valueDeclaration: ClassDeclaration;
-};
-/**
- * A representation of a class that accounts for the potential existence of two `ClassSymbol`s for a
- * given class, as the compiled JavaScript bundles that ngcc reflects on can have two declarations.
- */
-export interface NgccClassSymbol {
-    /**
-     * The name of the class.
-     */
-    name: string;
-    /**
-     * Represents the symbol corresponding with the outer declaration of the class. This should be
-     * considered the public class symbol, i.e. its declaration is visible to the rest of the program.
-     */
-    declaration: ClassSymbol;
-    /**
-     * Represents the symbol corresponding with the inner declaration of the class, referred to as its
-     * "implementation". This is not necessarily a `ClassSymbol` but rather just a `ts.Symbol`, as the
-     * inner declaration does not need to satisfy the requirements imposed on a publicly visible class
-     * declaration.
-     */
-    implementation: SymbolWithValueDeclaration;
-    /**
-     * Represents the symbol corresponding to a variable within a class IIFE that may be used to
-     * attach static properties or decorated.
-     */
-    adjacent?: SymbolWithValueDeclaration;
-}
-/**
- * A reflection host that has extra methods for looking at non-Typescript package formats
- */
-export interface NgccReflectionHost extends ReflectionHost {
-    /**
-     * Find a symbol for a declaration that we think is a class.
-     * @param declaration The declaration whose symbol we are finding
-     * @returns the symbol for the declaration or `undefined` if it is not
-     * a "class" or has no symbol.
-     */
-    getClassSymbol(declaration: ts.Node): NgccClassSymbol | undefined;
-    /**
-     * Retrieves all decorators of a given class symbol.
-     * @param symbol Class symbol that can refer to a declaration which can hold decorators.
-     * @returns An array of decorators or null if none are declared.
-     */
-    getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[] | null;
-    /**
-     * Retrieves all class symbols of a given source file.
-     * @param sourceFile The source file to search for classes.
-     * @returns An array of found class symbols.
-     */
-    findClassSymbols(sourceFile: ts.SourceFile): NgccClassSymbol[];
-    /**
-     * Find the last node that is relevant to the specified class.
-     *
-     * As well as the main declaration, classes can have additional statements such as static
-     * properties (`SomeClass.staticProp = ...;`) and decorators (`__decorate(SomeClass, ...);`).
-     * It is useful to know exactly where the class "ends" so that we can inject additional
-     * statements after that point.
-     *
-     * @param classSymbol The class whose statements we want.
-     */
-    getEndOfClass(classSymbol: NgccClassSymbol): ts.Node;
-    /**
-     * Check whether a `Declaration` corresponds with a known declaration and set its `known` property
-     * to the appropriate `KnownDeclaration`.
-     *
-     * @param decl The `Declaration` to check.
-     * @return The passed in `Declaration` (potentially enhanced with a `KnownDeclaration`).
-     */
-    detectKnownDeclaration<T extends Declaration>(decl: T): T;
-}

package/ngcc/src/host/umd_host.d.ts

@@ -1,85 +0,0 @@
-/**
- * @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
- */
-import ts from 'typescript';
-import { Logger } from '../../../src/ngtsc/logging';
-import { Declaration, Import } from '../../../src/ngtsc/reflection';
-import { BundleProgram } from '../packages/bundle_program';
-import { FactoryMap } from '../utils';
-import { Esm5ReflectionHost } from './esm5_host';
-import { NgccClassSymbol } from './ngcc_host';
-export declare class UmdReflectionHost extends Esm5ReflectionHost {
-    protected umdModules: FactoryMap<ts.SourceFile, UmdModule | null>;
-    protected umdExports: FactoryMap<ts.SourceFile, Map<string, Declaration<ts.Declaration>> | null>;
-    protected umdImportPaths: FactoryMap<ts.ParameterDeclaration, string | null>;
-    protected program: ts.Program;
-    protected compilerHost: ts.CompilerHost;
-    constructor(logger: Logger, isCore: boolean, src: BundleProgram, dts?: BundleProgram | null);
-    getImportOfIdentifier(id: ts.Identifier): Import | null;
-    getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
-    getExportsOfModule(module: ts.Node): Map<string, Declaration> | null;
-    getUmdModule(sourceFile: ts.SourceFile): UmdModule | null;
-    getUmdImportPath(importParameter: ts.ParameterDeclaration): string | null;
-    /**
-     * Get the top level statements for a module.
-     *
-     * In UMD modules these are the body of the UMD factory function.
-     *
-     * @param sourceFile The module whose statements we want.
-     * @returns An array of top level statements for the given module.
-     */
-    protected getModuleStatements(sourceFile: ts.SourceFile): ts.Statement[];
-    protected getClassSymbolFromOuterDeclaration(declaration: ts.Node): NgccClassSymbol | undefined;
-    protected getClassSymbolFromInnerDeclaration(declaration: ts.Node): NgccClassSymbol | undefined;
-    /**
-     * Extract all "classes" from the `statement` and add them to the `classes` map.
-     */
-    protected addClassSymbolsFromStatement(classes: Map<ts.Symbol, NgccClassSymbol>, statement: ts.Statement): void;
-    /**
-     * Analyze the given statement to see if it corresponds with an exports declaration like
-     * `exports.MyClass = MyClass_1 = <class def>;`. If so, the declaration of `MyClass_1`
-     * is associated with the `MyClass` identifier.
-     *
-     * @param statement The statement that needs to be preprocessed.
-     */
-    protected preprocessStatement(statement: ts.Statement): void;
-    private computeUmdModule;
-    private computeExportsOfUmdModule;
-    private computeImportPath;
-    private extractBasicUmdExportDeclaration;
-    private extractUmdWildcardReexports;
-    private extractUmdDefinePropertyExportDeclaration;
-    /**
-     * Is the identifier a parameter on a UMD factory function, e.g. `function factory(this, core)`?
-     * If so then return its declaration.
-     */
-    private findUmdImportParameter;
-    private getUmdDeclaration;
-    private getExportsDeclaration;
-    private getUmdModuleDeclaration;
-    private getImportPathFromParameter;
-    private getImportPathFromRequireCall;
-    /**
-     * If this is an IIFE then try to grab the outer and inner classes otherwise fallback on the super
-     * class.
-     */
-    protected getDeclarationOfExpression(expression: ts.Expression): Declaration | null;
-    private resolveModuleName;
-}
-export declare function parseStatementForUmdModule(statement: ts.Statement): UmdModule | null;
-export declare function getImportsOfUmdModule(umdModule: UmdModule): {
-    parameter: ts.ParameterDeclaration;
-    path: string;
-}[];
-interface UmdModule {
-    wrapperFn: ts.FunctionExpression;
-    factoryFn: ts.FunctionExpression;
-    factoryCalls: Record<'amdDefine' | 'commonJs' | 'commonJs2' | 'global', ts.CallExpression | null> & {
-        cjsCallForImports: ts.CallExpression;
-    };
-}
-export {};

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

@@ -1,9 +0,0 @@
-/**
- * @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
- */
-import ts from 'typescript';
-export declare function stripParentheses(node: ts.Node): ts.Node;

package/ngcc/src/locking/async_locker.d.ts

@@ -1,34 +0,0 @@
-/**
- * @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
- */
-import { Logger } from '../../../src/ngtsc/logging';
-import { LockFile } from './lock_file';
-/**
- * AsyncLocker is used to prevent more than one instance of ngcc executing at the same time,
- * when being called in an asynchronous context.
- *
- * * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder.
- * * If it finds one is already there then it pauses and waits for the file to be removed by the
- *   other process. If the file is not removed within a set timeout period given by
- *   `retryDelay*retryAttempts` an error is thrown with a suitable error message.
- * * If the process locking the file changes, then we restart the timeout.
- * * When ngcc completes executing, it removes the file so that future ngcc executions can start.
- */
-export declare class AsyncLocker {
-    private lockFile;
-    protected logger: Logger;
-    private retryDelay;
-    private retryAttempts;
-    constructor(lockFile: LockFile, logger: Logger, retryDelay: number, retryAttempts: number);
-    /**
-     * Run a function guarded by the lock file.
-     *
-     * @param fn The function to run.
-     */
-    lock<T>(fn: () => Promise<T>): Promise<T>;
-    protected create(): Promise<void>;
-}

package/ngcc/src/locking/lock_file.d.ts

@@ -1,31 +0,0 @@
-/**
- * @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
- */
-import { AbsoluteFsPath, PathManipulation } from '../../../src/ngtsc/file_system';
-/** Wrapper for resolving the lcok file path. Useful for test patching. */
-export declare class LockFilePathResolver {
-    static resolve(fs: PathManipulation): AbsoluteFsPath;
-}
-export interface LockFile {
-    path: AbsoluteFsPath;
-    /**
-     * Write a lock file to disk containing the PID of the current process.
-     */
-    write(): void;
-    /**
-     * Read the PID, of the process holding the lock, from the lock-file.
-     *
-     * It is feasible that the lock-file was removed between the call to `write()` that effectively
-     * checks for existence and this attempt to read the file. If so then this method should just
-     * gracefully return `"{unknown}"`.
-     */
-    read(): string;
-    /**
-     * Remove the lock file from disk, whether or not it exists.
-     */
-    remove(): void;
-}

package/ngcc/src/locking/lock_file_with_child_process/index.d.ts

@@ -1,44 +0,0 @@
-/// <reference types="node" />
-/**
- * @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
- */
-import { ChildProcess } from 'child_process';
-import { AbsoluteFsPath, FileSystem } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-import { LockFile } from '../lock_file';
-/**
- * This `LockFile` implementation uses a child-process to remove the lock file when the main process
- * exits (for whatever reason).
- *
- * There are a few milliseconds between the child-process being forked and it registering its
- * `disconnect` event, which is responsible for tidying up the lock-file in the event that the main
- * process exits unexpectedly.
- *
- * We eagerly create the unlocker child-process so that it maximizes the time before the lock-file
- * is actually written, which makes it very unlikely that the unlocker would not be ready in the
- * case that the developer hits Ctrl-C or closes the terminal within a fraction of a second of the
- * lock-file being created.
- *
- * The worst case scenario is that ngcc is killed too quickly and leaves behind an orphaned
- * lock-file. In which case the next ngcc run will display a helpful error message about deleting
- * the lock-file.
- */
-export declare class LockFileWithChildProcess implements LockFile {
-    protected fs: FileSystem;
-    protected logger: Logger;
-    path: AbsoluteFsPath;
-    private unlocker;
-    constructor(fs: FileSystem, logger: Logger);
-    write(): void;
-    read(): string;
-    remove(): void;
-    protected createUnlocker(path: AbsoluteFsPath): ChildProcess;
-}
-/** Wrapper for resolving the lock file unlocker script. Useful for test patching. */
-export declare class LockFileUnlockerScriptResolver {
-    static resolve(fs: FileSystem): AbsoluteFsPath;
-}

package/ngcc/src/locking/lock_file_with_child_process/ngcc_lock_unlocker.d.ts

@@ -1 +0,0 @@
-export {};

package/ngcc/src/locking/lock_file_with_child_process/util.d.ts

@@ -1,16 +0,0 @@
-/**
- * @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
- */
-import { AbsoluteFsPath, FileSystem } from '../../../../src/ngtsc/file_system';
-import { Logger } from '../../../../src/ngtsc/logging';
-/**
- * Remove the lock-file at the provided `lockFilePath` from the given file-system.
- *
- * It only removes the file if the pid stored in the file matches the provided `pid`.
- * The provided `pid` is of the process that is exiting and so no longer needs to hold the lock.
- */
-export declare function removeLockFile(fs: FileSystem, logger: Logger, lockFilePath: AbsoluteFsPath, pid: string): void;

package/ngcc/src/locking/sync_locker.d.ts

@@ -1,35 +0,0 @@
-/**
- * @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
- */
-import { LockFile } from './lock_file';
-/**
- * SyncLocker is used to prevent more than one instance of ngcc executing at the same time,
- * when being called in a synchronous context.
- *
- * * When ngcc starts executing, it creates a file in the `compiler-cli/ngcc` folder.
- * * If it finds one is already there then it fails with a suitable error message.
- * * When ngcc completes executing, it removes the file so that future ngcc executions can start.
- */
-export declare class SyncLocker {
-    private lockFile;
-    constructor(lockFile: LockFile);
-    /**
-     * Run the given function guarded by the lock file.
-     *
-     * @param fn the function to run.
-     * @returns the value returned from the `fn` call.
-     */
-    lock<T>(fn: () => T): T;
-    /**
-     * Write a lock file to disk, or error if there is already one there.
-     */
-    protected create(): void;
-    /**
-     * The lock-file already exists so raise a helpful error.
-     */
-    protected handleExistingLockFile(): void;
-}

package/ngcc/src/main.d.ts

@@ -1,17 +0,0 @@
-/**
- * @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
- */
-import { AsyncNgccOptions, SyncNgccOptions } from './ngcc_options';
-/**
- * This is the main entry-point into ngcc (aNGular Compatibility Compiler).
- *
- * You can call this function to process one or more npm packages, to ensure
- * that they are compatible with the ivy compiler (ngtsc).
- *
- * @param options The options telling ngcc what to compile and how.
- */
-export declare function mainNgcc<T extends AsyncNgccOptions | SyncNgccOptions>(options: T): T extends AsyncNgccOptions ? Promise<void> : void;