@angular/compiler 14.0.0-next.8 → 14.0.0-rc.1

package/src/render3/r3_module_compiler.d.ts

@@ -1,103 +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 { R3DeclareNgModuleFacade } from '../compiler_facade_interface';
-import * as o from '../output/output_ast';
-import { R3CompiledExpression, R3Reference } from './util';
-/**
- * How the selector scope of an NgModule (its declarations, imports, and exports) should be emitted
- * as a part of the NgModule definition.
- */
-export declare enum R3SelectorScopeMode {
-    /**
-     * Emit the declarations inline into the module definition.
-     *
-     * This option is useful in certain contexts where it's known that JIT support is required. The
-     * tradeoff here is that this emit style prevents directives and pipes from being tree-shaken if
-     * they are unused, but the NgModule is used.
-     */
-    Inline = 0,
-    /**
-     * Emit the declarations using a side effectful function call, `ɵɵsetNgModuleScope`, that is
-     * guarded with the `ngJitMode` flag.
-     *
-     * This form of emit supports JIT and can be optimized away if the `ngJitMode` flag is set to
-     * false, which allows unused directives and pipes to be tree-shaken.
-     */
-    SideEffect = 1,
-    /**
-     * Don't generate selector scopes at all.
-     *
-     * This is useful for contexts where JIT support is known to be unnecessary.
-     */
-    Omit = 2
-}
-/**
- * Metadata required by the module compiler to generate a module def (`ɵmod`) for a type.
- */
-export interface R3NgModuleMetadata {
-    /**
-     * An expression representing the module type being compiled.
-     */
-    type: R3Reference;
-    /**
-     * An expression representing the module type being compiled, intended for use within a class
-     * definition itself.
-     *
-     * This can differ from the outer `type` if the class is being compiled by ngcc and is inside
-     * an IIFE structure that uses a different name internally.
-     */
-    internalType: o.Expression;
-    /**
-     * An expression intended for use by statements that are adjacent (i.e. tightly coupled) to but
-     * not internal to a class definition.
-     *
-     * This can differ from the outer `type` if the class is being compiled by ngcc and is inside
-     * an IIFE structure that uses a different name internally.
-     */
-    adjacentType: o.Expression;
-    /**
-     * An array of expressions representing the bootstrap components specified by the module.
-     */
-    bootstrap: R3Reference[];
-    /**
-     * An array of expressions representing the directives and pipes declared by the module.
-     */
-    declarations: R3Reference[];
-    /**
-     * An array of expressions representing the imports of the module.
-     */
-    imports: R3Reference[];
-    /**
-     * An array of expressions representing the exports of the module.
-     */
-    exports: R3Reference[];
-    /**
-     * How to emit the selector scope values (declarations, imports, exports).
-     */
-    selectorScopeMode: R3SelectorScopeMode;
-    /**
-     * Whether to generate closure wrappers for bootstrap, declarations, imports, and exports.
-     */
-    containsForwardDecls: boolean;
-    /**
-     * The set of schemas that declare elements to be allowed in the NgModule.
-     */
-    schemas: R3Reference[] | null;
-    /** Unique ID or expression representing the unique ID of an NgModule. */
-    id: o.Expression | null;
-}
-/**
- * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.
- */
-export declare function compileNgModule(meta: R3NgModuleMetadata): R3CompiledExpression;
-/**
- * This function is used in JIT mode to generate the call to `ɵɵdefineNgModule()` from a call to
- * `ɵɵngDeclareNgModule()`.
- */
-export declare function compileNgModuleDeclarationExpression(meta: R3DeclareNgModuleFacade): o.Expression;
-export declare function createNgModuleType({ type: moduleType, declarations, imports, exports }: R3NgModuleMetadata): o.ExpressionType;

package/src/render3/r3_pipe_compiler.d.ts

@@ -1,50 +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 * as o from '../output/output_ast';
-import { R3DependencyMetadata } from './r3_factory';
-import { R3CompiledExpression, R3Reference } from './util';
-export interface R3PipeMetadata {
-    /**
-     * Name of the pipe type.
-     */
-    name: string;
-    /**
-     * An expression representing a reference to the pipe itself.
-     */
-    type: R3Reference;
-    /**
-     * An expression representing the pipe being compiled, intended for use within a class definition
-     * itself.
-     *
-     * This can differ from the outer `type` if the class is being compiled by ngcc and is inside an
-     * IIFE structure that uses a different name internally.
-     */
-    internalType: o.Expression;
-    /**
-     * Number of generic type parameters of the type itself.
-     */
-    typeArgumentCount: number;
-    /**
-     * Name of the pipe.
-     */
-    pipeName: string;
-    /**
-     * Dependencies of the pipe's constructor.
-     */
-    deps: R3DependencyMetadata[] | null;
-    /**
-     * Whether the pipe is marked as pure.
-     */
-    pure: boolean;
-    /**
-     * Whether the pipe is standalone.
-     */
-    isStandalone: boolean;
-}
-export declare function compilePipeFromMetadata(metadata: R3PipeMetadata): R3CompiledExpression;
-export declare function createPipeType(metadata: R3PipeMetadata): o.Type;

