@angular/core 6.1.6 → 6.1.10

package/src/linker/template_ref.d.ts

@@ -8,29 +8,39 @@
 import { ElementRef } from './element_ref';
 import { EmbeddedViewRef } from './view_ref';
 /**
- * Represents an Embedded Template that can be used to instantiate Embedded Views.
+ * Represents an embedded template that can be used to instantiate embedded views.
+ * To instantiate embedded views based on a template, use the `ViewContainerRef`
+ * method `createEmbeddedView()`.
  *
- * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element
- * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into
- * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for
- * the `TemplateRef` from a Component or a Directive via {@link Query}.
+ * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`
+ * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view
+ * is injected into the constructor of the directive,
+ * using the `TemplateRef` token.
  *
- * To instantiate Embedded Views based on a Template, use {@link ViewContainerRef#
- * createEmbeddedView}, which will create the View and attach it to the View Container.
+ * You can also use a `Query` to find a `TemplateRef` associated with
+ * a component or a directive.
+ *
+ * @see `ViewContainerRef`
+ * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)
  *
  */
 export declare abstract class TemplateRef<C> {
     /**
-     * The location in the View where the Embedded View logically belongs to.
+     * The anchor element in the parent view for this embedded view.
      *
-     * The data-binding and injection contexts of Embedded Views created from this `TemplateRef`
+     * The data-binding and injection contexts of embedded views created from this `TemplateRef`
      * inherit from the contexts of this location.
      *
-     * Typically new Embedded Views are attached to the View Container of this location, but in
-     * advanced use-cases, the View can be attached to a different container while keeping the
+     * Typically new embedded views are attached to the view container of this location, but in
+     * advanced use-cases, the view can be attached to a different container while keeping the
      * data-binding and injection context from the original location.
      *
      */
     abstract readonly elementRef: ElementRef;
+    /**
+     * Creates a view object and attaches it to the view container of the parent view.
+     * @param context The context for the new view, inherited from the anchor element.
+     * @returns The new view object.
+     */
     abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;
 }

package/src/linker/view_container_ref.d.ts

