@angular/core 14.0.0-next.14 → 14.0.0-next.15

package/esm2020/src/render3/interfaces/definition.mjs

@@ -8,4 +8,4 @@
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.
 export const unusedValueExportToPlacateAjd = 1;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA4aH,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC","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 {ProcessProvidersFunction} from '../../di/interface/provider';\nimport {Type} from '../../interface/type';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {FactoryFn} from '../definition_factory';\n\nimport {TAttributes, TConstantsOrFactory} from './node';\nimport {CssSelectorList} from './projection';\nimport {TView} from './view';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  // Note: the ctx parameter is typed as T|U, as using only U would prevent a template with\n  // e.g. ctx: {} from being assigned to ComponentTemplate<any> as TypeScript won't infer U = any\n  // in that scenario. By including T this incompatibility is resolved.\n  <U extends T>(rf: RenderFlags, ctx: T|U): void;\n};\n\n/**\n * Definition of what a view queries function should look like.\n */\nexport type ViewQueriesFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Definition of what a content queries function should look like.\n */\nexport type ContentQueriesFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, directiveIndex: number) => void;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ɵcmp`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> {\n  ɵcmp: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵdir`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> {\n  ɵdir: unknown;\n  ɵfac: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵpipe`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> {\n  ɵpipe: unknown;\n}\n\n\n\n/**\n * Runtime link information for Directives.\n *\n * This is an internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: string};\n\n  /**\n   * Function to create and refresh content queries associated with a given directive.\n   */\n  contentQueries: ContentQueriesFunction<T>|null;\n\n  /**\n   * Query-related instructions for a directive. Note that while directives don't have a\n   * view and as such view queries won't necessarily do anything, there might be\n   * components that extend the directive.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * Refreshes host bindings on the associated directive.\n   */\n  readonly hostBindings: HostBindingsFunction<T>|null;\n\n  /**\n   * The number of bindings in this directive `hostBindings` (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly hostVars: number;\n\n  /**\n   * Assign static attribute values to a host element.\n   *\n   * This property will assign static attribute values as well as class and style\n   * values to a host element. Since attribute values can consist of different types of values, the\n   * `hostAttrs` array must include the values in the following format:\n   *\n   * attrs = [\n   *   // static attributes (like `title`, `name`, `id`...)\n   *   attr1, value1, attr2, value,\n   *\n   *   // a single namespace value (like `x:id`)\n   *   NAMESPACE_MARKER, namespaceUri1, name1, value1,\n   *\n   *   // another single namespace value (like `x:name`)\n   *   NAMESPACE_MARKER, namespaceUri2, name2, value2,\n   *\n   *   // a series of CSS classes that will be applied to the element (no spaces)\n   *   CLASSES_MARKER, class1, class2, class3,\n   *\n   *   // a series of CSS styles (property + value) that will be applied to the element\n   *   STYLES_MARKER, prop1, value1, prop2, value2\n   * ]\n   *\n   * All non-class and non-style attributes must be defined at the start of the list\n   * first before all class and style values are set. When there is a change in value\n   * type (like when classes and styles are introduced) a marker must be used to separate\n   * the entries. The marker values themselves are set via entries found in the\n   * [AttributeMarker] enum.\n   */\n  readonly hostAttrs: TAttributes|null;\n\n  /** Token representing the directive. Used by DI. */\n  readonly type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver:\n      (<U extends T>(def: DirectiveDef<U>, processProvidersFn?: ProcessProvidersFunction) =>\n           void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  readonly selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string[]|null;\n\n  /**\n   * Whether this directive (or component) is standalone.\n   */\n  readonly standalone: boolean;\n\n  /**\n   * Factory function used to create a new directive instance. Will be null initially.\n   * Populated when the factory is first requested by directive instantiation logic.\n   */\n  readonly factory: FactoryFn<T>|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n\n  setInput:\n      (<U extends T>(\n           this: DirectiveDef<U>, instance: U, value: any, publicName: string,\n           privateName: string) => void)|null;\n}\n\n/**\n * Runtime link information for Components.\n *\n * This is an internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Runtime unique component ID.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /** Constants associated with the component's view. */\n  readonly consts: TConstantsOrFactory|null;\n\n  /**\n   * An array of `ngContent[selector]` values that were found in the template.\n   */\n  readonly ngContentSelectors?: string[];\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly decls: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {[kind: string]: any};\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the component's template.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Ivy runtime uses this place to store the computed tView for the component. This gets filled on\n   * the first run of component.\n   */\n  tView: TView|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: unknown;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is an internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /** Token representing the pipe. */\n  type: Type<T>;\n\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  readonly name: string;\n\n  /**\n   * Factory function used to create a new pipe instance. Will be null initially.\n   * Populated when the factory is first requested by pipe instantiation logic.\n   */\n  factory: FactoryFn<T>|null;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  readonly pure: boolean;\n\n  /**\n   * Whether this pipe is standalone.\n   */\n  readonly standalone: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList)|DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>|ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList)|DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveType<any>|ComponentType<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type DependencyTypeList = (DirectiveType<any>|ComponentType<any>|PipeType<any>|Type<any>)[];\n\nexport type TypeOrFactory<T> = T|(() => T);\n\nexport type HostBindingsFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList)|PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => PipeTypeList)|PipeTypeList;\n\nexport type PipeTypeList =\n    (PipeType<any>|Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAubH,iFAAiF;AACjF,0BAA0B;AAC1B,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC","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 {ProcessProvidersFunction} from '../../di/interface/provider';\nimport {EnvironmentInjector} from '../../di/r3_injector';\nimport {Type} from '../../interface/type';\nimport {SchemaMetadata} from '../../metadata/schema';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {FactoryFn} from '../definition_factory';\n\nimport {TAttributes, TConstantsOrFactory} from './node';\nimport {CssSelectorList} from './projection';\nimport {TView} from './view';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  // Note: the ctx parameter is typed as T|U, as using only U would prevent a template with\n  // e.g. ctx: {} from being assigned to ComponentTemplate<any> as TypeScript won't infer U = any\n  // in that scenario. By including T this incompatibility is resolved.\n  <U extends T>(rf: RenderFlags, ctx: T|U): void;\n};\n\n/**\n * Definition of what a view queries function should look like.\n */\nexport type ViewQueriesFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Definition of what a content queries function should look like.\n */\nexport type ContentQueriesFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, directiveIndex: number) => void;\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ɵcmp`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> {\n  ɵcmp: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵdir`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> {\n  ɵdir: unknown;\n  ɵfac: unknown;\n}\n\n/**\n * A subclass of `Type` which has a static `ɵpipe`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> {\n  ɵpipe: unknown;\n}\n\n\n\n/**\n * Runtime link information for Directives.\n *\n * This is an internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: string};\n\n  /**\n   * Function to create and refresh content queries associated with a given directive.\n   */\n  contentQueries: ContentQueriesFunction<T>|null;\n\n  /**\n   * Query-related instructions for a directive. Note that while directives don't have a\n   * view and as such view queries won't necessarily do anything, there might be\n   * components that extend the directive.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * Refreshes host bindings on the associated directive.\n   */\n  readonly hostBindings: HostBindingsFunction<T>|null;\n\n  /**\n   * The number of bindings in this directive `hostBindings` (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly hostVars: number;\n\n  /**\n   * Assign static attribute values to a host element.\n   *\n   * This property will assign static attribute values as well as class and style\n   * values to a host element. Since attribute values can consist of different types of values, the\n   * `hostAttrs` array must include the values in the following format:\n   *\n   * attrs = [\n   *   // static attributes (like `title`, `name`, `id`...)\n   *   attr1, value1, attr2, value,\n   *\n   *   // a single namespace value (like `x:id`)\n   *   NAMESPACE_MARKER, namespaceUri1, name1, value1,\n   *\n   *   // another single namespace value (like `x:name`)\n   *   NAMESPACE_MARKER, namespaceUri2, name2, value2,\n   *\n   *   // a series of CSS classes that will be applied to the element (no spaces)\n   *   CLASSES_MARKER, class1, class2, class3,\n   *\n   *   // a series of CSS styles (property + value) that will be applied to the element\n   *   STYLES_MARKER, prop1, value1, prop2, value2\n   * ]\n   *\n   * All non-class and non-style attributes must be defined at the start of the list\n   * first before all class and style values are set. When there is a change in value\n   * type (like when classes and styles are introduced) a marker must be used to separate\n   * the entries. The marker values themselves are set via entries found in the\n   * [AttributeMarker] enum.\n   */\n  readonly hostAttrs: TAttributes|null;\n\n  /** Token representing the directive. Used by DI. */\n  readonly type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver:\n      (<U extends T>(def: DirectiveDef<U>, processProvidersFn?: ProcessProvidersFunction) =>\n           void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  readonly selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string[]|null;\n\n  /**\n   * Whether this directive (or component) is standalone.\n   */\n  readonly standalone: boolean;\n\n  /**\n   * Factory function used to create a new directive instance. Will be null initially.\n   * Populated when the factory is first requested by directive instantiation logic.\n   */\n  readonly factory: FactoryFn<T>|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n\n  setInput:\n      (<U extends T>(\n           this: DirectiveDef<U>, instance: U, value: any, publicName: string,\n           privateName: string) => void)|null;\n}\n\n/**\n * Runtime link information for Components.\n *\n * This is an internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Runtime unique component ID.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /** Constants associated with the component's view. */\n  readonly consts: TConstantsOrFactory|null;\n\n  /**\n   * An array of `ngContent[selector]` values that were found in the template.\n   */\n  readonly ngContentSelectors?: string[];\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly decls: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {[kind: string]: any};\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * Unfiltered list of all dependencies of a component, or `null` if none.\n   */\n  dependencies: TypeOrFactory<DependencyTypeList>|null;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the component's template.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Ivy runtime uses this place to store the computed tView for the component. This gets filled on\n   * the first run of component.\n   */\n  tView: TView|null;\n\n  /**\n   * A function added by the {@see ɵɵStandaloneFeature} and used by the framework to create standalone injectors.\n   */\n  getStandaloneInjector: ((parentInjector: EnvironmentInjector) => EnvironmentInjector | null)|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: unknown;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is an internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /** Token representing the pipe. */\n  type: Type<T>;\n\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  readonly name: string;\n\n  /**\n   * Factory function used to create a new pipe instance. Will be null initially.\n   * Populated when the factory is first requested by pipe instantiation logic.\n   */\n  factory: FactoryFn<T>|null;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  readonly pure: boolean;\n\n  /**\n   * Whether this pipe is standalone.\n   */\n  readonly standalone: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList)|DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>|ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList)|DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveType<any>|ComponentType<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type DependencyTypeList = (DirectiveType<any>|ComponentType<any>|PipeType<any>|Type<any>)[];\n\nexport type TypeOrFactory<T> = T|(() => T);\n\nexport type HostBindingsFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList)|PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => PipeTypeList)|PipeTypeList;\n\nexport type PipeTypeList =\n    (PipeType<any>|Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}