package/src/render3/r3_template_transform.d.ts

@@ -1,24 +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 * as html from '../ml_parser/ast';
-import { ParseError } from '../parse_util';
-import { BindingParser } from '../template_parser/binding_parser';
-import * as t from './r3_ast';
-export interface Render3ParseResult {
-    nodes: t.Node[];
-    errors: ParseError[];
-    styles: string[];
-    styleUrls: string[];
-    ngContentSelectors: string[];
-    commentNodes?: t.Comment[];
-}
-interface Render3ParseOptions {
-    collectCommentNodes: boolean;
-}
-export declare function htmlAstToRender3Ast(htmlNodes: html.Node[], bindingParser: BindingParser, options: Render3ParseOptions): Render3ParseResult;
-export {};

package/src/render3/util.d.ts

@@ -1,94 +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 * as o from '../output/output_ast';
-export declare function typeWithParameters(type: o.Expression, numParams: number): o.ExpressionType;
-export interface R3Reference {
-    value: o.Expression;
-    type: o.Expression;
-}
-/**
- * Result of compilation of a render3 code unit, e.g. component, directive, pipe, etc.
- */
-export interface R3CompiledExpression {
-    expression: o.Expression;
-    type: o.Type;
-    statements: o.Statement[];
-}
-export declare function prepareSyntheticPropertyName(name: string): string;
-export declare function prepareSyntheticListenerName(name: string, phase: string): string;
-export declare function getSafePropertyAccessString(accessor: string, name: string): string;
-export declare function prepareSyntheticListenerFunctionName(name: string, phase: string): string;
-export declare function jitOnlyGuardedExpression(expr: o.Expression): o.Expression;
-export declare function devOnlyGuardedExpression(expr: o.Expression): o.Expression;
-export declare function guardedExpression(guard: string, expr: o.Expression): o.Expression;
-export declare function wrapReference(value: any): R3Reference;
-export declare function refsToArray(refs: R3Reference[], shouldForwardDeclare: boolean): o.Expression;
-/**
- * Describes an expression that may have been wrapped in a `forwardRef()` guard.
- *
- * This is used when describing expressions that can refer to types that may eagerly reference types
- * that have not yet been defined.
- */
-export interface MaybeForwardRefExpression<T extends o.Expression = o.Expression> {
-    /**
-     * The unwrapped expression.
-     */
-    expression: T;
-    /**
-     * Specified whether the `expression` contains a reference to something that has not yet been
-     * defined, and whether the expression is still wrapped in a `forwardRef()` call.
-     *
-     * If this value is `ForwardRefHandling.None` then the `expression` is safe to use as-is.
-     *
-     * Otherwise the `expression` was wrapped in a call to `forwardRef()` and must not be eagerly
-     * evaluated. Instead it must be wrapped in a function closure that will be evaluated lazily to
-     * allow the definition of the expression to be evaluated first.
-     *
-     * In full AOT compilation it can be safe to unwrap the `forwardRef()` call up front if the
-     * expression will actually be evaluated lazily inside a function call after the value of
-     * `expression` has been defined.
-     *
-     * But in other cases, such as partial AOT compilation or JIT compilation the expression will be
-     * evaluated eagerly in top level code so will need to continue to be wrapped in a `forwardRef()`
-     * call.
-     *
-     */
-    forwardRef: ForwardRefHandling;
-}
-export declare function createMayBeForwardRefExpression<T extends o.Expression>(expression: T, forwardRef: ForwardRefHandling): MaybeForwardRefExpression<T>;
-/**
- * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
- * `forwardRef()` call.
- *
- * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
- * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
- * in the code.
- *
- * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
- * `packages/compiler/src/jit_compiler_facade.ts` for more information.
- */
-export declare function convertFromMaybeForwardRefExpression({ expression, forwardRef }: MaybeForwardRefExpression): o.Expression;
-/**
- * Generate an expression that has the given `expr` wrapped in the following form:
- *
- * ```
- * forwardRef(() => expr)
- * ```
- */
-export declare function generateForwardRef(expr: o.Expression): o.Expression;
-/**
- * Specifies how a forward ref has been handled in a MaybeForwardRefExpression
- */
-export declare const enum ForwardRefHandling {
-    /** The expression was not wrapped in a `forwardRef()` call in the first place. */
-    None = 0,
-    /** The expression is still wrapped in a `forwardRef()` call. */
-    Wrapped = 1,
-    /** The expression was wrapped in a `forwardRef()` call but has since been unwrapped. */
-    Unwrapped = 2
-}

