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

package/ngcc/src/execution/tasks/queues/parallel_task_queue.d.ts

@@ -1,27 +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 { PartiallyOrderedTasks, Task, TaskDependencies } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed in parallel, thus has to ensure a
- * task's dependencies have been processed before processing the task.
- */
-export declare class ParallelTaskQueue extends BaseTaskQueue {
-    /**
-     * A map from Tasks to the Tasks that it depends upon.
-     *
-     * This is the reverse mapping of `TaskDependencies`.
-     */
-    private blockedTasks;
-    constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies);
-    computeNextTask(): Task | null;
-    markAsCompleted(task: Task): void;
-    toString(): string;
-    private stringifyBlockedTasks;
-}

package/ngcc/src/execution/tasks/queues/serial_task_queue.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 { Task } from '../api';
-import { BaseTaskQueue } from './base_task_queue';
-/**
- * A `TaskQueue` implementation that assumes tasks are processed serially and each one is completed
- * before requesting the next one.
- */
-export declare class SerialTaskQueue extends BaseTaskQueue {
-    computeNextTask(): Task | null;
-}

package/ngcc/src/execution/tasks/utils.d.ts

@@ -1,57 +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 { DepGraph } from 'dependency-graph';
-import { EntryPoint } from '../../packages/entry_point';
-import { PartiallyOrderedTasks, Task, TaskDependencies } from './api';
-/** Stringify a task for debugging purposes. */
-export declare const stringifyTask: (task: Task) => string;
-/**
- * Compute a mapping of tasks to the tasks that are dependent on them (if any).
- *
- * Task A can depend upon task B, if either:
- *
- * * A and B have the same entry-point _and_ B is generating the typings for that entry-point
- *   (i.e. has `processDts: true`).
- * * A's entry-point depends on B's entry-point _and_ B is also generating typings.
- *
- * NOTE: If a task is not generating typings, then it cannot affect anything which depends on its
- *       entry-point, regardless of the dependency graph. To put this another way, only the task
- *       which produces the typings for a dependency needs to have been completed.
- *
- * As a performance optimization, we take into account the fact that `tasks` are sorted in such a
- * way that a task can only depend on earlier tasks (i.e. dependencies always come before
- * dependents in the list of tasks).
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param graph The dependency graph between entry-points.
- * @return A map from each task to those tasks directly dependent upon it.
- */
-export declare function computeTaskDependencies(tasks: PartiallyOrderedTasks, graph: DepGraph<EntryPoint>): TaskDependencies;
-export declare function getDependentsSet(map: TaskDependencies, task: Task): Set<Task>;
-/**
- * Invert the given mapping of Task dependencies.
- *
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @returns A mapping of tasks to the tasks that they depend upon.
- */
-export declare function getBlockedTasks(dependencies: TaskDependencies): Map<Task, Set<Task>>;
-/**
- * Sort a list of tasks by priority.
- *
- * Priority is determined by the number of other tasks that a task is (transitively) blocking:
- * The more tasks a task is blocking the higher its priority is, because processing it will
- * potentially unblock more tasks.
- *
- * To keep the behavior predictable, if two tasks block the same number of other tasks, their
- * relative order in the original `tasks` lists is preserved.
- *
- * @param tasks A (partially ordered) list of tasks.
- * @param dependencies The mapping of tasks to the tasks that depend upon them.
- * @return The list of tasks sorted by priority.
- */
-export declare function sortTasksByPriority(tasks: PartiallyOrderedTasks, dependencies: TaskDependencies): PartiallyOrderedTasks;

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