package/esm2020/src/render3/jit/directive.mjs

@@ -10,9 +10,10 @@ import { resolveForwardRef } from '../../di/forward_ref';
 import { getReflect, reflectDependencies } from '../../di/jit/util';
 import { componentNeedsResolution, maybeQueueResolutionOfComponentResources } from '../../metadata/resource_loading';
 import { ViewEncapsulation } from '../../metadata/view';
+import { flatten } from '../../util/array_utils';
 import { EMPTY_ARRAY, EMPTY_OBJ } from '../../util/empty';
 import { initNgDevMode } from '../../util/ng_dev_mode';
-import { getComponentDef, getDirectiveDef } from '../definition';
+import { getComponentDef, getDirectiveDef, getNgModuleDef, getPipeDef } from '../definition';
 import { NG_COMP_DEF, NG_DIR_DEF, NG_FACTORY_DEF } from '../fields';
 import { stringifyForError } from '../util/stringify_utils';
 import { angularCoreEnv } from './environment';
@@ -98,18 +99,35 @@ export function compileComponent(type, metadata) {
                     preserveWhitespaces,
                     styles: metadata.styles || EMPTY_ARRAY,
                     animations: metadata.animations,
+                    // JIT components are always compiled against an empty set of `declarations`. Instead, the
+                    // `directiveDefs` and `pipeDefs` are updated at a later point:
+                    //  * for NgModule-based components, they're set when the NgModule which declares the
+                    //    component resolves in the module scoping queue
+                    //  * for standalone components, they're set just below, after `compileComponent`.
                     declarations: [],
                     changeDetection: metadata.changeDetection,
                     encapsulation,
                     interpolation: metadata.interpolation,
                     viewProviders: metadata.viewProviders || null,
+                    isStandalone: !!metadata.standalone,
                 };
                 compilationDepth++;
                 try {
                     if (meta.usesInheritance) {
                         addDirectiveDefToUndecoratedParents(type);
                     }
-                    ngComponentDef = compiler.compileComponent(angularCoreEnv, templateUrl, meta);
+                    ngComponentDef =
+                        compiler.compileComponent(angularCoreEnv, templateUrl, meta);
+                    if (metadata.standalone) {
+                        // Patch the component definition for standalone components with `directiveDefs` and
+                        // `pipeDefs` functions which lazily compute the directives/pipes available in the
+                        // standalone component. Also set `dependencies` to the lazily resolved list of imports.
+                        const imports = flatten(metadata.imports || EMPTY_ARRAY);
+                        const { directiveDefs, pipeDefs } = getStandaloneDefFunctions(type, imports);
+                        ngComponentDef.directiveDefs = directiveDefs;
+                        ngComponentDef.pipeDefs = pipeDefs;
+                        ngComponentDef.dependencies = () => imports.map(resolveForwardRef);
+                    }
                 }
                 finally {
                     // Ensure that the compilation depth is decremented even when the compilation failed.
@@ -131,6 +149,17 @@ export function compileComponent(type, metadata) {
                     const scopes = transitiveScopesFor(type.ngSelectorScope);
                     patchComponentDefWithScope(ngComponentDef, scopes);
                 }
+                if (metadata.schemas) {
+                    if (metadata.standalone) {
+                        ngComponentDef.schemas = metadata.schemas;
+                    }
+                    else {
+                        throw new Error(`The 'schemas' was specified for the ${stringifyForError(type)} but is only valid on a component that is standalone.`);
+                    }
+                }
+                else if (metadata.standalone) {
+                    ngComponentDef.schemas = [];
+                }
             }
             return ngComponentDef;
         },
@@ -138,6 +167,65 @@ export function compileComponent(type, metadata) {
         configurable: !!ngDevMode,
     });
 }
+/**
+ * Build memoized `directiveDefs` and `pipeDefs` functions for the component definition of a
+ * standalone component, which process `imports` and filter out directives and pipes. The use of
+ * memoized functions here allows for the delayed resolution of any `forwardRef`s present in the
+ * component's `imports`.
+ */
+function getStandaloneDefFunctions(type, imports) {
+    let cachedDirectiveDefs = null;
+    let cachedPipeDefs = null;
+    const directiveDefs = () => {
+        if (cachedDirectiveDefs === null) {
+            // Standalone components are always able to self-reference, so include the component's own
+            // definition in its `directiveDefs`.
+            cachedDirectiveDefs = [getComponentDef(type)];
+            for (const rawDep of imports) {
+                const dep = resolveForwardRef(rawDep);
+                if (!!getNgModuleDef(dep)) {
+                    const scope = transitiveScopesFor(dep);
+                    for (const dir of scope.exported.directives) {
+                        const def = getComponentDef(dir) || getDirectiveDef(dir);
+                        if (def) {
+                            cachedDirectiveDefs.push(def);
+                        }
+                    }
+                }
+                else {
+                    const def = getComponentDef(dep) || getDirectiveDef(dep);
+                    if (def) {
+                        cachedDirectiveDefs.push(def);
+                    }
+                }
+            }
+        }
+        return cachedDirectiveDefs;
+    };
+    const pipeDefs = () => {
+        if (cachedPipeDefs === null) {
+            cachedPipeDefs = [];
+            for (const rawDep of imports) {
+                const dep = resolveForwardRef(rawDep);
+                if (!!getNgModuleDef(dep)) {
+                    const scope = transitiveScopesFor(dep);
+                    cachedPipeDefs.push(...Array.from(scope.exported.pipes).map(pipe => getPipeDef(pipe)));
+                }
+                else {
+                    const def = getPipeDef(dep);
+                    if (def) {
+                        cachedPipeDefs.push(def);
+                    }
+                }
+            }
+        }
+        return cachedPipeDefs;
+    };
+    return {
+        directiveDefs,
+        pipeDefs,
+    };
+}
 function hasSelectorScope(component) {
     return component.ngSelectorScope !== undefined;
 }
