@angular/cdk 7.1.1 → 7.3.0

package/typings/drag-drop/directives/drag.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from '@angular/cdk/bidi';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import { AfterViewInit, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy, QueryList, ViewContainerRef, OnChanges, SimpleChanges } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DragDropRegistry } from '../drag-drop-registry';
+import { CdkDragDrop, CdkDragEnd, CdkDragEnter, CdkDragExit, CdkDragMove, CdkDragStart, CdkDragRelease } from '../drag-events';
+import { CdkDragHandle } from './drag-handle';
+import { CdkDragPlaceholder } from './drag-placeholder';
+import { CdkDragPreview } from './drag-preview';
+import { DragRef, DragRefConfig } from '../drag-ref';
+import { DropListRef } from '../drop-list-ref';
+import { CdkDropListInternal as CdkDropList } from './drop-list';
+import { DragDrop } from '../drag-drop';
+/** Injection token that can be used to configure the behavior of `CdkDrag`. */
+export declare const CDK_DRAG_CONFIG: InjectionToken<DragRefConfig>;
+/** @docs-private */
+export declare function CDK_DRAG_CONFIG_FACTORY(): DragRefConfig;
+/** Element that can be moved inside a CdkDropList container. */
+export declare class CdkDrag<T = any> implements AfterViewInit, OnChanges, OnDestroy {
+    /** Element that the draggable is attached to. */
+    element: ElementRef<HTMLElement>;
+    /** Droppable container that the draggable is a part of. */
+    dropContainer: CdkDropList;
+    private _document;
+    private _ngZone;
+    private _viewContainerRef;
+    private _dir;
+    private _destroyed;
+    /** Reference to the underlying drag instance. */
+    _dragRef: DragRef<CdkDrag<T>>;
+    /** Elements that can be used to drag the draggable item. */
+    _handles: QueryList<CdkDragHandle>;
+    /** Element that will be used as a template to create the draggable item's preview. */
+    _previewTemplate: CdkDragPreview;
+    /** Template for placeholder element rendered to show where a draggable would be dropped. */
+    _placeholderTemplate: CdkDragPlaceholder;
+    /** Arbitrary data to attach to this drag instance. */
+    data: T;
+    /** Locks the position of the dragged element along the specified axis. */
+    lockAxis: 'x' | 'y';
+    /**
+     * Selector that will be used to determine the root draggable element, starting from
+     * the `cdkDrag` element and going up the DOM. Passing an alternate root element is useful
+     * when trying to enable dragging on an element that you might not have access to.
+     */
+    rootElementSelector: string;
+    /**
+     * Selector that will be used to determine the element to which the draggable's position will
+     * be constrained. Matching starts from the element's parent and goes up the DOM until a matching
+     * element has been found.
+     */
+    boundaryElementSelector: string;
+    /** Whether starting to drag this element is disabled. */
+    disabled: boolean;
+    private _disabled;
+    /** Emits when the user starts dragging the item. */
+    started: EventEmitter<CdkDragStart>;
+    /** Emits when the user has released a drag item, before any animations have started. */
+    released: EventEmitter<CdkDragRelease>;
+    /** Emits when the user stops dragging an item in the container. */
+    ended: EventEmitter<CdkDragEnd>;
+    /** Emits when the user has moved the item into a new container. */
+    entered: EventEmitter<CdkDragEnter<any>>;
+    /** Emits when the user removes the item its container by dragging it into another container. */
+    exited: EventEmitter<CdkDragExit<any>>;
+    /** Emits when the user drops the item inside a container. */
+    dropped: EventEmitter<CdkDragDrop<any>>;
+    /**
+     * Emits as the user is dragging the item. Use with caution,
+     * because this event will fire for every pixel that the user has dragged.
+     */
+    moved: Observable<CdkDragMove<T>>;
+    constructor(
+    /** Element that the draggable is attached to. */
+    element: ElementRef<HTMLElement>, 
+    /** Droppable container that the draggable is a part of. */
+    dropContainer: CdkDropList, _document: any, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, viewportRuler: ViewportRuler, dragDropRegistry: DragDropRegistry<DragRef, DropListRef>, config: DragRefConfig, _dir: Directionality, 
+    /**
+     * @deprecated `viewportRuler` and `dragDropRegistry` parameters
+     * to be removed. Also `dragDrop` parameter to be made required.
+     * @breaking-change 8.0.0.
+     */
+    dragDrop?: DragDrop);
+    /**
+     * Returns the element that is being used as a placeholder
+     * while the current element is being dragged.
+     */
+    getPlaceholderElement(): HTMLElement;
+    /** Returns the root draggable element. */
+    getRootElement(): HTMLElement;
+    /** Resets a standalone drag item to its initial position. */
+    reset(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Syncs the root element with the `DragRef`. */
+    private _updateRootElement;
+    /** Gets the boundary element, based on the `boundaryElementSelector`. */
+    private _getBoundaryElement;
+    /** Syncs the inputs of the CdkDrag with the options of the underlying DragRef. */
+    private _syncInputs;
+    /**
+     * Proxies the events from a DragRef to events that
+     * match the interfaces of the CdkDrag outputs.
+     */
+    private _proxyEvents;
+}

package/typings/drag-drop/{drop-list-group.d.ts → directives/drop-list-group.d.ts}

@@ -15,5 +15,8 @@ import { OnDestroy } from '@angular/core';
 export declare class CdkDropListGroup<T> implements OnDestroy {
     /** Drop lists registered inside the group. */
     readonly _items: Set<T>;
+    /** Whether starting a dragging sequence from inside this group is disabled. */
+    disabled: boolean;
+    private _disabled;
     ngOnDestroy(): void;
 }

package/typings/{esm5/drag-drop → drag-drop/directives}/drop-list.d.ts

@@ -5,19 +5,36 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { ElementRef, EventEmitter, OnDestroy, OnInit, QueryList, ChangeDetectorRef } from '@angular/core';
+import { ElementRef, EventEmitter, OnDestroy, QueryList, ChangeDetectorRef, AfterContentInit } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import { CdkDrag } from './drag';
-import { DragDropRegistry } from './drag-drop-registry';
-import { CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent } from './drag-events';
+import { DragDropRegistry } from '../drag-drop-registry';
+import { CdkDragDrop, CdkDragEnter, CdkDragExit, CdkDragSortEvent } from '../drag-events';
+import { CdkDropListContainer } from '../drop-list-container';
 import { CdkDropListGroup } from './drop-list-group';
+import { DropListRef } from '../drop-list-ref';
+import { DragRef } from '../drag-ref';
+import { DragDrop } from '../drag-drop';
+/**
+ * Internal compile-time-only representation of a `CdkDropList`.
+ * Used to avoid circular import issues between the `CdkDropList` and the `CdkDrag`.
+ * @docs-private
+ */
+export interface CdkDropListInternal extends CdkDropList {
+}
 /** Container that wraps a set of draggable items. */
-export declare class CdkDropList<T = any> implements OnInit, OnDestroy {
+export declare class CdkDropList<T = any> implements CdkDropListContainer, AfterContentInit, OnDestroy {
+    /** Element that the drop list is attached to. */
     element: ElementRef<HTMLElement>;
-    private _dragDropRegistry;
     private _changeDetectorRef;
     private _dir?;
     private _group?;
+    /** Emits when the list has been destroyed. */
+    private _destroyed;
+    /** Keeps track of the drop lists that are currently on the page. */
+    private static _dropLists;
+    /** Reference to the underlying drop list instance. */
+    _dropListRef: DropListRef<CdkDropList<T>>;
     /** Draggable items in the container. */
     _draggables: QueryList<CdkDrag>;
     /**
@@ -58,24 +75,17 @@ export declare class CdkDropList<T = any> implements OnInit, OnDestroy {
     exited: EventEmitter<CdkDragExit<T>>;
     /** Emits as the user is swapping items while actively dragging. */
     sorted: EventEmitter<CdkDragSortEvent<T>>;
-    constructor(element: ElementRef<HTMLElement>, _dragDropRegistry: DragDropRegistry<CdkDrag, CdkDropList<T>>, _changeDetectorRef: ChangeDetectorRef, _dir?: Directionality | undefined, _group?: CdkDropListGroup<CdkDropList<any>> | undefined);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /** Whether an item in the container is being dragged. */
-    _dragging: boolean;
-    /** Cache of the dimensions of all the items and the sibling containers. */
-    private _positionCache;
-    /**
-     * Draggable items that are currently active inside the container. Includes the items
-     * from `_draggables`, as well as any items that have been dragged in, but haven't
-     * been dropped yet.
-     */
-    private _activeDraggables;
+    constructor(
+    /** Element that the drop list is attached to. */
+    element: ElementRef<HTMLElement>, dragDropRegistry: DragDropRegistry<DragRef, DropListRef>, _changeDetectorRef: ChangeDetectorRef, _dir?: Directionality | undefined, _group?: CdkDropListGroup<CdkDropList<any>> | undefined, _document?: any, 
     /**
-     * Keeps track of the item that was last swapped with the dragged item, as
-     * well as what direction the pointer was moving in when the swap occured.
+     * @deprecated `dragDropRegistry` and `_document` parameters to be removed.
+     * Also `dragDrop` parameter to be made required.
+     * @breaking-change 8.0.0.
      */
-    private _previousSwap;
+    dragDrop?: DragDrop);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
     /** Starts dragging an item. */
     start(): void;
     /**
@@ -83,8 +93,10 @@ export declare class CdkDropList<T = any> implements OnInit, OnDestroy {
      * @param item Item being dropped into the container.
      * @param currentIndex Index at which the item should be inserted.
      * @param previousContainer Container from which the item got dragged in.
+     * @param isPointerOverContainer Whether the user's pointer was over the
+     *    container when the item was dropped.
      */
-    drop(item: CdkDrag, currentIndex: number, previousContainer: CdkDropList): void;
+    drop(item: CdkDrag, currentIndex: number, previousContainer: Partial<CdkDropListContainer>, isPointerOverContainer: boolean): void;
     /**
      * Emits an event to indicate that the user moved an item into the container.
      * @param item Item that was moved into the container.
@@ -107,7 +119,7 @@ export declare class CdkDropList<T = any> implements OnInit, OnDestroy {
      * @param item Item to be sorted.
      * @param pointerX Position of the item along the X axis.
      * @param pointerY Position of the item along the Y axis.
-     * @param pointerDeta Direction in which the pointer is moving along each axis.
+     * @param pointerDelta Direction in which the pointer is moving along each axis.
      */
     _sortItem(item: CdkDrag, pointerX: number, pointerY: number, pointerDelta: {
         x: number;
@@ -120,53 +132,15 @@ export declare class CdkDropList<T = any> implements OnInit, OnDestroy {
      * @param x Position of the item along the X axis.
      * @param y Position of the item along the Y axis.
      */
-    _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropList | null;
-    /**
-     * Checks whether an item that started in this container can be returned to it,
-     * after it was moved out into another container.
-     * @param x Position of the item along the X axis.
-     * @param y Position of the item along the Y axis.
-     */
-    _canReturnItem(x: number, y: number): boolean;
-    /** Refreshes the position cache of the items and sibling containers. */
-    private _cachePositions;
-    /** Resets the container to its initial state. */
-    private _reset;
-    /**
-     * Updates the top/left positions of a `ClientRect`, as well as their bottom/right counterparts.
-     * @param clientRect `ClientRect` that should be updated.
-     * @param top Amount to add to the `top` position.
-     * @param left Amount to add to the `left` position.
-     */
-    private _adjustClientRect;
-    /**
-     * Gets the index of an item in the drop container, based on the position of the user's pointer.
-     * @param item Item that is being sorted.
-     * @param pointerX Position of the user's pointer along the X axis.
-     * @param pointerY Position of the user's pointer along the Y axis.
-     * @param delta Direction in which the user is moving their pointer.
-     */
-    private _getItemIndexFromPointerPosition;
-    /**
-     * Checks whether the pointer coordinates are close to the drop container.
-     * @param pointerX Coordinates along the X axis.
-     * @param pointerY Coordinates along the Y axis.
-     */
-    private _isPointerNearDropContainer;
-    /**
-     * Gets the offset in pixels by which the item that is being dragged should be moved.
-     * @param currentPosition Current position of the item.
-     * @param newPosition Position of the item where the current item should be moved.
-     * @param delta Direction in which the user is moving.
-     */
-    private _getItemOffsetPx;
+    _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropListContainer | null;
     /**
-     * Gets the offset in pixels by which the items that aren't being dragged should be moved.
-     * @param currentIndex Index of the item currently being dragged.
-     * @param siblings All of the items in the list.
-     * @param delta Direction in which the user is moving.
+     * Checks whether the user's pointer is positioned over the container.
+     * @param x Pointer position along the X axis.
+     * @param y Pointer position along the Y axis.
      */
-    private _getSiblingOffsetPx;
-    /** Gets an array of unique drop lists that the current list is connected to. */
-    private _getConnectedLists;
+    _isOverContainer(x: number, y: number): boolean;
+    /** Syncs the inputs of the CdkDropList with the options of the underlying DropListRef. */
+    private _syncInputs;
+    /** Handles events from the underlying DropListRef. */
+    private _handleEvents;
 }

package/typings/drag-drop/drag-drop-registry.d.ts

@@ -54,13 +54,18 @@ export declare class DragDropRegistry<I, C extends {
     stopDragging(drag: I): void;
     /** Gets whether a drag item instance is currently being dragged. */
     isDragging(drag: I): boolean;
-    /** Gets a drop container by its id. */
+    /**
+     * Gets a drop container by its id.
+     * @deprecated No longer being used. To be removed.
+     * @breaking-change 8.0.0
+     */
     getDropContainer(id: string): C | undefined;
     ngOnDestroy(): void;
     /**
-     * Listener used to prevent `touchmove` and `wheel` events while the element is being dragged.
+     * Event listener that will prevent the default browser action while the user is dragging.
+     * @param event Event whose default action should be prevented.
      */
-    private _preventScrollListener;
+    private _preventDefaultWhileDragging;
     /** Clears out the global event listeners from the `document`. */
     private _clearGlobalListeners;
 }

package/typings/drag-drop/drag-drop.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { NgZone, ElementRef } from '@angular/core';
+import { ViewportRuler } from '@angular/cdk/scrolling';
+import { DragRef, DragRefConfig } from './drag-ref';
+import { DropListRef } from './drop-list-ref';
+import { DragDropRegistry } from './drag-drop-registry';
+/**
+ * Service that allows for drag-and-drop functionality to be attached to DOM elements.
+ */
+export declare class DragDrop {
+    private _document;
+    private _ngZone;
+    private _viewportRuler;
+    private _dragDropRegistry;
+    constructor(_document: any, _ngZone: NgZone, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry<DragRef, DropListRef>);
+    /**
+     * Turns an element into a draggable item.
+     * @param element Element to which to attach the dragging functionality.
+     * @param config Object used to configure the dragging behavior.
+     */
+    createDrag<T = any>(element: ElementRef<HTMLElement> | HTMLElement, config?: DragRefConfig): DragRef<T>;
+    /**
+     * Turns an element into a drop list.
+     * @param element Element to which to attach the drop list functionality.
+     */
+    createDropList<T = any>(element: ElementRef<HTMLElement> | HTMLElement): DropListRef<T>;
+}

package/typings/drag-drop/drag-events.d.ts

@@ -5,13 +5,18 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { CdkDrag } from './drag';
-import { CdkDropListContainer } from './drop-list-container';
+import { CdkDrag } from './directives/drag';
+import { CdkDropList } from './directives/drop-list';
 /** Event emitted when the user starts dragging a draggable. */
 export interface CdkDragStart<T = any> {
     /** Draggable that emitted the event. */
     source: CdkDrag<T>;
 }
+/** Event emitted when the user releases an item, before any animations have started. */
+export interface CdkDragRelease<T = any> {
+    /** Draggable that emitted the event. */
+    source: CdkDrag<T>;
+}
 /** Event emitted when the user stops dragging a draggable. */
 export interface CdkDragEnd<T = any> {
     /** Draggable that emitted the event. */
@@ -20,7 +25,7 @@ export interface CdkDragEnd<T = any> {
 /** Event emitted when the user moves an item into a new drop container. */
 export interface CdkDragEnter<T = any, I = T> {
     /** Container into which the user has moved the item. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that was removed from the container. */
     item: CdkDrag<I>;
 }
@@ -30,7 +35,7 @@ export interface CdkDragEnter<T = any, I = T> {
  */
 export interface CdkDragExit<T = any, I = T> {
     /** Container from which the user has a removed an item. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that was removed from the container. */
     item: CdkDrag<I>;
 }
@@ -43,9 +48,11 @@ export interface CdkDragDrop<T, O = T> {
     /** Item that is being dropped. */
     item: CdkDrag;
     /** Container in which the item was dropped. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Container from which the item was picked up. Can be the same as the `container`. */
-    previousContainer: CdkDropListContainer<O>;
+    previousContainer: CdkDropList<O>;
+    /** Whether the user's pointer was over the container when the item was dropped. */
+    isPointerOverContainer: boolean;
 }
 /** Event emitted as the user is dragging a draggable item. */
 export interface CdkDragMove<T = any> {
@@ -76,7 +83,7 @@ export interface CdkDragSortEvent<T = any, I = T> {
     /** Index that the item is currently in. */
     currentIndex: number;
     /** Container that the item belongs to. */
-    container: CdkDropListContainer<T>;
+    container: CdkDropList<T>;
     /** Item that is being sorted. */
     item: CdkDrag<I>;
 }