@angular/compiler-cli 15.2.1 → 16.0.0-next.1

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;
-}