@@ -1,69 +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 CommonJsReflectionHost extends Esm5ReflectionHost {
-    protected commonJsExports: FactoryMap<ts.SourceFile, Map<string, Declaration<ts.Declaration>> | null>;
-    protected topLevelHelperCalls: FactoryMap<string, FactoryMap<ts.SourceFile, ts.CallExpression[]>>;
-    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;
-    /**
-     * Search statements related to the given class for calls to the specified helper.
-     *
-     * In CommonJS these helper calls can be outside the class's IIFE at the top level of the
-     * source file. Searching the top level statements for helpers can be expensive, so we
-     * try to get helpers from the IIFE first and only fall back on searching the top level if
-     * no helpers are found.
-     *
-     * @param classSymbol the class whose helper calls we are interested in.
-     * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested
-     * in.
-     * @returns an array of nodes of calls to the helper with the given name.
-     */
-    protected getHelperCallsForClass(classSymbol: NgccClassSymbol, helperNames: string[]): ts.CallExpression[];
-    /**
-     * Find all the helper calls at the top level of a source file.
-     *
-     * We cache the helper calls per source file so that we don't have to keep parsing the code for
-     * each class in a file.
-     *
-     * @param sourceFile the source who may contain helper calls.
-     * @param helperNames the names of the helpers (e.g. `__decorate`) whose calls we are interested
-     * in.
-     * @returns an array of nodes of calls to the helper with the given name.
-     */
-    private getTopLevelHelperCalls;
-    private computeExportsOfCommonJsModule;
-    private extractBasicCommonJsExportDeclaration;
-    private extractCommonJsWildcardReexports;
-    private extractCommonJsDefinePropertyExportDeclaration;
-    private findCommonJsImport;
-    /**
-     * Handle the case where the identifier represents a reference to a whole CommonJS
-     * module, i.e. the result of a call to `require(...)`.
-     *
-     * @param id the identifier whose declaration we are looking for.
-     * @returns a declaration if `id` refers to a CommonJS module, or `null` otherwise.
-     */
-    private getCommonJsModuleDeclaration;
-    /**
-     * If this is an IFE then try to grab the outer and inner classes otherwise fallback on the super
-     * class.
-     */
-    protected getDeclarationOfExpression(expression: ts.Expression): Declaration | null;
-    private resolveModuleName;
-}

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

@@ -1,146 +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 { Declaration } from '../../../src/ngtsc/reflection';
-export interface ExportDeclaration {
-    name: string;
-    declaration: Declaration;
-}
-/**
- * A CommonJS or UMD wildcard re-export statement.
- *
- * The CommonJS or UMD version of `export * from 'blah';`.
- *
- * These statements can have several forms (depending, for example, on whether
- * the TypeScript helpers are imported or emitted inline). The expression can have one of the
- * following forms:
- * - `__export(firstArg)`
- * - `__exportStar(firstArg)`
- * - `tslib.__export(firstArg, exports)`
- * - `tslib.__exportStar(firstArg, exports)`
- *
- * In all cases, we only care about `firstArg`, which is the first argument of the re-export call
- * expression and can be either a `require('...')` call or an identifier (initialized via a
- * `require('...')` call).
- */
-export interface WildcardReexportStatement extends ts.ExpressionStatement {
-    expression: ts.CallExpression;
-}
-/**
- * A CommonJS or UMD re-export statement using an `Object.defineProperty()` call.
- * For example:
- *
- * ```
- * Object.defineProperty(exports, "<exported-id>",
- *     { enumerable: true, get: function () { return <imported-id>; } });
- * ```
- */
-export interface DefinePropertyReexportStatement extends ts.ExpressionStatement {
-    expression: ts.CallExpression & {
-        arguments: [ts.Identifier, ts.StringLiteral, ts.ObjectLiteralExpression];
-    };
-}
-/**
- * A call expression that has a string literal for its first argument.
- */
-export interface RequireCall extends ts.CallExpression {
-    arguments: ts.CallExpression['arguments'] & [ts.StringLiteral];
-}
-/**
- * Return the "namespace" of the specified `ts.Identifier` if the identifier is the RHS of a
- * property access expression, i.e. an expression of the form `<namespace>.<id>` (in which case a
- * `ts.Identifier` corresponding to `<namespace>` will be returned). Otherwise return `null`.
- */
-export declare function findNamespaceOfIdentifier(id: ts.Identifier): ts.Identifier | null;
-/**
- * Return the `RequireCall` that is used to initialize the specified `ts.Identifier`, if the
- * specified identifier was indeed initialized with a require call in a declaration of the form:
- * `var <id> = require('...')`
- */
-export declare function findRequireCallReference(id: ts.Identifier, checker: ts.TypeChecker): RequireCall | null;
-/**
- * Check whether the specified `ts.Statement` is a wildcard re-export statement.
- * I.E. an expression statement of one of the following forms:
- * - `__export(<foo>)`
- * - `__exportStar(<foo>)`
- * - `tslib.__export(<foo>, exports)`
- * - `tslib.__exportStar(<foo>, exports)`
- */
-export declare function isWildcardReexportStatement(stmt: ts.Statement): stmt is WildcardReexportStatement;
-/**
- * Check whether the statement is a re-export of the form:
- *
- * ```
- * Object.defineProperty(exports, "<export-name>",
- *     { enumerable: true, get: function () { return <import-name>; } });
- * ```
- */
-export declare function isDefinePropertyReexportStatement(stmt: ts.Statement): stmt is DefinePropertyReexportStatement;
-/**
- * Extract the "value" of the getter in a `defineProperty` statement.
- *
- * This will return the `ts.Expression` value of a single `return` statement in the `get` method
- * of the property definition object, or `null` if that is not possible.
- */
-export declare function extractGetterFnExpression(statement: DefinePropertyReexportStatement): ts.Expression | null;
-/**
- * Check whether the specified `ts.Node` represents a `require()` call, i.e. an call expression of
- * the form: `require('<foo>')`
- */
-export declare function isRequireCall(node: ts.Node): node is RequireCall;
-/**
- * Check whether the specified `path` is an "external" import.
- * In other words, that it comes from a entry-point outside the current one.
- */
-export declare function isExternalImport(path: string): boolean;
-/**
- * A UMD/CommonJS style export declaration of the form `exports.<name>`.
- */
-export interface ExportsDeclaration extends ts.PropertyAccessExpression {
-    name: ts.Identifier;
-    expression: ts.Identifier;
-    parent: ExportsAssignment;
-}
-/**
- * Check whether the specified `node` is a property access expression of the form
- * `exports.<foo>`.
- */
-export declare function isExportsDeclaration(expr: ts.Node): expr is ExportsDeclaration;
-/**
- * A UMD/CommonJS style export assignment of the form `exports.<foo> = <bar>`.
- */
-export interface ExportsAssignment extends ts.BinaryExpression {
-    left: ExportsDeclaration;
-}
-/**
- * Check whether the specified `node` is an assignment expression of the form
- * `exports.<foo> = <bar>`.
- */
-export declare function isExportsAssignment(expr: ts.Node): expr is ExportsAssignment;
-/**
- * An expression statement of the form `exports.<foo> = <bar>;`.
- */
-export interface ExportsStatement extends ts.ExpressionStatement {
-    expression: ExportsAssignment;
-}
-/**
- * Check whether the specified `stmt` is an expression statement of the form
- * `exports.<foo> = <bar>;`.
- */
-export declare function isExportsStatement(stmt: ts.Node): stmt is ExportsStatement;
-/**
- * Find the far right hand side of a sequence of aliased assignments of the form
- *
- * ```
- * exports.MyClass = alias1 = alias2 = <<declaration>>
- * ```
- *
- * @param node the expression to parse
- * @returns the original `node` or the far right expression of a series of assignments.
- */
-export declare function skipAliases(node: ts.Expression): ts.Expression;

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