package/src/render3/view/api.d.ts

@@ -1,328 +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 { ChangeDetectionStrategy, ViewEncapsulation } from '../../core';
-import { InterpolationConfig } from '../../ml_parser/interpolation_config';
-import * as o from '../../output/output_ast';
-import { ParseSourceSpan } from '../../parse_util';
-import * as t from '../r3_ast';
-import { R3DependencyMetadata } from '../r3_factory';
-import { MaybeForwardRefExpression, R3Reference } from '../util';
-/**
- * Information needed to compile a directive for the render3 runtime.
- */
-export interface R3DirectiveMetadata {
-    /**
-     * Name of the directive type.
-     */
-    name: string;
-    /**
-     * An expression representing a reference to the directive itself.
-     */
-    type: R3Reference;
-    /**
-     * An expression representing a reference to the directive being compiled, intended for use within
-     * a class definition itself.
-     *
-     * This can differ from the outer `type` if the class is being compiled by ngcc and is inside
-     * an IIFE structure that uses a different name internally.
-     */
-    internalType: o.Expression;
-    /**
-     * Number of generic type parameters of the type itself.
-     */
-    typeArgumentCount: number;
-    /**
-     * A source span for the directive type.
-     */
-    typeSourceSpan: ParseSourceSpan;
-    /**
-     * Dependencies of the directive's constructor.
-     */
-    deps: R3DependencyMetadata[] | 'invalid' | null;
-    /**
-     * Unparsed selector of the directive, or `null` if there was no selector.
-     */
-    selector: string | null;
-    /**
-     * Information about the content queries made by the directive.
-     */
-    queries: R3QueryMetadata[];
-    /**
-     * Information about the view queries made by the directive.
-     */
-    viewQueries: R3QueryMetadata[];
-    /**
-     * Mappings indicating how the directive interacts with its host element (host bindings,
-     * listeners, etc).
-     */
-    host: R3HostMetadata;
-    /**
-     * Information about usage of specific lifecycle events which require special treatment in the
-     * code generator.
-     */
-    lifecycle: {
-        /**
-         * Whether the directive uses NgOnChanges.
-         */
-        usesOnChanges: boolean;
-    };
-    /**
-     * A mapping of inputs from class property names to binding property names, or to a tuple of
-     * binding property name and class property name if the names are different.
-     */
-    inputs: {
-        [field: string]: string | [string, string];
-    };
-    /**
-     * A mapping of outputs from class property names to binding property names, or to a tuple of
-     * binding property name and class property name if the names are different.
-     */
-    outputs: {
-        [field: string]: string;
-    };
-    /**
-     * Whether or not the component or directive inherits from another class
-     */
-    usesInheritance: boolean;
-    /**
-     * Whether or not the component or directive inherits its entire decorator from its base class.
-     */
-    fullInheritance: boolean;
-    /**
-     * Reference name under which to export the directive's type in a template,
-     * if any.
-     */
-    exportAs: string[] | null;
-    /**
-     * The list of providers defined in the directive.
-     */
-    providers: o.Expression | null;
-    /**
-     * Whether or not the component or directive is standalone.
-     */
-    isStandalone: boolean;
-}
-/**
- * Specifies how a list of declaration type references should be emitted into the generated code.
- */
-export declare const enum DeclarationListEmitMode {
-    /**
-     * The list of declarations is emitted into the generated code as is.
-     *
-     * ```
-     * directives: [MyDir],
-     * ```
-     */
-    Direct = 0,
-    /**
-     * The list of declarations is emitted into the generated code wrapped inside a closure, which
-     * is needed when at least one declaration is a forward reference.
-     *
-     * ```
-     * directives: function () { return [MyDir, ForwardDir]; },
-     * ```
-     */
-    Closure = 1,
-    /**
-     * Similar to `Closure`, with the addition that the list of declarations can contain individual
-     * items that are themselves forward references. This is relevant for JIT compilations, as
-     * unwrapping the forwardRef cannot be done statically so must be deferred. This mode emits
-     * the declaration list using a mapping transform through `resolveForwardRef` to ensure that
-     * any forward references within the list are resolved when the outer closure is invoked.
-     *
-     * Consider the case where the runtime has captured two declarations in two distinct values:
-     * ```
-     * const dirA = MyDir;
-     * const dirB = forwardRef(function() { return ForwardRef; });
-     * ```
-     *
-     * This mode would emit the declarations captured in `dirA` and `dirB` as follows:
-     * ```
-     * directives: function () { return [dirA, dirB].map(ng.resolveForwardRef); },
-     * ```
-     */
-    ClosureResolved = 2
-}
-/**
- * Information needed to compile a component for the render3 runtime.
- */
-export interface R3ComponentMetadata extends R3DirectiveMetadata {
-    /**
-     * Information about the component's template.
-     */
-    template: {
-        /**
-         * Parsed nodes of the template.
-         */
-        nodes: t.Node[];
-        /**
-         * Any ng-content selectors extracted from the template. Contains `*` when an ng-content
-         * element without selector is present.
-         */
-        ngContentSelectors: string[];
-    };
-    /**
-     * A map of pipe names to an expression referencing the pipe type which are in the scope of the
-     * compilation.
-     */
-    pipes: Map<string, o.Expression>;
-    /**
-     * A list of directive selectors and an expression referencing the directive type which are in the
-     * scope of the compilation.
-     */
-    directives: R3UsedDirectiveMetadata[];
-    /**
-     * Specifies how the 'directives' and/or `pipes` array, if generated, need to be emitted.
-     */
-    declarationListEmitMode: DeclarationListEmitMode;
-    /**
-     * A collection of styling data that will be applied and scoped to the component.
-     */
-    styles: string[];
-    /**
-     * An encapsulation policy for the component's styling.
-     * Possible values:
-     * - `ViewEncapsulation.Emulated`: Apply modified component styles in order to emulate
-     *                                 a native Shadow DOM CSS encapsulation behavior.
-     * - `ViewEncapsulation.None`: Apply component styles globally without any sort of encapsulation.
-     * - `ViewEncapsulation.ShadowDom`: Use the browser's native Shadow DOM API to encapsulate styles.
-     */
-    encapsulation: ViewEncapsulation;
-    /**
-     * A collection of animation triggers that will be used in the component template.
-     */
-    animations: o.Expression | null;
-    /**
-     * The list of view providers defined in the component.
-     */
-    viewProviders: o.Expression | null;
-    /**
-     * Path to the .ts file in which this template's generated code will be included, relative to
-     * the compilation root. This will be used to generate identifiers that need to be globally
-     * unique in certain contexts (such as g3).
-     */
-    relativeContextFilePath: string;
-    /**
-     * Whether translation variable name should contain external message id
-     * (used by Closure Compiler's output of `goog.getMsg` for transition period).
-     */
-    i18nUseExternalIds: boolean;
-    /**
-     * Overrides the default interpolation start and end delimiters ({{ and }}).
-     */
-    interpolation: InterpolationConfig;
-    /**
-     * Strategy used for detecting changes in the component.
-     */
-    changeDetection?: ChangeDetectionStrategy;
-}
-/**
- * Information about a directive that is used in a component template. Only the stable, public
- * facing information of the directive is stored here.
- */
-export interface R3UsedDirectiveMetadata {
-    /**
-     * The type of the directive as an expression.
-     */
-    type: o.Expression;
-    /**
-     * The selector of the directive.
-     */
-    selector: string;
-    /**
-     * The binding property names of the inputs of the directive.
-     */
-    inputs: string[];
-    /**
-     * The binding property names of the outputs of the directive.
-     */
-    outputs: string[];
-    /**
-     * Name under which the directive is exported, if any (exportAs in Angular). Null otherwise.
-     */
-    exportAs: string[] | null;
-    /**
-     * If true then this directive is actually a component; otherwise it is not.
-     */
-    isComponent?: boolean;
-}
-/**
- * Information needed to compile a query (view or content).
- */
-export interface R3QueryMetadata {
-    /**
-     * Name of the property on the class to update with query results.
-     */
-    propertyName: string;
-    /**
-     * Whether to read only the first matching result, or an array of results.
-     */
-    first: boolean;
-    /**
-     * Either an expression representing a type or `InjectionToken` for the query
-     * predicate, or a set of string selectors.
-     */
-    predicate: MaybeForwardRefExpression | string[];
-    /**
-     * Whether to include only direct children or all descendants.
-     */
-    descendants: boolean;
-    /**
-     * If the `QueryList` should fire change event only if actual change to query was computed (vs old
-     * behavior where the change was fired whenever the query was recomputed, even if the recomputed
-     * query resulted in the same list.)
-     */
-    emitDistinctChangesOnly: boolean;
-    /**
-     * An expression representing a type to read from each matched node, or null if the default value
-     * for a given node is to be returned.
-     */
-    read: o.Expression | null;
-    /**
-     * Whether or not this query should collect only static results.
-     *
-     * If static is true, the query's results will be set on the component after nodes are created,
-     * but before change detection runs. This means that any results that relied upon change detection
-     * to run (e.g. results inside *ngIf or *ngFor views) will not be collected. Query results are
-     * available in the ngOnInit hook.
-     *
-     * If static is false, the query's results will be set on the component after change detection
-     * runs. This means that the query results can contain nodes inside *ngIf or *ngFor views, but
-     * the results will not be available in the ngOnInit hook (only in the ngAfterContentInit for
-     * content hooks and ngAfterViewInit for view hooks).
-     */
-    static: boolean;
-}
-/**
- * Mappings indicating how the class interacts with its
- * host element (host bindings, listeners, etc).
- */
-export interface R3HostMetadata {
-    /**
-     * A mapping of attribute binding keys to `o.Expression`s.
-     */
-    attributes: {
-        [key: string]: o.Expression;
-    };
-    /**
-     * A mapping of event binding keys to unparsed expressions.
-     */
-    listeners: {
-        [key: string]: string;
-    };
-    /**
-     * A mapping of property binding keys to unparsed expressions.
-     */
-    properties: {
-        [key: string]: string;
-    };
-    specialAttributes: {
-        styleAttr?: string;
-        classAttr?: string;
-    };
-}