@@ -226,9 +314,7 @@ export function directiveMetadata(type, metadata) {
         exportAs: extractExportAs(metadata.exportAs),
         providers: metadata.providers || null,
         viewQueries: extractQueriesMetadata(type, propMetadata, isViewQuery),
-        // TODO(alxhub): pass through the standalone flag from the directive metadata once standalone
-        // functionality is fully rolled out.
-        isStandalone: false,
+        isStandalone: !!metadata.standalone,
     };
 }
 /**
@@ -324,4 +410,4 @@ function shouldAddAbstractDirective(type) {
     }
     return false;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directive.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/jit/directive.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,iBAAiB,EAA8C,MAAM,gCAAgC,CAAC;AAE9G,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAC,UAAU,EAAE,mBAAmB,EAAC,MAAM,mBAAmB,CAAC;AAIlE,OAAO,EAAC,wBAAwB,EAAE,wCAAwC,EAAC,MAAM,iCAAiC,CAAC;AACnH,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAC,WAAW,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAC,aAAa,EAAC,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAC,eAAe,EAAE,eAAe,EAAC,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAC,WAAW,EAAE,UAAU,EAAE,cAAc,EAAC,MAAM,WAAW,CAAC;AAElE,OAAO,EAAC,iBAAiB,EAAC,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAC,uCAAuC,EAAE,0BAA0B,EAAE,mBAAmB,EAAC,MAAM,UAAU,CAAC;AAElH;;;;;;;;;;;;GAYG;AACH,IAAI,gBAAgB,GAAG,CAAC,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAe,EAAE,QAAmB;IACnE,8EAA8E;IAC9E,0DAA0D;IAC1D,CAAC,OAAO,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,IAAI,aAAa,EAAE,CAAC;IAEnE,IAAI,cAAc,GAAQ,IAAI,CAAC;IAE/B,yDAAyD;IACzD,wCAAwC,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAEzD,iGAAiG;IACjG,uFAAuF;IACvF,2DAA2D;IAC3D,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAEvC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE;QACvC,GAAG,EAAE,GAAG,EAAE;YACR,IAAI,cAAc,KAAK,IAAI,EAAE;gBAC3B,MAAM,QAAQ,GACV,iBAAiB,CAAC,EAAC,KAAK,mBAA4B,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;gBAE1F,IAAI,wBAAwB,CAAC,QAAQ,CAAC,EAAE;oBACtC,MAAM,KAAK,GAAG,CAAC,cAAc,IAAI,CAAC,IAAI,oBAAoB,CAAC,CAAC;oBAC5D,IAAI,QAAQ,CAAC,WAAW,EAAE;wBACxB,KAAK,CAAC,IAAI,CAAC,mBAAmB,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;qBACvD;oBACD,IAAI,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE;wBACnD,KAAK,CAAC,IAAI,CAAC,iBAAiB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;qBACnE;oBACD,KAAK,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;oBACtE,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;iBACnC;gBAED,2FAA2F;gBAC3F,qFAAqF;gBACrF,oFAAoF;gBACpF,2FAA2F;gBAC3F,MAAM,OAAO,GAAG,aAAa,EAAE,CAAC;gBAChC,IAAI,mBAAmB,GAAG,QAAQ,CAAC,mBAAmB,CAAC;gBACvD,IAAI,mBAAmB,KAAK,SAAS,EAAE;oBACrC,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,mBAAmB,KAAK,SAAS,EAAE;wBACjE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;qBACnD;yBAAM;wBACL,mBAAmB,GAAG,KAAK,CAAC;qBAC7B;iBACF;gBACD,IAAI,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC;gBAC3C,IAAI,aAAa,KAAK,SAAS,EAAE;oBAC/B,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,oBAAoB,KAAK,SAAS,EAAE;wBAClE,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC;qBAC9C;yBAAM;wBACL,aAAa,GAAG,iBAAiB,CAAC,QAAQ,CAAC;qBAC5C;iBACF;gBAED,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,IAAI,SAAS,IAAI,CAAC,IAAI,gBAAgB,CAAC;gBAC/E,MAAM,IAAI,GAA8B;oBACtC,GAAG,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC;oBACpC,cAAc,EAAE,QAAQ,CAAC,qBAAqB,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC;oBACnF,QAAQ,EAAE,QAAQ,CAAC,QAAQ,IAAI,EAAE;oBACjC,mBAAmB;oBACnB,MAAM,EAAE,QAAQ,CAAC,MAAM,IAAI,WAAW;oBACtC,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,YAAY,EAAE,EAAE;oBAChB,eAAe,EAAE,QAAQ,CAAC,eAAe;oBACzC,aAAa;oBACb,aAAa,EAAE,QAAQ,CAAC,aAAa;oBACrC,aAAa,EAAE,QAAQ,CAAC,aAAa,IAAI,IAAI;iBAC9C,CAAC;gBAEF,gBAAgB,EAAE,CAAC;gBACnB,IAAI;oBACF,IAAI,IAAI,CAAC,eAAe,EAAE;wBACxB,mCAAmC,CAAC,IAAI,CAAC,CAAC;qBAC3C;oBACD,cAAc,GAAG,QAAQ,CAAC,gBAAgB,CAAC,cAAc,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;iBAC/E;wBAAS;oBACR,qFAAqF;oBACrF,gBAAgB,EAAE,CAAC;iBACpB;gBAED,IAAI,gBAAgB,KAAK,CAAC,EAAE;oBAC1B,gFAAgF;oBAChF,mFAAmF;oBACnF,iFAAiF;oBACjF,+EAA+E;oBAC/E,sBAAsB;oBACtB,uCAAuC,EAAE,CAAC;iBAC3C;gBAED,sFAAsF;gBACtF,wFAAwF;gBACxF,mFAAmF;gBACnF,sBAAsB;gBACtB,IAAI,gBAAgB,CAAC,IAAI,CAAC,EAAE;oBAC1B,MAAM,MAAM,GAAG,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBACzD,0BAA0B,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;iBACpD;aACF;YACD,OAAO,cAAc,CAAC;QACxB,CAAC;QACD,0EAA0E;QAC1E,YAAY,EAAE,CAAC,CAAC,SAAS;KAC1B,CAAC,CAAC;AACL,CAAC;AAED,SAAS,gBAAgB,CAAI,SAAkB;IAE7C,OAAQ,SAAqC,CAAC,eAAe,KAAK,SAAS,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAe,EAAE,SAAyB;IACzE,IAAI,cAAc,GAAQ,IAAI,CAAC;IAE/B,sBAAsB,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IAE9C,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE;QACtC,GAAG,EAAE,GAAG,EAAE;YACR,IAAI,cAAc,KAAK,IAAI,EAAE;gBAC3B,6EAA6E;gBAC7E,mFAAmF;gBACnF,gDAAgD;gBAChD,MAAM,IAAI,GAAG,oBAAoB,CAAC,IAAI,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;gBACzD,MAAM,QAAQ,GACV,iBAAiB,CAAC,EAAC,KAAK,mBAA4B,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAC,CAAC,CAAC;gBACpF,cAAc;oBACV,QAAQ,CAAC,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;aACjF;YACD,OAAO,cAAc,CAAC;QACxB,CAAC;QACD,0EAA0E;QAC1E,YAAY,EAAE,CAAC,CAAC,SAAS;KAC1B,CAAC,CAAC;AACL,CAAC;AAED,SAAS,oBAAoB,CAAC,IAAe,EAAE,QAAmB;IAChE,MAAM,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;IAC/B,MAAM,YAAY,GAAG,SAAS,IAAI,UAAU,CAAC;IAC7C,MAAM,QAAQ,GAAG,iBAAiB,CAAC,EAAC,KAAK,mBAA4B,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAC,CAAC,CAAC;IACjG,MAAM,MAAM,GAAG,iBAAiB,CAAC,IAA0B,EAAE,QAAQ,CAAC,CAAC;IACvE,MAAM,CAAC,cAAc,GAAG,QAAQ,CAAC,qBAAqB,CAAC,WAAW,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;IACxF,IAAI,MAAM,CAAC,eAAe,EAAE;QAC1B,mCAAmC,CAAC,IAAI,CAAC,CAAC;KAC3C;IACD,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAC,CAAC;AAC1C,CAAC;AAED,SAAS,sBAAsB,CAAC,IAAe,EAAE,QAA6B;IAC5E,IAAI,YAAY,GAAQ,IAAI,CAAC;IAE7B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE;QAC1C,GAAG,EAAE,GAAG,EAAE;YACR,IAAI,YAAY,KAAK,IAAI,EAAE;gBACzB,MAAM,IAAI,GAAG,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;gBAClD,MAAM,QAAQ,GACV,iBAAiB,CAAC,EAAC,KAAK,mBAA4B,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAC,CAAC,CAAC;gBACpF,YAAY,GAAG,QAAQ,CAAC,cAAc,CAAC,cAAc,EAAE,SAAS,IAAI,CAAC,IAAI,UAAU,EAAE;oBACnF,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;oBACxB,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;oBACxB,iBAAiB,EAAE,CAAC;oBACpB,IAAI,EAAE,mBAAmB,CAAC,IAAI,CAAC;oBAC/B,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,SAAS;iBACzC,CAAC,CAAC;aACJ;YACD,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,0EAA0E;QAC1E,YAAY,EAAE,CAAC,CAAC,SAAS;KAC1B,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,IAAe;IACvD,OAAO,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,SAAS,CAAC;AACpE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAe,EAAE,QAAmB;IACpE,8BAA8B;IAC9B,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAC7B,MAAM,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAEnD,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,IAAI,EAAE,IAAI;QACV,QAAQ,EAAE,QAAQ,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI;QACpE,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,SAAS;QAChC,YAAY,EAAE,YAAY;QAC1B,MAAM,EAAE,QAAQ,CAAC,MAAM,IAAI,WAAW;QACtC,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,WAAW;QACxC,OAAO,EAAE,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,cAAc,CAAC;QACnE,SAAS,EAAE,EAAC,aAAa,EAAE,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,EAAC;QACzE,cAAc,EAAE,IAAK;QACrB,eAAe,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC;QACjD,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC5C,SAAS,EAAE,QAAQ,CAAC,SAAS,IAAI,IAAI;QACrC,WAAW,EAAE,sBAAsB,CAAC,IAAI,EAAE,YAAY,EAAE,WAAW,CAAC;QACpE,6FAA6F;QAC7F,qCAAqC;QACrC,YAAY,EAAE,KAAK;KACpB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,mCAAmC,CAAC,IAAe;IAC1D,MAAM,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC;IACtC,IAAI,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC;IAE/D,6CAA6C;IAC7C,OAAO,MAAM,IAAI,MAAM,KAAK,YAAY,EAAE;QACxC,kFAAkF;QAClF,+EAA+E;QAC/E,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;YACpD,0BAA0B,CAAC,MAAM,CAAC,EAAE;YACtC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;SAChC;QACD,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;KACxC;AACH,CAAC;AAED,SAAS,yBAAyB,CAAC,QAAa;IAC9C,OAAO,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;AAC7F,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,YAAoB,EAAE,GAAU;IACvE,OAAO;QACL,YAAY,EAAE,YAAY;QAC1B,SAAS,EAAE,yBAAyB,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClD,WAAW,EAAE,GAAG,CAAC,WAAW;QAC5B,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI;QAChC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM;QACpB,uBAAuB,EAAE,CAAC,CAAC,GAAG,CAAC,uBAAuB;KACvD,CAAC;AACJ,CAAC;AACD,SAAS,sBAAsB,CAC3B,IAAe,EAAE,YAAoC,EACrD,UAAsC;IACxC,MAAM,WAAW,GAA4B,EAAE,CAAC;IAChD,KAAK,MAAM,KAAK,IAAI,YAAY,EAAE;QAChC,IAAI,YAAY,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;YACtC,MAAM,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;YACxC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACxB,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE;oBACnB,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE;wBACjB,MAAM,IAAI,KAAK,CACX,6CAA6C,KAAK,OAAO;4BACzD,IAAI,iBAAiB,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;qBAC9E;oBACD,IAAI,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE;wBACvC,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;qBAC3E;oBACD,WAAW,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;iBACxD;YACH,CAAC,CAAC,CAAC;SACJ;KACF;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,SAAS,eAAe,CAAC,QAA0B;IACjD,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED,SAAS,cAAc,CAAC,KAAU;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC;IAClC,OAAO,IAAI,KAAK,cAAc,IAAI,IAAI,KAAK,iBAAiB,CAAC;AAC/D,CAAC;AAED,SAAS,WAAW,CAAC,KAAU;IAC7B,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC;IAClC,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,cAAc,CAAC;AACzD,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAU;IACnC,OAAO,KAAK,CAAC,cAAc,KAAK,OAAO,CAAC;AAC1C,CAAC;AAED,SAAS,YAAY,CAAC,KAAa;IACjC,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,eAAe,GAAG;IACtB,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB;IAC9F,oBAAoB,EAAE,uBAAuB;CAC9C,CAAC;AAEF,SAAS,0BAA0B,CAAC,IAAe;IACjD,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAE7B,IAAI,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE;QAC9E,OAAO,IAAI,CAAC;KACb;IAED,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAEhD,KAAK,MAAM,KAAK,IAAI,YAAY,EAAE;QAChC,MAAM,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAExC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC3C,MAAM,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;YAC/B,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;YAE5C,IAAI,iBAAiB,CAAC,OAAO,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC,IAAI,WAAW,CAAC,OAAO,CAAC;gBAC7E,YAAY,KAAK,QAAQ,IAAI,YAAY,KAAK,aAAa;gBAC3D,YAAY,KAAK,cAAc,EAAE;gBACnC,OAAO,IAAI,CAAC;aACb;SACF;KACF;IAED,OAAO,KAAK,CAAC;AACf,CAAC","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 {getCompilerFacade, JitCompilerUsage, R3DirectiveMetadataFacade} from '../../compiler/compiler_facade';\nimport {R3ComponentMetadataFacade, R3QueryMetadataFacade} from '../../compiler/compiler_facade_interface';\nimport {resolveForwardRef} from '../../di/forward_ref';\nimport {getReflect, reflectDependencies} from '../../di/jit/util';\nimport {Type} from '../../interface/type';\nimport {Query} from '../../metadata/di';\nimport {Component, Directive, Input} from '../../metadata/directives';\nimport {componentNeedsResolution, maybeQueueResolutionOfComponentResources} from '../../metadata/resource_loading';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {EMPTY_ARRAY, EMPTY_OBJ} from '../../util/empty';\nimport {initNgDevMode} from '../../util/ng_dev_mode';\nimport {getComponentDef, getDirectiveDef} from '../definition';\nimport {NG_COMP_DEF, NG_DIR_DEF, NG_FACTORY_DEF} from '../fields';\nimport {ComponentType} from '../interfaces/definition';\nimport {stringifyForError} from '../util/stringify_utils';\n\nimport {angularCoreEnv} from './environment';\nimport {getJitOptions} from './jit_options';\nimport {flushModuleScopingQueueAsMuchAsPossible, patchComponentDefWithScope, transitiveScopesFor} from './module';\n\n/**\n * Keep track of the compilation depth to avoid reentrancy issues during JIT compilation. This\n * matters in the following scenario:\n *\n * Consider a component 'A' that extends component 'B', both declared in module 'M'. During\n * the compilation of 'A' the definition of 'B' is requested to capture the inheritance chain,\n * potentially triggering compilation of 'B'. If this nested compilation were to trigger\n * `flushModuleScopingQueueAsMuchAsPossible` it may happen that module 'M' is still pending in the\n * queue, resulting in 'A' and 'B' to be patched with the NgModule scope. As the compilation of\n * 'A' is still in progress, this would introduce a circular dependency on its compilation. To avoid\n * this issue, the module scope queue is only flushed for compilations at the depth 0, to ensure\n * all compilations have finished.\n */\nlet compilationDepth = 0;\n\n/**\n * Compile an Angular component according to its decorator metadata, and patch the resulting\n * component def (ɵcmp) onto the component type.\n *\n * Compilation may be asynchronous (due to the need to resolve URLs for the component template or\n * other resources, for example). In the event that compilation is not immediate, `compileComponent`\n * will enqueue resource resolution into a global queue and will fail to return the `ɵcmp`\n * until the global queue has been resolved with a call to `resolveComponentResources`.\n */\nexport function compileComponent(type: Type<any>, metadata: Component): void {\n  // Initialize ngDevMode. This must be the first statement in compileComponent.\n  // See the `initNgDevMode` docstring for more information.\n  (typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode();\n\n  let ngComponentDef: any = null;\n\n  // Metadata may have resources which need to be resolved.\n  maybeQueueResolutionOfComponentResources(type, metadata);\n\n  // Note that we're using the same function as `Directive`, because that's only subset of metadata\n  // that we need to create the ngFactoryDef. We're avoiding using the component metadata\n  // because we'd have to resolve the asynchronous templates.\n  addDirectiveFactoryDef(type, metadata);\n\n  Object.defineProperty(type, NG_COMP_DEF, {\n    get: () => {\n      if (ngComponentDef === null) {\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'component', type: type});\n\n        if (componentNeedsResolution(metadata)) {\n          const error = [`Component '${type.name}' is not resolved:`];\n          if (metadata.templateUrl) {\n            error.push(` - templateUrl: ${metadata.templateUrl}`);\n          }\n          if (metadata.styleUrls && metadata.styleUrls.length) {\n            error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);\n          }\n          error.push(`Did you run and wait for 'resolveComponentResources()'?`);\n          throw new Error(error.join('\\n'));\n        }\n\n        // This const was called `jitOptions` previously but had to be renamed to `options` because\n        // of a bug with Terser that caused optimized JIT builds to throw a `ReferenceError`.\n        // This bug was investigated in https://github.com/angular/angular-cli/issues/17264.\n        // We should not rename it back until https://github.com/terser/terser/issues/615 is fixed.\n        const options = getJitOptions();\n        let preserveWhitespaces = metadata.preserveWhitespaces;\n        if (preserveWhitespaces === undefined) {\n          if (options !== null && options.preserveWhitespaces !== undefined) {\n            preserveWhitespaces = options.preserveWhitespaces;\n          } else {\n            preserveWhitespaces = false;\n          }\n        }\n        let encapsulation = metadata.encapsulation;\n        if (encapsulation === undefined) {\n          if (options !== null && options.defaultEncapsulation !== undefined) {\n            encapsulation = options.defaultEncapsulation;\n          } else {\n            encapsulation = ViewEncapsulation.Emulated;\n          }\n        }\n\n        const templateUrl = metadata.templateUrl || `ng:///${type.name}/template.html`;\n        const meta: R3ComponentMetadataFacade = {\n          ...directiveMetadata(type, metadata),\n          typeSourceSpan: compiler.createParseSourceSpan('Component', type.name, templateUrl),\n          template: metadata.template || '',\n          preserveWhitespaces,\n          styles: metadata.styles || EMPTY_ARRAY,\n          animations: metadata.animations,\n          declarations: [],\n          changeDetection: metadata.changeDetection,\n          encapsulation,\n          interpolation: metadata.interpolation,\n          viewProviders: metadata.viewProviders || null,\n        };\n\n        compilationDepth++;\n        try {\n          if (meta.usesInheritance) {\n            addDirectiveDefToUndecoratedParents(type);\n          }\n          ngComponentDef = compiler.compileComponent(angularCoreEnv, templateUrl, meta);\n        } finally {\n          // Ensure that the compilation depth is decremented even when the compilation failed.\n          compilationDepth--;\n        }\n\n        if (compilationDepth === 0) {\n          // When NgModule decorator executed, we enqueued the module definition such that\n          // it would only dequeue and add itself as module scope to all of its declarations,\n          // but only if  if all of its declarations had resolved. This call runs the check\n          // to see if any modules that are in the queue can be dequeued and add scope to\n          // their declarations.\n          flushModuleScopingQueueAsMuchAsPossible();\n        }\n\n        // If component compilation is async, then the @NgModule annotation which declares the\n        // component may execute and set an ngSelectorScope property on the component type. This\n        // allows the component to patch itself with directiveDefs from the module after it\n        // finishes compiling.\n        if (hasSelectorScope(type)) {\n          const scopes = transitiveScopesFor(type.ngSelectorScope);\n          patchComponentDefWithScope(ngComponentDef, scopes);\n        }\n      }\n      return ngComponentDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nfunction hasSelectorScope<T>(component: Type<T>): component is Type<T>&\n    {ngSelectorScope: Type<any>} {\n  return (component as {ngSelectorScope?: any}).ngSelectorScope !== undefined;\n}\n\n/**\n * Compile an Angular directive according to its decorator metadata, and patch the resulting\n * directive def onto the component type.\n *\n * In the event that compilation is not immediate, `compileDirective` will return a `Promise` which\n * will resolve when compilation completes and the directive becomes usable.\n */\nexport function compileDirective(type: Type<any>, directive: Directive|null): void {\n  let ngDirectiveDef: any = null;\n\n  addDirectiveFactoryDef(type, directive || {});\n\n  Object.defineProperty(type, NG_DIR_DEF, {\n    get: () => {\n      if (ngDirectiveDef === null) {\n        // `directive` can be null in the case of abstract directives as a base class\n        // that use `@Directive()` with no selector. In that case, pass empty object to the\n        // `directiveMetadata` function instead of null.\n        const meta = getDirectiveMetadata(type, directive || {});\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n        ngDirectiveDef =\n            compiler.compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);\n      }\n      return ngDirectiveDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nfunction getDirectiveMetadata(type: Type<any>, metadata: Directive) {\n  const name = type && type.name;\n  const sourceMapUrl = `ng:///${name}/ɵdir.js`;\n  const compiler = getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n  const facade = directiveMetadata(type as ComponentType<any>, metadata);\n  facade.typeSourceSpan = compiler.createParseSourceSpan('Directive', name, sourceMapUrl);\n  if (facade.usesInheritance) {\n    addDirectiveDefToUndecoratedParents(type);\n  }\n  return {metadata: facade, sourceMapUrl};\n}\n\nfunction addDirectiveFactoryDef(type: Type<any>, metadata: Directive|Component) {\n  let ngFactoryDef: any = null;\n\n  Object.defineProperty(type, NG_FACTORY_DEF, {\n    get: () => {\n      if (ngFactoryDef === null) {\n        const meta = getDirectiveMetadata(type, metadata);\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n        ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${type.name}/ɵfac.js`, {\n          name: meta.metadata.name,\n          type: meta.metadata.type,\n          typeArgumentCount: 0,\n          deps: reflectDependencies(type),\n          target: compiler.FactoryTarget.Directive\n        });\n      }\n      return ngFactoryDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nexport function extendsDirectlyFromObject(type: Type<any>): boolean {\n  return Object.getPrototypeOf(type.prototype) === Object.prototype;\n}\n\n/**\n * Extract the `R3DirectiveMetadata` for a particular directive (either a `Directive` or a\n * `Component`).\n */\nexport function directiveMetadata(type: Type<any>, metadata: Directive): R3DirectiveMetadataFacade {\n  // Reflect inputs and outputs.\n  const reflect = getReflect();\n  const propMetadata = reflect.ownPropMetadata(type);\n\n  return {\n    name: type.name,\n    type: type,\n    selector: metadata.selector !== undefined ? metadata.selector : null,\n    host: metadata.host || EMPTY_OBJ,\n    propMetadata: propMetadata,\n    inputs: metadata.inputs || EMPTY_ARRAY,\n    outputs: metadata.outputs || EMPTY_ARRAY,\n    queries: extractQueriesMetadata(type, propMetadata, isContentQuery),\n    lifecycle: {usesOnChanges: reflect.hasLifecycleHook(type, 'ngOnChanges')},\n    typeSourceSpan: null!,\n    usesInheritance: !extendsDirectlyFromObject(type),\n    exportAs: extractExportAs(metadata.exportAs),\n    providers: metadata.providers || null,\n    viewQueries: extractQueriesMetadata(type, propMetadata, isViewQuery),\n    // TODO(alxhub): pass through the standalone flag from the directive metadata once standalone\n    // functionality is fully rolled out.\n    isStandalone: false,\n  };\n}\n\n/**\n * Adds a directive definition to all parent classes of a type that don't have an Angular decorator.\n */\nfunction addDirectiveDefToUndecoratedParents(type: Type<any>) {\n  const objPrototype = Object.prototype;\n  let parent = Object.getPrototypeOf(type.prototype).constructor;\n\n  // Go up the prototype until we hit `Object`.\n  while (parent && parent !== objPrototype) {\n    // Since inheritance works if the class was annotated already, we only need to add\n    // the def if there are no annotations and the def hasn't been created already.\n    if (!getDirectiveDef(parent) && !getComponentDef(parent) &&\n        shouldAddAbstractDirective(parent)) {\n      compileDirective(parent, null);\n    }\n    parent = Object.getPrototypeOf(parent);\n  }\n}\n\nfunction convertToR3QueryPredicate(selector: any): any|string[] {\n  return typeof selector === 'string' ? splitByComma(selector) : resolveForwardRef(selector);\n}\n\nexport function convertToR3QueryMetadata(propertyName: string, ann: Query): R3QueryMetadataFacade {\n  return {\n    propertyName: propertyName,\n    predicate: convertToR3QueryPredicate(ann.selector),\n    descendants: ann.descendants,\n    first: ann.first,\n    read: ann.read ? ann.read : null,\n    static: !!ann.static,\n    emitDistinctChangesOnly: !!ann.emitDistinctChangesOnly,\n  };\n}\nfunction extractQueriesMetadata(\n    type: Type<any>, propMetadata: {[key: string]: any[]},\n    isQueryAnn: (ann: any) => ann is Query): R3QueryMetadataFacade[] {\n  const queriesMeta: R3QueryMetadataFacade[] = [];\n  for (const field in propMetadata) {\n    if (propMetadata.hasOwnProperty(field)) {\n      const annotations = propMetadata[field];\n      annotations.forEach(ann => {\n        if (isQueryAnn(ann)) {\n          if (!ann.selector) {\n            throw new Error(\n                `Can't construct a query for the property \"${field}\" of ` +\n                `\"${stringifyForError(type)}\" since the query selector wasn't defined.`);\n          }\n          if (annotations.some(isInputAnnotation)) {\n            throw new Error(`Cannot combine @Input decorators with query decorators`);\n          }\n          queriesMeta.push(convertToR3QueryMetadata(field, ann));\n        }\n      });\n    }\n  }\n  return queriesMeta;\n}\n\nfunction extractExportAs(exportAs: string|undefined): string[]|null {\n  return exportAs === undefined ? null : splitByComma(exportAs);\n}\n\nfunction isContentQuery(value: any): value is Query {\n  const name = value.ngMetadataName;\n  return name === 'ContentChild' || name === 'ContentChildren';\n}\n\nfunction isViewQuery(value: any): value is Query {\n  const name = value.ngMetadataName;\n  return name === 'ViewChild' || name === 'ViewChildren';\n}\n\nfunction isInputAnnotation(value: any): value is Input {\n  return value.ngMetadataName === 'Input';\n}\n\nfunction splitByComma(value: string): string[] {\n  return value.split(',').map(piece => piece.trim());\n}\n\nconst LIFECYCLE_HOOKS = [\n  'ngOnChanges', 'ngOnInit', 'ngOnDestroy', 'ngDoCheck', 'ngAfterViewInit', 'ngAfterViewChecked',\n  'ngAfterContentInit', 'ngAfterContentChecked'\n];\n\nfunction shouldAddAbstractDirective(type: Type<any>): boolean {\n  const reflect = getReflect();\n\n  if (LIFECYCLE_HOOKS.some(hookName => reflect.hasLifecycleHook(type, hookName))) {\n    return true;\n  }\n\n  const propMetadata = reflect.propMetadata(type);\n\n  for (const field in propMetadata) {\n    const annotations = propMetadata[field];\n\n    for (let i = 0; i < annotations.length; i++) {\n      const current = annotations[i];\n      const metadataName = current.ngMetadataName;\n\n      if (isInputAnnotation(current) || isContentQuery(current) || isViewQuery(current) ||\n          metadataName === 'Output' || metadataName === 'HostBinding' ||\n          metadataName === 'HostListener') {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directive.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/jit/directive.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 {getCompilerFacade, JitCompilerUsage, R3DirectiveMetadataFacade} from '../../compiler/compiler_facade';\nimport {R3ComponentMetadataFacade, R3QueryMetadataFacade} from '../../compiler/compiler_facade_interface';\nimport {resolveForwardRef} from '../../di/forward_ref';\nimport {getReflect, reflectDependencies} from '../../di/jit/util';\nimport {Type} from '../../interface/type';\nimport {Query} from '../../metadata/di';\nimport {Component, Directive, Input} from '../../metadata/directives';\nimport {componentNeedsResolution, maybeQueueResolutionOfComponentResources} from '../../metadata/resource_loading';\nimport {ViewEncapsulation} from '../../metadata/view';\nimport {flatten} from '../../util/array_utils';\nimport {EMPTY_ARRAY, EMPTY_OBJ} from '../../util/empty';\nimport {initNgDevMode} from '../../util/ng_dev_mode';\nimport {getComponentDef, getDirectiveDef, getNgModuleDef, getPipeDef} from '../definition';\nimport {NG_COMP_DEF, NG_DIR_DEF, NG_FACTORY_DEF} from '../fields';\nimport {ComponentDef, ComponentType, DirectiveDefList, PipeDefList} from '../interfaces/definition';\nimport {stringifyForError} from '../util/stringify_utils';\n\nimport {angularCoreEnv} from './environment';\nimport {getJitOptions} from './jit_options';\nimport {flushModuleScopingQueueAsMuchAsPossible, patchComponentDefWithScope, transitiveScopesFor} from './module';\n\n/**\n * Keep track of the compilation depth to avoid reentrancy issues during JIT compilation. This\n * matters in the following scenario:\n *\n * Consider a component 'A' that extends component 'B', both declared in module 'M'. During\n * the compilation of 'A' the definition of 'B' is requested to capture the inheritance chain,\n * potentially triggering compilation of 'B'. If this nested compilation were to trigger\n * `flushModuleScopingQueueAsMuchAsPossible` it may happen that module 'M' is still pending in the\n * queue, resulting in 'A' and 'B' to be patched with the NgModule scope. As the compilation of\n * 'A' is still in progress, this would introduce a circular dependency on its compilation. To avoid\n * this issue, the module scope queue is only flushed for compilations at the depth 0, to ensure\n * all compilations have finished.\n */\nlet compilationDepth = 0;\n\n/**\n * Compile an Angular component according to its decorator metadata, and patch the resulting\n * component def (ɵcmp) onto the component type.\n *\n * Compilation may be asynchronous (due to the need to resolve URLs for the component template or\n * other resources, for example). In the event that compilation is not immediate, `compileComponent`\n * will enqueue resource resolution into a global queue and will fail to return the `ɵcmp`\n * until the global queue has been resolved with a call to `resolveComponentResources`.\n */\nexport function compileComponent(type: Type<any>, metadata: Component): void {\n  // Initialize ngDevMode. This must be the first statement in compileComponent.\n  // See the `initNgDevMode` docstring for more information.\n  (typeof ngDevMode === 'undefined' || ngDevMode) && initNgDevMode();\n\n  let ngComponentDef: ComponentDef<unknown>|null = null;\n\n  // Metadata may have resources which need to be resolved.\n  maybeQueueResolutionOfComponentResources(type, metadata);\n\n  // Note that we're using the same function as `Directive`, because that's only subset of metadata\n  // that we need to create the ngFactoryDef. We're avoiding using the component metadata\n  // because we'd have to resolve the asynchronous templates.\n  addDirectiveFactoryDef(type, metadata);\n\n  Object.defineProperty(type, NG_COMP_DEF, {\n    get: () => {\n      if (ngComponentDef === null) {\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'component', type: type});\n\n        if (componentNeedsResolution(metadata)) {\n          const error = [`Component '${type.name}' is not resolved:`];\n          if (metadata.templateUrl) {\n            error.push(` - templateUrl: ${metadata.templateUrl}`);\n          }\n          if (metadata.styleUrls && metadata.styleUrls.length) {\n            error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);\n          }\n          error.push(`Did you run and wait for 'resolveComponentResources()'?`);\n          throw new Error(error.join('\\n'));\n        }\n\n        // This const was called `jitOptions` previously but had to be renamed to `options` because\n        // of a bug with Terser that caused optimized JIT builds to throw a `ReferenceError`.\n        // This bug was investigated in https://github.com/angular/angular-cli/issues/17264.\n        // We should not rename it back until https://github.com/terser/terser/issues/615 is fixed.\n        const options = getJitOptions();\n        let preserveWhitespaces = metadata.preserveWhitespaces;\n        if (preserveWhitespaces === undefined) {\n          if (options !== null && options.preserveWhitespaces !== undefined) {\n            preserveWhitespaces = options.preserveWhitespaces;\n          } else {\n            preserveWhitespaces = false;\n          }\n        }\n        let encapsulation = metadata.encapsulation;\n        if (encapsulation === undefined) {\n          if (options !== null && options.defaultEncapsulation !== undefined) {\n            encapsulation = options.defaultEncapsulation;\n          } else {\n            encapsulation = ViewEncapsulation.Emulated;\n          }\n        }\n\n        const templateUrl = metadata.templateUrl || `ng:///${type.name}/template.html`;\n        const meta: R3ComponentMetadataFacade = {\n          ...directiveMetadata(type, metadata),\n          typeSourceSpan: compiler.createParseSourceSpan('Component', type.name, templateUrl),\n          template: metadata.template || '',\n          preserveWhitespaces,\n          styles: metadata.styles || EMPTY_ARRAY,\n          animations: metadata.animations,\n          // JIT components are always compiled against an empty set of `declarations`. Instead, the\n          // `directiveDefs` and `pipeDefs` are updated at a later point:\n          //  * for NgModule-based components, they're set when the NgModule which declares the\n          //    component resolves in the module scoping queue\n          //  * for standalone components, they're set just below, after `compileComponent`.\n          declarations: [],\n          changeDetection: metadata.changeDetection,\n          encapsulation,\n          interpolation: metadata.interpolation,\n          viewProviders: metadata.viewProviders || null,\n          isStandalone: !!metadata.standalone,\n        };\n\n        compilationDepth++;\n        try {\n          if (meta.usesInheritance) {\n            addDirectiveDefToUndecoratedParents(type);\n          }\n          ngComponentDef =\n              compiler.compileComponent(angularCoreEnv, templateUrl, meta) as ComponentDef<unknown>;\n\n          if (metadata.standalone) {\n            // Patch the component definition for standalone components with `directiveDefs` and\n            // `pipeDefs` functions which lazily compute the directives/pipes available in the\n            // standalone component. Also set `dependencies` to the lazily resolved list of imports.\n            const imports: Type<any>[] = flatten(metadata.imports || EMPTY_ARRAY);\n            const {directiveDefs, pipeDefs} = getStandaloneDefFunctions(type, imports);\n            ngComponentDef.directiveDefs = directiveDefs;\n            ngComponentDef.pipeDefs = pipeDefs;\n            ngComponentDef.dependencies = () => imports.map(resolveForwardRef);\n          }\n        } finally {\n          // Ensure that the compilation depth is decremented even when the compilation failed.\n          compilationDepth--;\n        }\n\n        if (compilationDepth === 0) {\n          // When NgModule decorator executed, we enqueued the module definition such that\n          // it would only dequeue and add itself as module scope to all of its declarations,\n          // but only if  if all of its declarations had resolved. This call runs the check\n          // to see if any modules that are in the queue can be dequeued and add scope to\n          // their declarations.\n          flushModuleScopingQueueAsMuchAsPossible();\n        }\n\n        // If component compilation is async, then the @NgModule annotation which declares the\n        // component may execute and set an ngSelectorScope property on the component type. This\n        // allows the component to patch itself with directiveDefs from the module after it\n        // finishes compiling.\n        if (hasSelectorScope(type)) {\n          const scopes = transitiveScopesFor(type.ngSelectorScope);\n          patchComponentDefWithScope(ngComponentDef, scopes);\n        }\n\n        if (metadata.schemas) {\n          if (metadata.standalone) {\n            ngComponentDef.schemas = metadata.schemas;\n          } else {\n            throw new Error(`The 'schemas' was specified for the ${\n                stringifyForError(type)} but is only valid on a component that is standalone.`);\n          }\n        } else if (metadata.standalone) {\n          ngComponentDef.schemas = [];\n        }\n      }\n      return ngComponentDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\n/**\n * Build memoized `directiveDefs` and `pipeDefs` functions for the component definition of a\n * standalone component, which process `imports` and filter out directives and pipes. The use of\n * memoized functions here allows for the delayed resolution of any `forwardRef`s present in the\n * component's `imports`.\n */\nfunction getStandaloneDefFunctions(type: Type<any>, imports: Type<any>[]): {\n  directiveDefs: () => DirectiveDefList,\n  pipeDefs: () => PipeDefList,\n} {\n  let cachedDirectiveDefs: DirectiveDefList|null = null;\n  let cachedPipeDefs: PipeDefList|null = null;\n  const directiveDefs = () => {\n    if (cachedDirectiveDefs === null) {\n      // Standalone components are always able to self-reference, so include the component's own\n      // definition in its `directiveDefs`.\n      cachedDirectiveDefs = [getComponentDef(type)!];\n\n      for (const rawDep of imports) {\n        const dep = resolveForwardRef(rawDep);\n\n        if (!!getNgModuleDef(dep)) {\n          const scope = transitiveScopesFor(dep);\n          for (const dir of scope.exported.directives) {\n            const def = getComponentDef(dir) || getDirectiveDef(dir);\n            if (def) {\n              cachedDirectiveDefs.push(def);\n            }\n          }\n        } else {\n          const def = getComponentDef(dep) || getDirectiveDef(dep);\n          if (def) {\n            cachedDirectiveDefs.push(def);\n          }\n        }\n      }\n    }\n    return cachedDirectiveDefs;\n  };\n\n  const pipeDefs = () => {\n    if (cachedPipeDefs === null) {\n      cachedPipeDefs = [];\n      for (const rawDep of imports) {\n        const dep = resolveForwardRef(rawDep);\n\n        if (!!getNgModuleDef(dep)) {\n          const scope = transitiveScopesFor(dep);\n          cachedPipeDefs.push(...Array.from(scope.exported.pipes).map(pipe => getPipeDef(pipe)!));\n        } else {\n          const def = getPipeDef(dep);\n          if (def) {\n            cachedPipeDefs.push(def);\n          }\n        }\n      }\n    }\n    return cachedPipeDefs;\n  };\n\n  return {\n    directiveDefs,\n    pipeDefs,\n  };\n}\n\nfunction hasSelectorScope<T>(component: Type<T>): component is Type<T>&\n    {ngSelectorScope: Type<any>} {\n  return (component as {ngSelectorScope?: any}).ngSelectorScope !== undefined;\n}\n\n/**\n * Compile an Angular directive according to its decorator metadata, and patch the resulting\n * directive def onto the component type.\n *\n * In the event that compilation is not immediate, `compileDirective` will return a `Promise` which\n * will resolve when compilation completes and the directive becomes usable.\n */\nexport function compileDirective(type: Type<any>, directive: Directive|null): void {\n  let ngDirectiveDef: any = null;\n\n  addDirectiveFactoryDef(type, directive || {});\n\n  Object.defineProperty(type, NG_DIR_DEF, {\n    get: () => {\n      if (ngDirectiveDef === null) {\n        // `directive` can be null in the case of abstract directives as a base class\n        // that use `@Directive()` with no selector. In that case, pass empty object to the\n        // `directiveMetadata` function instead of null.\n        const meta = getDirectiveMetadata(type, directive || {});\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n        ngDirectiveDef =\n            compiler.compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);\n      }\n      return ngDirectiveDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nfunction getDirectiveMetadata(type: Type<any>, metadata: Directive) {\n  const name = type && type.name;\n  const sourceMapUrl = `ng:///${name}/ɵdir.js`;\n  const compiler = getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n  const facade = directiveMetadata(type as ComponentType<any>, metadata);\n  facade.typeSourceSpan = compiler.createParseSourceSpan('Directive', name, sourceMapUrl);\n  if (facade.usesInheritance) {\n    addDirectiveDefToUndecoratedParents(type);\n  }\n  return {metadata: facade, sourceMapUrl};\n}\n\nfunction addDirectiveFactoryDef(type: Type<any>, metadata: Directive|Component) {\n  let ngFactoryDef: any = null;\n\n  Object.defineProperty(type, NG_FACTORY_DEF, {\n    get: () => {\n      if (ngFactoryDef === null) {\n        const meta = getDirectiveMetadata(type, metadata);\n        const compiler =\n            getCompilerFacade({usage: JitCompilerUsage.Decorator, kind: 'directive', type});\n        ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${type.name}/ɵfac.js`, {\n          name: meta.metadata.name,\n          type: meta.metadata.type,\n          typeArgumentCount: 0,\n          deps: reflectDependencies(type),\n          target: compiler.FactoryTarget.Directive\n        });\n      }\n      return ngFactoryDef;\n    },\n    // Make the property configurable in dev mode to allow overriding in tests\n    configurable: !!ngDevMode,\n  });\n}\n\nexport function extendsDirectlyFromObject(type: Type<any>): boolean {\n  return Object.getPrototypeOf(type.prototype) === Object.prototype;\n}\n\n/**\n * Extract the `R3DirectiveMetadata` for a particular directive (either a `Directive` or a\n * `Component`).\n */\nexport function directiveMetadata(type: Type<any>, metadata: Directive): R3DirectiveMetadataFacade {\n  // Reflect inputs and outputs.\n  const reflect = getReflect();\n  const propMetadata = reflect.ownPropMetadata(type);\n\n  return {\n    name: type.name,\n    type: type,\n    selector: metadata.selector !== undefined ? metadata.selector : null,\n    host: metadata.host || EMPTY_OBJ,\n    propMetadata: propMetadata,\n    inputs: metadata.inputs || EMPTY_ARRAY,\n    outputs: metadata.outputs || EMPTY_ARRAY,\n    queries: extractQueriesMetadata(type, propMetadata, isContentQuery),\n    lifecycle: {usesOnChanges: reflect.hasLifecycleHook(type, 'ngOnChanges')},\n    typeSourceSpan: null!,\n    usesInheritance: !extendsDirectlyFromObject(type),\n    exportAs: extractExportAs(metadata.exportAs),\n    providers: metadata.providers || null,\n    viewQueries: extractQueriesMetadata(type, propMetadata, isViewQuery),\n    isStandalone: !!metadata.standalone,\n  };\n}\n\n/**\n * Adds a directive definition to all parent classes of a type that don't have an Angular decorator.\n */\nfunction addDirectiveDefToUndecoratedParents(type: Type<any>) {\n  const objPrototype = Object.prototype;\n  let parent = Object.getPrototypeOf(type.prototype).constructor;\n\n  // Go up the prototype until we hit `Object`.\n  while (parent && parent !== objPrototype) {\n    // Since inheritance works if the class was annotated already, we only need to add\n    // the def if there are no annotations and the def hasn't been created already.\n    if (!getDirectiveDef(parent) && !getComponentDef(parent) &&\n        shouldAddAbstractDirective(parent)) {\n      compileDirective(parent, null);\n    }\n    parent = Object.getPrototypeOf(parent);\n  }\n}\n\nfunction convertToR3QueryPredicate(selector: any): any|string[] {\n  return typeof selector === 'string' ? splitByComma(selector) : resolveForwardRef(selector);\n}\n\nexport function convertToR3QueryMetadata(propertyName: string, ann: Query): R3QueryMetadataFacade {\n  return {\n    propertyName: propertyName,\n    predicate: convertToR3QueryPredicate(ann.selector),\n    descendants: ann.descendants,\n    first: ann.first,\n    read: ann.read ? ann.read : null,\n    static: !!ann.static,\n    emitDistinctChangesOnly: !!ann.emitDistinctChangesOnly,\n  };\n}\nfunction extractQueriesMetadata(\n    type: Type<any>, propMetadata: {[key: string]: any[]},\n    isQueryAnn: (ann: any) => ann is Query): R3QueryMetadataFacade[] {\n  const queriesMeta: R3QueryMetadataFacade[] = [];\n  for (const field in propMetadata) {\n    if (propMetadata.hasOwnProperty(field)) {\n      const annotations = propMetadata[field];\n      annotations.forEach(ann => {\n        if (isQueryAnn(ann)) {\n          if (!ann.selector) {\n            throw new Error(\n                `Can't construct a query for the property \"${field}\" of ` +\n                `\"${stringifyForError(type)}\" since the query selector wasn't defined.`);\n          }\n          if (annotations.some(isInputAnnotation)) {\n            throw new Error(`Cannot combine @Input decorators with query decorators`);\n          }\n          queriesMeta.push(convertToR3QueryMetadata(field, ann));\n        }\n      });\n    }\n  }\n  return queriesMeta;\n}\n\nfunction extractExportAs(exportAs: string|undefined): string[]|null {\n  return exportAs === undefined ? null : splitByComma(exportAs);\n}\n\nfunction isContentQuery(value: any): value is Query {\n  const name = value.ngMetadataName;\n  return name === 'ContentChild' || name === 'ContentChildren';\n}\n\nfunction isViewQuery(value: any): value is Query {\n  const name = value.ngMetadataName;\n  return name === 'ViewChild' || name === 'ViewChildren';\n}\n\nfunction isInputAnnotation(value: any): value is Input {\n  return value.ngMetadataName === 'Input';\n}\n\nfunction splitByComma(value: string): string[] {\n  return value.split(',').map(piece => piece.trim());\n}\n\nconst LIFECYCLE_HOOKS = [\n  'ngOnChanges', 'ngOnInit', 'ngOnDestroy', 'ngDoCheck', 'ngAfterViewInit', 'ngAfterViewChecked',\n  'ngAfterContentInit', 'ngAfterContentChecked'\n];\n\nfunction shouldAddAbstractDirective(type: Type<any>): boolean {\n  const reflect = getReflect();\n\n  if (LIFECYCLE_HOOKS.some(hookName => reflect.hasLifecycleHook(type, hookName))) {\n    return true;\n  }\n\n  const propMetadata = reflect.propMetadata(type);\n\n  for (const field in propMetadata) {\n    const annotations = propMetadata[field];\n\n    for (let i = 0; i < annotations.length; i++) {\n      const current = annotations[i];\n      const metadataName = current.ngMetadataName;\n\n      if (isInputAnnotation(current) || isContentQuery(current) || isViewQuery(current) ||\n          metadataName === 'Output' || metadataName === 'HostBinding' ||\n          metadataName === 'HostListener') {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n"]}