@@ -12,95 +12,112 @@ import { NgModuleRef } from './ng_module_factory';
 import { TemplateRef } from './template_ref';
 import { EmbeddedViewRef, ViewRef } from './view_ref';
 /**
- * Represents a container where one or more Views can be attached.
+ * Represents a container where one or more views can be attached to a component.
  *
- * The container can contain two kinds of Views. Host Views, created by instantiating a
- * {@link Component} via {@link #createComponent}, and Embedded Views, created by instantiating an
- * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
+ * Can contain *host views* (created by instantiating a
+ * component with the `createComponent()` method), and *embedded views*
+ * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
  *
- * The location of the View Container within the containing View is specified by the Anchor
- * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
- * have a single View Container.
+ * A view container instance can contain other view containers,
+ * creating a [view hierarchy](guide/glossary#view-tree).
  *
- * Root elements of Views attached to this container become siblings of the Anchor Element in
- * the Rendered View.
- *
- * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
- * with `ViewContainerRef` on the Element, or you obtain it via a {@link ViewChild} query.
+ * @see `ComponentRef`
+ * @see `EmbeddedViewRef`
  *
  */
 export declare abstract class ViewContainerRef {
     /**
-     * Anchor element that specifies the location of this container in the containing View.
+     * Anchor element that specifies the location of this container in the containing view.
+     * Each view container can have only one anchor element, and each anchor element
+     * can have only a single view container.
+     *
+     * Root elements of views attached to this container become siblings of the anchor element in
+     * the rendered view.
+     *
+     * Access the `ViewContainerRef` of an element by placing a `Directive` injected
+     * with `ViewContainerRef` on the element, or use a `ViewChild` query.
+     *
      * <!-- TODO: rename to anchorElement -->
      */
     abstract readonly element: ElementRef;
+    /**
+     * The [dependency injector](guide/glossary#injector) for this view container.
+     */
     abstract readonly injector: Injector;
     abstract readonly parentInjector: Injector;
     /**
-     * Destroys all Views in this container.
+     * Destroys all views in this container.
      */
     abstract clear(): void;
     /**
-     * Returns the {@link ViewRef} for the View located in this container at the specified index.
+     * Retrieves a view from this container.
+     * @param index The 0-based index of the view to retrieve.
+     * @returns The `ViewRef` instance, or null if the index is out of range.
      */
     abstract get(index: number): ViewRef | null;
     /**
-     * Returns the number of Views currently attached to this container.
+     * Reports how many views are currently attached to this container.
+     * @returns The number of views.
      */
     abstract readonly length: number;
     /**
-     * Instantiates an Embedded View based on the {@link TemplateRef `templateRef`} and inserts it
-     * into this container at the specified `index`.
+     * Instantiates an embedded view and inserts it
+     * into this container.
+     * @param templateRef The HTML template that defines the view.
+     * @param index The 0-based index at which to insert the new view into this container.
+     * If not specified, appends the new view as the last entry.
      *
-     * If `index` is not specified, the new View will be inserted as the last View in the container.
-     *
-     * Returns the {@link ViewRef} for the newly created View.
+     * @returns The `ViewRef` instance for the newly created view.
      */
     abstract createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number): EmbeddedViewRef<C>;
     /**
-     * Instantiates a single {@link Component} and inserts its Host View into this container at the
-     * specified `index`.
-     *
-     * The component is instantiated using its {@link ComponentFactory} which can be obtained via
-     * {@link ComponentFactoryResolver#resolveComponentFactory resolveComponentFactory}.
+     * Instantiates a single component and inserts its host view into this container.
      *
-     * If `index` is not specified, the new View will be inserted as the last View in the container.
+     * @param componentFactory The factory to use.
+     * @param index The index at which to insert the new component's host view into this container.
+     * If not specified, appends the new view as the last entry.
+     * @param injector The injector to use as the parent for the new component.
+     * @param projectableNodes
+     * @param ngModule
      *
-     * You can optionally specify the {@link Injector} that will be used as parent for the Component.
+     * @returns The new component instance, containing the host view.
      *
-     * Returns the {@link ComponentRef} of the Host View created for the newly instantiated Component.
      */
     abstract createComponent<C>(componentFactory: ComponentFactory<C>, index?: number, injector?: Injector, projectableNodes?: any[][], ngModule?: NgModuleRef<any>): ComponentRef<C>;
     /**
-     * Inserts a View identified by a {@link ViewRef} into the container at the specified `index`.
-     *
-     * If `index` is not specified, the new View will be inserted as the last View in the container.
+     * Inserts a view into this container.
+     * @param viewRef The view to insert.
+     * @param index The 0-based index at which to insert the view.
+     * If not specified, appends the new view as the last entry.
+     * @returns The inserted `ViewRef` instance.
      *
-     * Returns the inserted {@link ViewRef}.
      */
     abstract insert(viewRef: ViewRef, index?: number): ViewRef;
     /**
-     * Moves a View identified by a {@link ViewRef} into the container at the specified `index`.
-     *
-     * Returns the inserted {@link ViewRef}.
+     * Moves a view to a new location in this container.
+     * @param viewRef The view to move.
+     * @param index The 0-based index of the new location.
+     * @returns The moved `ViewRef` instance.
      */
     abstract move(viewRef: ViewRef, currentIndex: number): ViewRef;
     /**
-     * Returns the index of the View, specified via {@link ViewRef}, within the current container or
-     * `-1` if this container doesn't contain the View.
+     * Returns the index of a view within the current container.
+     * @param viewRef The view to query.
+     * @returns The 0-based index of the view's position in this container,
+     * or `-1` if this container doesn't contain the view.
      */
     abstract indexOf(viewRef: ViewRef): number;
     /**
-     * Destroys a View attached to this container at the specified `index`.
-     *
-     * If `index` is not specified, the last View in the container will be removed.
+     * Destroys a view attached to this container
+     * @param index The 0-based index of the view to destroy.
+     * If not specified, the last view in the container is removed.
      */
     abstract remove(index?: number): void;
     /**
-     * Use along with {@link #insert} to move a View within the current container.
-     *
-     * If the `index` param is omitted, the last {@link ViewRef} is detached.
+     * Detaches a view from this container without destroying it.
+     * Use along with `insert()` to move a view within the current container.
+     * @param index The 0-based index of the view to detach.
+     * If not specified, the last view in the container is detached.
      */
     abstract detach(index?: number): ViewRef | null;
 }

package/src/linker/view_ref.d.ts

@@ -7,30 +7,48 @@
  */
 import { ApplicationRef } from '../application_ref';
 import { ChangeDetectorRef } from '../change_detection/change_detector_ref';