package/src/render3/view/compiler.d.ts

@@ -1,86 +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 { ConstantPool } from '../../constant_pool';
-import * as o from '../../output/output_ast';
-import { ParseError, ParseSourceSpan } from '../../parse_util';
-import { BindingParser } from '../../template_parser/binding_parser';
-import { R3CompiledExpression } from '../util';
-import { R3ComponentMetadata, R3DirectiveMetadata } from './api';
-/**
- * Compile a directive for the render3 runtime as defined by the `R3DirectiveMetadata`.
- */
-export declare function compileDirectiveFromMetadata(meta: R3DirectiveMetadata, constantPool: ConstantPool, bindingParser: BindingParser): R3CompiledExpression;
-/**
- * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`.
- */
-export declare function compileComponentFromMetadata(meta: R3ComponentMetadata, constantPool: ConstantPool, bindingParser: BindingParser): R3CompiledExpression;
-/**
- * Creates the type specification from the component meta. This type is inserted into .d.ts files
- * to be consumed by upstream compilations.
- */
-export declare function createComponentType(meta: R3ComponentMetadata): o.Type;
-/**
- * A set of flags to be used with Queries.
- *
- * NOTE: Ensure changes here are in sync with `packages/core/src/render3/interfaces/query.ts`
- */
-export declare const enum QueryFlags {
-    /**
-     * No flags
-     */
-    none = 0,
-    /**
-     * Whether or not the query should descend into children.
-     */
-    descendants = 1,
-    /**
-     * The query can be computed statically and hence can be assigned eagerly.
-     *
-     * NOTE: Backwards compatibility with ViewEngine.
-     */
-    isStatic = 2,
-    /**
-     * If the `QueryList` should fire change event only if actual change to query was computed (vs old
-     * behavior where the change was fired whenever the query was recomputed, even if the recomputed
-     * query resulted in the same list.)
-     */
-    emitDistinctChangesOnly = 4
-}
-export declare function createDirectiveTypeParams(meta: R3DirectiveMetadata): o.Type[];
-/**
- * Creates the type specification from the directive meta. This type is inserted into .d.ts files
- * to be consumed by upstream compilations.
- */
-export declare function createDirectiveType(meta: R3DirectiveMetadata): o.Type;
-export interface ParsedHostBindings {
-    attributes: {
-        [key: string]: o.Expression;
-    };
-    listeners: {
-        [key: string]: string;
-    };
-    properties: {
-        [key: string]: string;
-    };
-    specialAttributes: {
-        styleAttr?: string;
-        classAttr?: string;
-    };
-}
-export declare function parseHostBindings(host: {
-    [key: string]: string | o.Expression;
-}): ParsedHostBindings;
-/**
- * Verifies host bindings and returns the list of errors (if any). Empty array indicates that a
- * given set of host bindings has no errors.
- *
- * @param bindings set of host bindings to verify.
- * @param sourceSpan source span where host bindings were defined.
- * @returns array of errors associated with a given set of host bindings.
- */
-export declare function verifyHostBindings(bindings: ParsedHostBindings, sourceSpan: ParseSourceSpan): ParseError[];