@angular/core 7.1.3 → 7.1.4

package/esm2015/src/render3/interfaces/definition.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
+ * @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
  */
 /**
  * @license
@@ -9,14 +9,8 @@
  * 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
  */
-/** @typedef {?} */
-var ComponentTemplate;
-export { ComponentTemplate };
-/** @typedef {?} */
-var ComponentQuery;
-export { ComponentQuery };
 /** @enum {number} */
-var RenderFlags = {
+const RenderFlags = {
     /* Whether to run the creation block (e.g. create elements and directives) */
     Create: 1,
     /* Whether to run the update block (e.g. refresh bindings) */
@@ -30,8 +24,10 @@ export { RenderFlags };
  * @template T
  */
 export function ComponentType() { }
-/** @type {?} */
-ComponentType.prototype.ngComponentDef;
+if (false) {
+    /** @type {?} */
+    ComponentType.prototype.ngComponentDef;
+}
 /**
  * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it
  * consumable for rendering.
@@ -39,10 +35,12 @@ ComponentType.prototype.ngComponentDef;
  * @template T
  */
 export function DirectiveType() { }
-/** @type {?} */
-DirectiveType.prototype.ngDirectiveDef;
+if (false) {
+    /** @type {?} */
+    DirectiveType.prototype.ngDirectiveDef;
+}
 /** @enum {number} */
-var DirectiveDefFlags = {
+const DirectiveDefFlags = {
     ContentQuery: 2,
 };
 export { DirectiveDefFlags };
@@ -53,11 +51,10 @@ export { DirectiveDefFlags };
  * @template T
  */
 export function PipeType() { }
-/** @type {?} */
-PipeType.prototype.ngPipeDef;
-/** @typedef {?} */
-var DirectiveDefWithMeta;
-export { DirectiveDefWithMeta };
+if (false) {
+    /** @type {?} */
+    PipeType.prototype.ngPipeDef;
+}
 /**
  * Runtime information for classes that are inherited by components or directives
  * that aren't defined as components or directives.
@@ -70,26 +67,28 @@ export { DirectiveDefWithMeta };
  * @template T
  */
 export function BaseDef() { }
-/**
- * A dictionary mapping the inputs' minified property names to their public API names, which
- * are their aliases if any, or their original unminified property names
- * (as in `\@Input('alias') propertyName: any;`).
- * @type {?}
- */
-BaseDef.prototype.inputs;
-/**
- * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
- * public or minified name.
- * @type {?}
- */
-BaseDef.prototype.declaredInputs;
-/**
- * A dictionary mapping the outputs' minified property names to their public API names, which
- * are their aliases if any, or their original unminified property names
- * (as in `\@Output('alias') propertyName: any;`).
- * @type {?}
- */
-BaseDef.prototype.outputs;
+if (false) {
+    /**
+     * A dictionary mapping the inputs' minified property names to their public API names, which
+     * are their aliases if any, or their original unminified property names
+     * (as in `\@Input('alias') propertyName: any;`).
+     * @type {?}
+     */
+    BaseDef.prototype.inputs;
+    /**
+     * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
+     * public or minified name.
+     * @type {?}
+     */
+    BaseDef.prototype.declaredInputs;
+    /**
+     * A dictionary mapping the outputs' minified property names to their public API names, which
+     * are their aliases if any, or their original unminified property names
+     * (as in `\@Output('alias') propertyName: any;`).
+     * @type {?}
+     */
+    BaseDef.prototype.outputs;
+}
 /**
  * Runtime link information for Directives.
  *
@@ -107,84 +106,83 @@ BaseDef.prototype.outputs;
  * @template T
  */
 export function DirectiveDef() { }
-/**
- * Token representing the directive. Used by DI.
- * @type {?}
- */
-DirectiveDef.prototype.type;
-/**
- * Function that resolves providers and publishes them into the DI system.
- * @type {?}
- */
-DirectiveDef.prototype.providersResolver;
-/**
- * The selectors that will be used to match nodes to this directive.
- * @type {?}
- */
-DirectiveDef.prototype.selectors;
-/**
- * Name under which the directive is exported (for use with local references in template)
- * @type {?}
- */
-DirectiveDef.prototype.exportAs;
-/**
- * Factory function used to create a new directive instance.
- * @type {?}
- */
-DirectiveDef.prototype.factory;
-/**
- * Function to create instances of content queries associated with a given directive.
- * @type {?}
- */
-DirectiveDef.prototype.contentQueries;
-/**
- * Refreshes content queries associated with directives in a given view
- * @type {?}
- */
-DirectiveDef.prototype.contentQueriesRefresh;
-/**
- * The number of host bindings (including pure fn bindings) in this directive/component.
- *
- * Used to calculate the length of the LViewData array for the *parent* component
- * of this directive/component.
- * @type {?}
- */
-DirectiveDef.prototype.hostVars;
-/**
- * Refreshes host bindings on the associated directive.
- * @type {?}
- */
-DirectiveDef.prototype.hostBindings;
-/**
- * Static attributes to set on host element.
- *
- * Even indices: attribute name
- * Odd indices: attribute value
- * @type {?}
- */
-DirectiveDef.prototype.attributes;
-/** @type {?} */
-DirectiveDef.prototype.onInit;
-/** @type {?} */
-DirectiveDef.prototype.doCheck;
-/** @type {?} */
-DirectiveDef.prototype.afterContentInit;
-/** @type {?} */
-DirectiveDef.prototype.afterContentChecked;
-/** @type {?} */
-DirectiveDef.prototype.afterViewInit;
-/** @type {?} */
-DirectiveDef.prototype.afterViewChecked;
-/** @type {?} */
-DirectiveDef.prototype.onDestroy;
-/**
- * The features applied to this directive
- * @type {?}
- */
-DirectiveDef.prototype.features;
-/** @typedef {?} */
-var ComponentDefWithMeta;
-export { ComponentDefWithMeta };
+if (false) {
+    /**
+     * Token representing the directive. Used by DI.
+     * @type {?}
+     */
+    DirectiveDef.prototype.type;
+    /**
+     * Function that resolves providers and publishes them into the DI system.
+     * @type {?}
+     */
+    DirectiveDef.prototype.providersResolver;
+    /**
+     * The selectors that will be used to match nodes to this directive.
+     * @type {?}
+     */
+    DirectiveDef.prototype.selectors;
+    /**
+     * Name under which the directive is exported (for use with local references in template)
+     * @type {?}
+     */
+    DirectiveDef.prototype.exportAs;
+    /**
+     * Factory function used to create a new directive instance.
+     * @type {?}
+     */
+    DirectiveDef.prototype.factory;
+    /**
+     * Function to create instances of content queries associated with a given directive.
+     * @type {?}
+     */
+    DirectiveDef.prototype.contentQueries;
+    /**
+     * Refreshes content queries associated with directives in a given view
+     * @type {?}
+     */
+    DirectiveDef.prototype.contentQueriesRefresh;
+    /**
+     * The number of host bindings (including pure fn bindings) in this directive/component.
+     *
+     * Used to calculate the length of the LViewData array for the *parent* component
+     * of this directive/component.
+     * @type {?}
+     */
+    DirectiveDef.prototype.hostVars;
+    /**
+     * Refreshes host bindings on the associated directive.
+     * @type {?}
+     */
+    DirectiveDef.prototype.hostBindings;
+    /**
+     * Static attributes to set on host element.
+     *
+     * Even indices: attribute name
+     * Odd indices: attribute value
+     * @type {?}
+     */
+    DirectiveDef.prototype.attributes;
+    /** @type {?} */
+    DirectiveDef.prototype.onInit;
+    /** @type {?} */
+    DirectiveDef.prototype.doCheck;
+    /** @type {?} */
+    DirectiveDef.prototype.afterContentInit;
+    /** @type {?} */
+    DirectiveDef.prototype.afterContentChecked;
+    /** @type {?} */
+    DirectiveDef.prototype.afterViewInit;
+    /** @type {?} */
+    DirectiveDef.prototype.afterViewChecked;
+    /** @type {?} */
+    DirectiveDef.prototype.onDestroy;
+    /**
+     * The features applied to this directive
+     * @type {?}
+     */
+    DirectiveDef.prototype.features;
+}
 /**
  * Runtime link information for Components.
  *
@@ -200,86 +198,88 @@ export { ComponentDefWithMeta };
  * @template T
  */
 export function ComponentDef() { }
-/**
- * Runtime unique component ID.
- * @type {?}
- */
-ComponentDef.prototype.id;
-/**
- * The View template of the component.
- * @type {?}
- */
-ComponentDef.prototype.template;
-/**
- * A set of styles that the component needs to be present for component to render correctly.
- * @type {?}
- */
-ComponentDef.prototype.styles;
-/**
- * The number of nodes, local refs, and pipes in this component template.
- *
- * Used to calculate the length of the component's LViewData array, so we
- * can pre-fill the array and set the binding start index.
- * @type {?}
- */
-ComponentDef.prototype.consts;
-/**
- * The number of bindings in this component template (including pure fn bindings).
- *
- * Used to calculate the length of the component's LViewData array, so we
- * can pre-fill the array and set the host binding start index.
- * @type {?}
- */
-ComponentDef.prototype.vars;
-/**
- * Query-related instructions for a component.
- * @type {?}
- */
-ComponentDef.prototype.viewQuery;
-/**
- * The view encapsulation type, which determines how styles are applied to
- * DOM elements. One of
- * - `Emulated` (default): Emulate native scoping of styles.
- * - `Native`: Use the native encapsulation mechanism of the renderer.
- * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and
- *   create a ShadowRoot for component's host element.
- * - `None`: Do not provide any template or style encapsulation.
- * @type {?}
- */
-ComponentDef.prototype.encapsulation;
-/**
- * Defines arbitrary developer-defined data to be stored on a renderer instance.
- * This is useful for renderers that delegate to other renderers.
- * @type {?}
- */
-ComponentDef.prototype.data;
-/**
- * Whether or not this component's ChangeDetectionStrategy is OnPush
- * @type {?}
- */
-ComponentDef.prototype.onPush;
-/**
- * Registry of directives and components that may be found in this view.
- *
- * The property is either an array of `DirectiveDef`s or a function which returns the array of
- * `DirectiveDef`s. The function is necessary to be able to support forward declarations.
- * @type {?}
- */
-ComponentDef.prototype.directiveDefs;
-/**
- * Registry of pipes that may be found in this view.
- *
- * The property is either an array of `PipeDefs`s or a function which returns the array of
- * `PipeDefs`s. The function is necessary to be able to support forward declarations.
- * @type {?}
- */
-ComponentDef.prototype.pipeDefs;
-/**
- * Used to store the result of `noSideEffects` function so that it is not removed by closure
- * compiler. The property should never be read.
- * @type {?|undefined}
- */
-ComponentDef.prototype._;
+if (false) {
+    /**
+     * Runtime unique component ID.
+     * @type {?}
+     */
+    ComponentDef.prototype.id;
+    /**
+     * The View template of the component.
+     * @type {?}
+     */
+    ComponentDef.prototype.template;
+    /**
+     * A set of styles that the component needs to be present for component to render correctly.
+     * @type {?}
+     */
+    ComponentDef.prototype.styles;
+    /**
+     * The number of nodes, local refs, and pipes in this component template.
+     *
+     * Used to calculate the length of the component's LViewData array, so we
+     * can pre-fill the array and set the binding start index.
+     * @type {?}
+     */
+    ComponentDef.prototype.consts;
+    /**
+     * The number of bindings in this component template (including pure fn bindings).
+     *
+     * Used to calculate the length of the component's LViewData array, so we
+     * can pre-fill the array and set the host binding start index.
+     * @type {?}
+     */
+    ComponentDef.prototype.vars;
+    /**
+     * Query-related instructions for a component.
+     * @type {?}
+     */
+    ComponentDef.prototype.viewQuery;
+    /**
+     * The view encapsulation type, which determines how styles are applied to
+     * DOM elements. One of
+     * - `Emulated` (default): Emulate native scoping of styles.
+     * - `Native`: Use the native encapsulation mechanism of the renderer.
+     * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and
+     *   create a ShadowRoot for component's host element.
+     * - `None`: Do not provide any template or style encapsulation.
+     * @type {?}
+     */
+    ComponentDef.prototype.encapsulation;
+    /**
+     * Defines arbitrary developer-defined data to be stored on a renderer instance.
+     * This is useful for renderers that delegate to other renderers.
+     * @type {?}
+     */
+    ComponentDef.prototype.data;
+    /**
+     * Whether or not this component's ChangeDetectionStrategy is OnPush
+     * @type {?}
+     */
+    ComponentDef.prototype.onPush;
+    /**
+     * Registry of directives and components that may be found in this view.
+     *
+     * The property is either an array of `DirectiveDef`s or a function which returns the array of
+     * `DirectiveDef`s. The function is necessary to be able to support forward declarations.
+     * @type {?}
+     */
+    ComponentDef.prototype.directiveDefs;
+    /**
+     * Registry of pipes that may be found in this view.
+     *
+     * The property is either an array of `PipeDefs`s or a function which returns the array of
+     * `PipeDefs`s. The function is necessary to be able to support forward declarations.
+     * @type {?}
+     */
+    ComponentDef.prototype.pipeDefs;
+    /**
+     * Used to store the result of `noSideEffects` function so that it is not removed by closure
+     * compiler. The property should never be read.
+     * @type {?|undefined}
+     */
+    ComponentDef.prototype._;
+}
 /**
  * Runtime link information for Pipes.
  *
@@ -295,82 +295,55 @@ ComponentDef.prototype._;
  * @template T
  */
 export function PipeDef() { }
-/**
- * Pipe name.
- *
- * Used to resolve pipe in templates.
- * @type {?}
- */
-PipeDef.prototype.name;
-/**
- * Factory function used to create a new pipe instance.
- * @type {?}
- */
-PipeDef.prototype.factory;
-/**
- * Whether or not the pipe is pure.
- *
- * Pure pipes result only depends on the pipe input and not on internal
- * state of the pipe.
- * @type {?}
- */
-PipeDef.prototype.pure;
-/** @type {?} */
-PipeDef.prototype.onDestroy;
-/** @typedef {?} */
-var PipeDefWithMeta;
-export { PipeDefWithMeta };
+if (false) {
+    /**
+     * Pipe name.
+     *
+     * Used to resolve pipe in templates.
+     * @type {?}
+     */
+    PipeDef.prototype.name;
+    /**
+     * Factory function used to create a new pipe instance.
+     * @type {?}
+     */
+    PipeDef.prototype.factory;
+    /**
+     * Whether or not the pipe is pure.
+     *
+     * Pure pipes result only depends on the pipe input and not on internal
+     * state of the pipe.
+     * @type {?}
+     */
+    PipeDef.prototype.pure;
+    /** @type {?} */
+    PipeDef.prototype.onDestroy;
+}
 /**
  * @record
  */
 export function DirectiveDefFeature() { }
-/* TODO: handle strange member:
-<T>(directiveDef: DirectiveDef<T>): void;
-*/
-/** @type {?|undefined} */
-DirectiveDefFeature.prototype.ngInherit;
+if (false) {
+    /** @type {?|undefined} */
+    DirectiveDefFeature.prototype.ngInherit;
+    /* Skipping unhandled member: <T>(directiveDef: DirectiveDef<T>): void;*/
+}
 /**
  * @record
  */
 export function ComponentDefFeature() { }
-/* TODO: handle strange member:
-<T>(componentDef: ComponentDef<T>): void;
-*/
-/** @type {?|undefined} */
-ComponentDefFeature.prototype.ngInherit;
-/** @typedef {?} */
-var DirectiveDefListOrFactory;
-export { DirectiveDefListOrFactory };
-/** @typedef {?} */
-var DirectiveDefList;
-export { DirectiveDefList };
-/** @typedef {?} */
-var DirectiveTypesOrFactory;
-export { DirectiveTypesOrFactory };
-/** @typedef {?} */
-var DirectiveTypeList;
-export { DirectiveTypeList };
-/** @typedef {?} */
-var HostBindingsFunction;
-export { HostBindingsFunction };
-/** @typedef {?} */
-var PipeDefListOrFactory;
-export { PipeDefListOrFactory };
-/** @typedef {?} */
-var PipeDefList;
-export { PipeDefList };
-/** @typedef {?} */
-var PipeTypesOrFactory;
-export { PipeTypesOrFactory };
-/** @typedef {?} */
-var PipeTypeList;
-export { PipeTypeList };
+if (false) {
+    /** @type {?|undefined} */
+    ComponentDefFeature.prototype.ngInherit;
+    /* Skipping unhandled member: <T>(componentDef: ComponentDef<T>): void;*/
+}
+// Note: This hack is necessary so we don't erroneously get a circular dependency
+// failure based on types.
 /** @type {?} */
 export const unusedValueExportToPlacateAjd = 1;
 /** @enum {number} */
-var InitialStylingFlags = {
+const InitialStylingFlags = {
     VALUES_MODE: 1,
 };
 export { InitialStylingFlags };
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;IAmCE,SAAa;;IAGb,SAAa;;;;;;;;;;;;;;;;;;;;;;;IAesB,eAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6SxD,aAAa,6BAA6B,GAAG,CAAC,CAAC;;;IAG7C,cAAiB","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {ViewEncapsulation} from '../../core';\nimport {Type} from '../../type';\nimport {CssSelectorList} from './projection';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  (rf: RenderFlags, ctx: T): void; ngPrivateData?: never;\n};\n\n/**\n * Definition of what a query function should look like.\n */\nexport type ComponentQuery<T> = ComponentTemplate<T>;\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 `ngComponentDef`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> { ngComponentDef: never; }\n\n/**\n * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> { ngDirectiveDef: never; }\n\nexport const enum DirectiveDefFlags {ContentQuery = 0b10}\n\n/**\n * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> { ngPipeDef: never; }\n\nexport type DirectiveDefWithMeta<\n    T, Selector extends string, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = DirectiveDef<T>;\n\n/**\n * Runtime information for classes that are inherited by components or directives\n * that aren't defined as components or directives.\n *\n * This is an internal data structure used by the render to determine what inputs\n * and outputs should be inherited.\n *\n * See: {@link defineBase}\n */\nexport interface BaseDef<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]: P};\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]: P};\n}\n\n/**\n * Runtime link information for Directives.\n *\n * This is 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> extends BaseDef<T> {\n  /** Token representing the directive. Used by DI. */\n  type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver: ((def: DirectiveDef<T>) => 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   * Factory function used to create a new directive instance.\n   */\n  factory: (t: Type<T>|null) => T;\n\n  /**\n   * Function to create instances of content queries associated with a given directive.\n   */\n  contentQueries: ((directiveIndex: number) => void)|null;\n\n  /** Refreshes content queries associated with directives in a given view */\n  contentQueriesRefresh: ((directiveIndex: number, queryIndex: number) => void)|null;\n\n  /**\n   * The number of host bindings (including pure fn bindings) in this directive/component.\n   *\n   * Used to calculate the length of the LViewData array for the *parent* component\n   * of this directive/component.\n   */\n  readonly hostVars: number;\n\n  /** Refreshes host bindings on the associated directive. */\n  hostBindings: HostBindingsFunction|null;\n\n  /**\n   * Static attributes to set on host element.\n   *\n   * Even indices: attribute name\n   * Odd indices: attribute value\n   */\n  readonly attributes: string[]|null;\n\n  /* The following are lifecycle hooks for this component */\n  onInit: (() => void)|null;\n  doCheck: (() => void)|null;\n  afterContentInit: (() => void)|null;\n  afterContentChecked: (() => void)|null;\n  afterViewInit: (() => void)|null;\n  afterViewChecked: (() => void)|null;\n  onDestroy: (() => void)|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n}\n\nexport type ComponentDefWithMeta<\n    T, Selector extends String, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = ComponentDef<T>;\n\n/**\n * Runtime link information for Components.\n *\n * This is 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  /**\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 LViewData 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 consts: 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 LViewData 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: ComponentQuery<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\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   * 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 _?: never;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is 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  /**\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.\n   */\n  factory: (t: Type<T>|null) => T;\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  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport type PipeDefWithMeta<T, Name extends string> = PipeDef<T>;\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  ngInherit?: true;\n}\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\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    (DirectiveDef<any>| ComponentDef<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type HostBindingsFunction = (directiveIndex: number, elementIndex: number) => 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 = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type PipeTypeList =\n    (PipeDef<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\nexport const enum InitialStylingFlags {\n  VALUES_MODE = 0b1,\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"../../","sources":["packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":";;;;;;;;;;;;;IAkCE,6EAA6E;IAC7E,SAAa;IAEb,6DAA6D;IAC7D,SAAa;;;;;;;;;AAOf,mCAA4E;;;IAAxB,uCAAsB;;;;;;;;AAM1E,mCAA4E;;;IAAxB,uCAAsB;;;;IAErC,eAAmB;;;;;;;;;AAMxD,8BAAkE;;;IAAnB,6BAAiB;;;;;;;;;;;;;AAehE,6BAoBC;;;;;;;;IAdC,yBAA0C;;;;;;IAM1C,iCAA6C;;;;;;;IAO7C,0BAAsC;;;;;;;;;;;;;;;;;;AAiBxC,kCA4DC;;;;;;IA1DC,4BAAc;;;;;IAGd,yCAAyD;;;;;IAGzD,iCAAoC;;;;;IAKpC,gCAA+B;;;;;IAK/B,+BAAgC;;;;;IAKhC,sCAAwD;;;;;IAGxD,6CAAmF;;;;;;;;IAQnF,gCAA0B;;;;;IAG1B,oCAAwC;;;;;;;;IAQxC,kCAAmC;;IAGnC,8BAA0B;;IAC1B,+BAA2B;;IAC3B,wCAAoC;;IACpC,2CAAuC;;IACvC,qCAAiC;;IACjC,wCAAoC;;IACpC,iCAA6B;;;;;IAK7B,gCAA8C;;;;;;;;;;;;;;;;AAmBhD,kCAgFC;;;;;;IA5EC,0BAAoB;;;;;IAKpB,gCAAwC;;;;;IAKxC,8BAA0B;;;;;;;;IAS1B,8BAAwB;;;;;;;;IAQxB,4BAAsB;;;;;IAKtB,iCAAkC;;;;;;;;;;;IAWlC,qCAA0C;;;;;;IAM1C,4BAAqC;;;;;IAGrC,8BAAyB;;;;;;;;IASzB,qCAA8C;;;;;;;;IAQ9C,gCAAoC;;;;;;IAMpC,yBAAmB;;;;;;;;;;;;;;;;AAerB,6BAuBC;;;;;;;;IAjBC,uBAAsB;;;;;IAKtB,0BAAgC;;;;;;;;IAQhC,uBAAuB;;IAGvB,4BAA6B;;;;;AAK/B,yCAGC;;;IADC,wCAAiB;;;;;;AAGnB,yCAGC;;;IADC,wCAAiB;;;;;;AAsCnB,MAAM,OAAO,6BAA6B,GAAG,CAAC;;;IAG5C,cAAiB","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {ViewEncapsulation} from '../../core';\nimport {Type} from '../../type';\nimport {CssSelectorList} from './projection';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  (rf: RenderFlags, ctx: T): void; ngPrivateData?: never;\n};\n\n/**\n * Definition of what a query function should look like.\n */\nexport type ComponentQuery<T> = ComponentTemplate<T>;\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 `ngComponentDef`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> { ngComponentDef: never; }\n\n/**\n * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> { ngDirectiveDef: never; }\n\nexport const enum DirectiveDefFlags {ContentQuery = 0b10}\n\n/**\n * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> { ngPipeDef: never; }\n\nexport type DirectiveDefWithMeta<\n    T, Selector extends string, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = DirectiveDef<T>;\n\n/**\n * Runtime information for classes that are inherited by components or directives\n * that aren't defined as components or directives.\n *\n * This is an internal data structure used by the render to determine what inputs\n * and outputs should be inherited.\n *\n * See: {@link defineBase}\n */\nexport interface BaseDef<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]: P};\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]: P};\n}\n\n/**\n * Runtime link information for Directives.\n *\n * This is 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> extends BaseDef<T> {\n  /** Token representing the directive. Used by DI. */\n  type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver: ((def: DirectiveDef<T>) => 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   * Factory function used to create a new directive instance.\n   */\n  factory: (t: Type<T>|null) => T;\n\n  /**\n   * Function to create instances of content queries associated with a given directive.\n   */\n  contentQueries: ((directiveIndex: number) => void)|null;\n\n  /** Refreshes content queries associated with directives in a given view */\n  contentQueriesRefresh: ((directiveIndex: number, queryIndex: number) => void)|null;\n\n  /**\n   * The number of host bindings (including pure fn bindings) in this directive/component.\n   *\n   * Used to calculate the length of the LViewData array for the *parent* component\n   * of this directive/component.\n   */\n  readonly hostVars: number;\n\n  /** Refreshes host bindings on the associated directive. */\n  hostBindings: HostBindingsFunction|null;\n\n  /**\n   * Static attributes to set on host element.\n   *\n   * Even indices: attribute name\n   * Odd indices: attribute value\n   */\n  readonly attributes: string[]|null;\n\n  /* The following are lifecycle hooks for this component */\n  onInit: (() => void)|null;\n  doCheck: (() => void)|null;\n  afterContentInit: (() => void)|null;\n  afterContentChecked: (() => void)|null;\n  afterViewInit: (() => void)|null;\n  afterViewChecked: (() => void)|null;\n  onDestroy: (() => void)|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n}\n\nexport type ComponentDefWithMeta<\n    T, Selector extends String, ExportAs extends string, InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = ComponentDef<T>;\n\n/**\n * Runtime link information for Components.\n *\n * This is 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  /**\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 LViewData 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 consts: 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 LViewData 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: ComponentQuery<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\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   * 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 _?: never;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is 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  /**\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.\n   */\n  factory: (t: Type<T>|null) => T;\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  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\nexport type PipeDefWithMeta<T, Name extends string> = PipeDef<T>;\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  ngInherit?: true;\n}\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\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    (DirectiveDef<any>| ComponentDef<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type HostBindingsFunction = (directiveIndex: number, elementIndex: number) => 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 = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type PipeTypeList =\n    (PipeDef<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\nexport const enum InitialStylingFlags {\n  VALUES_MODE = 0b1,\n}\n"]}