+/**
+ * Represents an Angular [view](guide/glossary#view),
+ * specifically the [host view](guide/glossary#view-tree) that is defined by a component.
+ * Also serves as the base class
+ * that adds destroy methods for [embedded views](guide/glossary#view-tree).
+ *
+ * @see `EmbeddedViewRef`
+ */
 export declare abstract class ViewRef extends ChangeDetectorRef {
     /**
-     * Destroys the view and all of the data structures associated with it.
+     * Destroys this view and all of the data structures associated with it.
      */
     abstract destroy(): void;
+    /**
+     * Reports whether this view has been destroyed.
+     * @returns True after the `destroy()` method has been called, false otherwise.
+     */
     abstract readonly destroyed: boolean;
+    /**
+     * A lifecycle hook that provides additional developer-defined cleanup
+     * functionality for views.
+     * @param callback A handler function that cleans up developer-defined data
+     * associated with a view. Called when the `destroy()` method is invoked.
+     */
     abstract onDestroy(callback: Function): any /** TODO #9100 */;
 }
 /**
- * Represents an Angular View.
+ * Represents an Angular [view](guide/glossary#view) in a view container.
+ * An [embedded view](guide/glossary#view-tree) can be referenced from a component
+ * other than the hosting component whose template defines it, or it can be defined
+ * independently by a `TemplateRef`.
  *
- * <!-- TODO: move the next two paragraphs to the dev guide -->
- * A View is a fundamental building block of the application UI. It is the smallest grouping of
- * Elements which are created and destroyed together.
+ * Properties of elements in a view can change, but the structure (number and order) of elements in
+ * a view cannot. Change the structure of elements by inserting, moving, or
+ * removing nested views in a view container.
  *
- * Properties of elements in a View can change, but the structure (number and order) of elements in
- * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
- * removing nested Views via a `ViewContainerRef`. Each View can contain many View Containers.
- * <!-- /TODO -->
+ * @see `ViewContainerRef`
  *
  * @usageNotes
- * ### Example
  *
- * Given this template...
+ * The following template breaks down into two separate `TemplateRef` instances,
+ * an outer one and an inner one.
  *
  * ```
  * Count: {{items.length}}
@@ -39,9 +57,7 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
  * </ul>
  * ```
  *
- * We have two `TemplateRef`s:
- *
- * Outer `TemplateRef`:
+ * This is the outer `TemplateRef`:
  *
  * ```
  * Count: {{items.length}}
@@ -50,15 +66,13 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
  * </ul>
  * ```
  *
- * Inner `TemplateRef`:
+ * This is the inner `TemplateRef`:
  *
  * ```
  *   <li>{{item}}</li>
  * ```
  *
- * Notice that the original template is broken down into two separate `TemplateRef`s.
- *
- * The outer/inner `TemplateRef`s are then assembled into views like so:
+ * The outer and inner `TemplateRef` instances are assembled into views as follows:
  *
  * ```
  * <!-- ViewRef: outer-0 -->
@@ -73,7 +87,13 @@ export declare abstract class ViewRef extends ChangeDetectorRef {
  * @experimental
  */
 export declare abstract class EmbeddedViewRef<C> extends ViewRef {
+    /**
+     * The context for this view, inherited from the anchor element.
+     */
     abstract readonly context: C;
+    /**
+     * The root nodes for this embedded view.
+     */
     abstract readonly rootNodes: any[];
 }
 export interface InternalViewRef extends ViewRef {

package/src/metadata/view.d.ts

@@ -10,6 +10,9 @@
  *
  * See {@link Component#encapsulation encapsulation}.
  *
+ * @usageNotes
+ * ### Example
+ * {@example core/ts/metadata/encapsulation.ts region='longform'}
  */
 export declare enum ViewEncapsulation {
     /**
@@ -40,9 +43,6 @@ export declare enum ViewEncapsulation {
      * For the DOM this means using modern [Shadow
      * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
      * creating a ShadowRoot for Component's Host Element.
-     *
-     * ### Example
-     * {@example core/ts/metadata/encapsulation.ts region='longform'}
      */
     ShadowDom = 3
 }

package/src/render3/ng_dev_mode.d.ts

@@ -29,4 +29,4 @@ declare global {
         rendererRemoveNode: number;
     }
 }
-export declare const ngDevModeResetPerfCounters: () => void;
+export declare function ngDevModeResetPerfCounters(): NgDevModePerfCounters;

package/src/zone.d.ts

@@ -5,4 +5,4 @@
  * 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
  */
-export { NgZone } from './zone/ng_zone';
+export { NgZone, NoopNgZone as ɵNoopNgZone } from './zone/ng_zone';