@@ -1,43 +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, CtorParameter, Declaration, DeclarationNode, Decorator, FunctionDefinition, Import, ReflectionHost } from '../../../src/ngtsc/reflection';
-import { NgccClassSymbol, NgccReflectionHost } from './ngcc_host';
-/**
- * A reflection host implementation that delegates reflector queries depending on whether they
- * reflect on declaration files (for dependent libraries) or source files within the entry-point
- * that is being compiled. The first type of queries are handled by the regular TypeScript
- * reflection host, whereas the other queries are handled by an `NgccReflectionHost` that is
- * specific to the entry-point's format.
- */
-export declare class DelegatingReflectionHost implements NgccReflectionHost {
-    private tsHost;
-    private ngccHost;
-    constructor(tsHost: ReflectionHost, ngccHost: NgccReflectionHost);
-    getConstructorParameters(clazz: ClassDeclaration): CtorParameter[] | null;
-    getDeclarationOfIdentifier(id: ts.Identifier): Declaration | null;
-    getDecoratorsOfDeclaration(declaration: DeclarationNode): Decorator[] | null;
-    getDefinitionOfFunction(fn: ts.Node): FunctionDefinition | null;
-    getDtsDeclaration(declaration: DeclarationNode): ts.Declaration | null;
-    getExportsOfModule(module: ts.Node): Map<string, Declaration> | null;
-    getGenericArityOfClass(clazz: ClassDeclaration): number | null;
-    getImportOfIdentifier(id: ts.Identifier): Import | null;
-    getInternalNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getAdjacentNameOfClass(clazz: ClassDeclaration): ts.Identifier;
-    getMembersOfClass(clazz: ClassDeclaration): ClassMember[];
-    getVariableValue(declaration: ts.VariableDeclaration): ts.Expression | null;
-    hasBaseClass(clazz: ClassDeclaration): boolean;
-    getBaseClassExpression(clazz: ClassDeclaration): ts.Expression | null;
-    isClass(node: ts.Node): node is ClassDeclaration;
-    findClassSymbols(sourceFile: ts.SourceFile): NgccClassSymbol[];
-    getClassSymbol(node: ts.Node): NgccClassSymbol | undefined;
-    getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[] | null;
-    getEndOfClass(classSymbol: NgccClassSymbol): ts.Node;
-    detectKnownDeclaration<T extends Declaration>(decl: T): T;
-    isStaticallyExported(decl: ts.Node): boolean;
-}