ngx-bootstrap 3.0.1 → 3.1.4

package/sortable/esm5/draggable-item.service.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+var DraggableItemService = /** @class */ (function () {
+    function DraggableItemService() {
+        this.onCapture = new Subject();
+    }
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    DraggableItemService.prototype.dragStart = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        this.draggableItem = item;
+    };
+    /**
+     * @return {?}
+     */
+    DraggableItemService.prototype.getItem = /**
+     * @return {?}
+     */
+    function () {
+        return this.draggableItem;
+    };
+    /**
+     * @param {?} overZoneIndex
+     * @param {?} newIndex
+     * @return {?}
+     */
+    DraggableItemService.prototype.captureItem = /**
+     * @param {?} overZoneIndex
+     * @param {?} newIndex
+     * @return {?}
+     */
+    function (overZoneIndex, newIndex) {
+        if (this.draggableItem.overZoneIndex !== overZoneIndex) {
+            this.draggableItem.lastZoneIndex = this.draggableItem.overZoneIndex;
+            this.draggableItem.overZoneIndex = overZoneIndex;
+            this.onCapture.next(this.draggableItem);
+            this.draggableItem = Object.assign({}, this.draggableItem, {
+                overZoneIndex: overZoneIndex,
+                i: newIndex
+            });
+        }
+        return this.draggableItem;
+    };
+    /**
+     * @return {?}
+     */
+    DraggableItemService.prototype.onCaptureItem = /**
+     * @return {?}
+     */
+    function () {
+        return this.onCapture;
+    };
+    DraggableItemService.decorators = [
+        { type: Injectable }
+    ];
+    return DraggableItemService;
+}());
+export { DraggableItemService };
+function DraggableItemService_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    DraggableItemService.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    DraggableItemService.ctorParameters;
+    /** @type {?} */
+    DraggableItemService.prototype.draggableItem;
+    /** @type {?} */
+    DraggableItemService.prototype.onCapture;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/sortable/esm5/ngx-bootstrap-sortable.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { SortableModule, SortableComponent, DraggableItemService } from './public_api';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWJvb3RzdHJhcC1zb3J0YWJsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvc29ydGFibGUvIiwic291cmNlcyI6WyJuZ3gtYm9vdHN0cmFwLXNvcnRhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSx3RUFBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/sortable/esm5/public_api.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { SortableModule } from './sortable.module';
+export { SortableComponent } from './sortable.component';
+export { DraggableItemService } from './draggable-item.service';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvc29ydGFibGUvIiwic291cmNlcyI6WyJwdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFnQixNQUFNLHNCQUFzQixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgU29ydGFibGVNb2R1bGUgfSBmcm9tICcuL3NvcnRhYmxlLm1vZHVsZSc7XG5leHBvcnQgeyBTb3J0YWJsZUNvbXBvbmVudCwgU29ydGFibGVJdGVtIH0gZnJvbSAnLi9zb3J0YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0IHsgRHJhZ2dhYmxlSXRlbVNlcnZpY2UgfSBmcm9tICcuL2RyYWdnYWJsZS1pdGVtLnNlcnZpY2UnO1xuZXhwb3J0IHsgRHJhZ2dhYmxlSXRlbSB9IGZyb20gJy4vZHJhZ2dhYmxlLWl0ZW0nO1xuIl19

package/sortable/esm5/sortable.component.js

@@ -0,0 +1,398 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, Input, Output, EventEmitter, forwardRef, TemplateRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { DraggableItemService } from './draggable-item.service';
+var SortableComponent = /** @class */ (function () {
+    function SortableComponent(transfer) {
+        var _this = this;
+        /**
+         * class name for items wrapper
+         */
+        this.wrapperClass = '';
+        /**
+         * style object for items wrapper
+         */
+        this.wrapperStyle = {};
+        /**
+         * class name for item
+         */
+        this.itemClass = '';
+        /**
+         * style object for item
+         */
+        this.itemStyle = {};
+        /**
+         * class name for active item
+         */
+        this.itemActiveClass = '';
+        /**
+         * style object for active item
+         */
+        this.itemActiveStyle = {};
+        /**
+         * class name for placeholder
+         */
+        this.placeholderClass = '';
+        /**
+         * style object for placeholder
+         */
+        this.placeholderStyle = {};
+        /**
+         * placeholder item which will be shown if collection is empty
+         */
+        this.placeholderItem = '';
+        /**
+         * fired on array change (reordering, insert, remove), same as <code>ngModelChange</code>.
+         *  Returns new items collection as a payload.
+         */
+        this.onChange = new EventEmitter();
+        this.showPlaceholder = false;
+        this.activeItem = -1;
+        /* tslint:disable-next-line: no-any */
+        this.onTouched = Function.prototype;
+        /* tslint:disable-next-line: no-any */
+        this.onChanged = Function.prototype;
+        this.transfer = transfer;
+        this.currentZoneIndex = SortableComponent.globalZoneIndex++;
+        this.transfer
+            .onCaptureItem()
+            .subscribe(function (item) { return _this.onDrop(item); });
+    }
+    Object.defineProperty(SortableComponent.prototype, "items", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._items;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._items = value;
+            var /** @type {?} */ out = this.items.map(function (x) { return x.initData; });
+            this.onChanged(out);
+            this.onChange.emit(out);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} event
+     * @param {?} item
+     * @param {?} i
+     * @return {?}
+     */
+    SortableComponent.prototype.onItemDragstart = /**
+     * @param {?} event
+     * @param {?} item
+     * @param {?} i
+     * @return {?}
+     */
+    function (event, item, i) {
+        this.initDragstartEvent(event);
+        this.onTouched();
+        this.transfer.dragStart({
+            event: event,
+            item: item,
+            i: i,
+            initialIndex: i,
+            lastZoneIndex: this.currentZoneIndex,
+            overZoneIndex: this.currentZoneIndex
+        });
+    };
+    /**
+     * @param {?} event
+     * @param {?} i
+     * @return {?}
+     */
+    SortableComponent.prototype.onItemDragover = /**
+     * @param {?} event
+     * @param {?} i
+     * @return {?}
+     */
+    function (event, i) {
+        if (!this.transfer.getItem()) {
+            return;
+        }
+        event.preventDefault();
+        var /** @type {?} */ dragItem = this.transfer.captureItem(this.currentZoneIndex, this.items.length);
+        /* tslint:disable-next-line: no-any */
+        var /** @type {?} */ newArray = [];
+        if (!this.items.length) {
+            newArray = [dragItem.item];
+        }
+        else if (dragItem.i > i) {
+            newArray = tslib_1.__spread(this.items.slice(0, i), [
+                dragItem.item
+            ], this.items.slice(i, dragItem.i), this.items.slice(dragItem.i + 1));
+        }
+        else {
+            // this.draggedItem.i < i
+            newArray = tslib_1.__spread(this.items.slice(0, dragItem.i), this.items.slice(dragItem.i + 1, i + 1), [
+                dragItem.item
+            ], this.items.slice(i + 1));
+        }
+        this.items = newArray;
+        dragItem.i = i;
+        this.activeItem = i;
+        this.updatePlaceholderState();
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    SortableComponent.prototype.cancelEvent = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        if (!this.transfer.getItem() || !event) {
+            return;
+        }
+        event.preventDefault();
+    };
+    /**
+     * @param {?} item
+     * @return {?}
+     */
+    SortableComponent.prototype.onDrop = /**
+     * @param {?} item
+     * @return {?}
+     */
+    function (item) {
+        if (item &&
+            item.overZoneIndex !== this.currentZoneIndex &&
+            item.lastZoneIndex === this.currentZoneIndex) {
+            this.items = this.items.filter(function (x, i) { return i !== item.i; });
+            this.updatePlaceholderState();
+        }
+        this.resetActiveItem(undefined);
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    SortableComponent.prototype.resetActiveItem = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        this.cancelEvent(event);
+        this.activeItem = -1;
+    };
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    SortableComponent.prototype.registerOnChange = /**
+     * @param {?} callback
+     * @return {?}
+     */
+    function (callback) {
+        this.onChanged = callback;
+    };
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    SortableComponent.prototype.registerOnTouched = /**
+     * @param {?} callback
+     * @return {?}
+     */
+    function (callback) {
+        this.onTouched = callback;
+    };
+    /* tslint:disable-next-line: no-any */
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    SortableComponent.prototype.writeValue = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        var _this = this;
+        if (value) {
+            /* tslint:disable-next-line: no-any */
+            this.items = value.map(function (x, i) {
+                return ({
+                    id: i,
+                    initData: x,
+                    value: _this.fieldName ? x[_this.fieldName] : x
+                });
+            });
+        }
+        else {
+            this.items = [];
+        }
+        this.updatePlaceholderState();
+    };
+    /**
+     * @return {?}
+     */
+    SortableComponent.prototype.updatePlaceholderState = /**
+     * @return {?}
+     */
+    function () {
+        this.showPlaceholder = !this._items.length;
+    };
+    /**
+     * @param {?} isActive
+     * @return {?}
+     */
+    SortableComponent.prototype.getItemStyle = /**
+     * @param {?} isActive
+     * @return {?}
+     */
+    function (isActive) {
+        return isActive
+            ? Object.assign({}, this.itemStyle, this.itemActiveStyle)
+            : this.itemStyle;
+    };
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    SortableComponent.prototype.initDragstartEvent = /**
+     * @param {?} event
+     * @return {?}
+     */
+    function (event) {
+        // it is necessary for mozilla
+        // data type should be 'Text' instead of 'text/plain' to keep compatibility
+        // with IE
+        event.dataTransfer.setData('Text', 'placeholder');
+    };
+    SortableComponent.globalZoneIndex = 0;
+    SortableComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'bs-sortable',
+                    exportAs: 'bs-sortable',
+                    template: "\n<div\n    [ngClass]=\"wrapperClass\"\n    [ngStyle]=\"wrapperStyle\"\n    [ngStyle]=\"wrapperStyle\"\n    (dragover)=\"cancelEvent($event)\"\n    (dragenter)=\"cancelEvent($event)\"\n    (drop)=\"resetActiveItem($event)\"\n    (mouseleave)=\"resetActiveItem($event)\">\n  <div\n        *ngIf=\"showPlaceholder\"\n        [ngClass]=\"placeholderClass\"\n        [ngStyle]=\"placeholderStyle\"\n        (dragover)=\"onItemDragover($event, 0)\"\n        (dragenter)=\"cancelEvent($event)\"\n    >{{placeholderItem}}</div>\n    <div\n        *ngFor=\"let item of items; let i=index;\"\n        [ngClass]=\"[ itemClass, i === activeItem ? itemActiveClass : '' ]\"\n        [ngStyle]=\"getItemStyle(i === activeItem)\"\n        draggable=\"true\"\n        (dragstart)=\"onItemDragstart($event, item, i)\"\n        (dragend)=\"resetActiveItem($event)\"\n        (dragover)=\"onItemDragover($event, i)\"\n        (dragenter)=\"cancelEvent($event)\"\n        aria-dropeffect=\"move\"\n        [attr.aria-grabbed]=\"i === activeItem\"\n    ><ng-template [ngTemplateOutlet]=\"itemTemplate || defItemTemplate\"\n  [ngTemplateOutletContext]=\"{item:item, index: i}\"></ng-template></div>\n</div>\n\n<ng-template #defItemTemplate let-item=\"item\">{{item.value}}</ng-template>  \n",
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(function () { return SortableComponent; }),
+                            multi: true
+                        }
+                    ]
+                }] }
+    ];
+    /** @nocollapse */
+    SortableComponent.ctorParameters = function () { return [
+        { type: DraggableItemService, },
+    ]; };
+    SortableComponent.propDecorators = {
+        "fieldName": [{ type: Input },],
+        "wrapperClass": [{ type: Input },],
+        "wrapperStyle": [{ type: Input },],
+        "itemClass": [{ type: Input },],
+        "itemStyle": [{ type: Input },],
+        "itemActiveClass": [{ type: Input },],
+        "itemActiveStyle": [{ type: Input },],
+        "placeholderClass": [{ type: Input },],
+        "placeholderStyle": [{ type: Input },],
+        "placeholderItem": [{ type: Input },],
+        "itemTemplate": [{ type: Input },],
+        "onChange": [{ type: Output },],
+    };
+    return SortableComponent;
+}());
+export { SortableComponent };
+function SortableComponent_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    SortableComponent.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    SortableComponent.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    SortableComponent.propDecorators;
+    /** @type {?} */
+    SortableComponent.globalZoneIndex;
+    /**
+     * field name if input array consists of objects
+     * @type {?}
+     */
+    SortableComponent.prototype.fieldName;
+    /**
+     * class name for items wrapper
+     * @type {?}
+     */
+    SortableComponent.prototype.wrapperClass;
+    /**
+     * style object for items wrapper
+     * @type {?}
+     */
+    SortableComponent.prototype.wrapperStyle;
+    /**
+     * class name for item
+     * @type {?}
+     */
+    SortableComponent.prototype.itemClass;
+    /**
+     * style object for item
+     * @type {?}
+     */
+    SortableComponent.prototype.itemStyle;
+    /**
+     * class name for active item
+     * @type {?}
+     */
+    SortableComponent.prototype.itemActiveClass;
+    /**
+     * style object for active item
+     * @type {?}
+     */
+    SortableComponent.prototype.itemActiveStyle;
+    /**
+     * class name for placeholder
+     * @type {?}
+     */
+    SortableComponent.prototype.placeholderClass;
+    /**
+     * style object for placeholder
+     * @type {?}
+     */
+    SortableComponent.prototype.placeholderStyle;
+    /**
+     * placeholder item which will be shown if collection is empty
+     * @type {?}
+     */
+    SortableComponent.prototype.placeholderItem;
+    /**
+     * used to specify a custom item template. Template variables: item and index;
+     * @type {?}
+     */
+    SortableComponent.prototype.itemTemplate;
+    /**
+     * fired on array change (reordering, insert, remove), same as <code>ngModelChange</code>.
+     *  Returns new items collection as a payload.
+     * @type {?}
+     */
+    SortableComponent.prototype.onChange;
+    /** @type {?} */
+    SortableComponent.prototype.showPlaceholder;
+    /** @type {?} */
+    SortableComponent.prototype.activeItem;
+    /** @type {?} */
+    SortableComponent.prototype.onTouched;
+    /** @type {?} */
+    SortableComponent.prototype.onChanged;
+    /** @type {?} */
+    SortableComponent.prototype.transfer;
+    /** @type {?} */
+    SortableComponent.prototype.currentZoneIndex;
+    /** @type {?} */
+    SortableComponent.prototype._items;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sortable.component.js","sourceRoot":"ng://ngx-bootstrap/sortable/","sources":["sortable.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  forwardRef,\n  TemplateRef\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { DraggableItem } from './draggable-item';\nimport { DraggableItemService } from './draggable-item.service';\n\n/* tslint:disable */\n@Component({\n  selector: 'bs-sortable',\n  exportAs: 'bs-sortable',\n  template: `\n<div\n    [ngClass]=\"wrapperClass\"\n    [ngStyle]=\"wrapperStyle\"\n    [ngStyle]=\"wrapperStyle\"\n    (dragover)=\"cancelEvent($event)\"\n    (dragenter)=\"cancelEvent($event)\"\n    (drop)=\"resetActiveItem($event)\"\n    (mouseleave)=\"resetActiveItem($event)\">\n  <div\n        *ngIf=\"showPlaceholder\"\n        [ngClass]=\"placeholderClass\"\n        [ngStyle]=\"placeholderStyle\"\n        (dragover)=\"onItemDragover($event, 0)\"\n        (dragenter)=\"cancelEvent($event)\"\n    >{{placeholderItem}}</div>\n    <div\n        *ngFor=\"let item of items; let i=index;\"\n        [ngClass]=\"[ itemClass, i === activeItem ? itemActiveClass : '' ]\"\n        [ngStyle]=\"getItemStyle(i === activeItem)\"\n        draggable=\"true\"\n        (dragstart)=\"onItemDragstart($event, item, i)\"\n        (dragend)=\"resetActiveItem($event)\"\n        (dragover)=\"onItemDragover($event, i)\"\n        (dragenter)=\"cancelEvent($event)\"\n        aria-dropeffect=\"move\"\n        [attr.aria-grabbed]=\"i === activeItem\"\n    ><ng-template [ngTemplateOutlet]=\"itemTemplate || defItemTemplate\"\n  [ngTemplateOutletContext]=\"{item:item, index: i}\"></ng-template></div>\n</div>\n\n<ng-template #defItemTemplate let-item=\"item\">{{item.value}}</ng-template>  \n`,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SortableComponent),\n      multi: true\n    }\n  ]\n})\n/* tslint:enable */\nexport class SortableComponent implements ControlValueAccessor {\n  private static globalZoneIndex = 0;\n  /** field name if input array consists of objects */\n  @Input() fieldName: string;\n\n  /** class name for items wrapper */\n  @Input() wrapperClass = '';\n\n  /** style object for items wrapper */\n  @Input() wrapperStyle: { [key: string]: string } = {};\n\n  /** class name for item */\n  @Input() itemClass = '';\n\n  /** style object for item */\n  @Input() itemStyle: { [key: string]: string } = {};\n\n  /** class name for active item */\n  @Input() itemActiveClass = '';\n\n  /** style object for active item */\n  @Input() itemActiveStyle: { [key: string]: string } = {};\n\n  /** class name for placeholder */\n  @Input() placeholderClass = '';\n\n  /** style object for placeholder */\n  @Input() placeholderStyle: { [key: string]: string } = {};\n\n  /** placeholder item which will be shown if collection is empty */\n  @Input() placeholderItem = '';\n\n  /** used to specify a custom item template. Template variables: item and index; */\n  /* tslint:disable-next-line: no-any */\n  @Input() itemTemplate: TemplateRef<any>;\n\n  /** fired on array change (reordering, insert, remove), same as <code>ngModelChange</code>.\n   *  Returns new items collection as a payload.\n   */\n  /* tslint:disable-next-line: no-any */\n  @Output() onChange: EventEmitter<any[]> = new EventEmitter<any[]>();\n\n  showPlaceholder = false;\n  activeItem = -1;\n\n  get items(): SortableItem[] {\n    return this._items;\n  }\n\n  set items(value: SortableItem[]) {\n    this._items = value;\n    const out = this.items.map((x: SortableItem) => x.initData);\n    this.onChanged(out);\n    this.onChange.emit(out);\n  }\n\n  /* tslint:disable-next-line: no-any */\n  onTouched: any = Function.prototype;\n  /* tslint:disable-next-line: no-any */\n  onChanged: any = Function.prototype;\n\n  private transfer: DraggableItemService;\n  private currentZoneIndex: number;\n  private _items: SortableItem[];\n\n  constructor(transfer: DraggableItemService) {\n    this.transfer = transfer;\n    this.currentZoneIndex = SortableComponent.globalZoneIndex++;\n    this.transfer\n      .onCaptureItem()\n      .subscribe((item: DraggableItem) => this.onDrop(item));\n  }\n\n  onItemDragstart(\n    event: DragEvent,\n    item: SortableItem,\n    i: number\n  ): void {\n    this.initDragstartEvent(event);\n    this.onTouched();\n    this.transfer.dragStart({\n      event,\n      item,\n      i,\n      initialIndex: i,\n      lastZoneIndex: this.currentZoneIndex,\n      overZoneIndex: this.currentZoneIndex\n    });\n  }\n\n  onItemDragover(event: DragEvent, i: number): void {\n    if (!this.transfer.getItem()) {\n      return;\n    }\n    event.preventDefault();\n    const dragItem = this.transfer.captureItem(\n      this.currentZoneIndex,\n      this.items.length\n    );\n\n    /* tslint:disable-next-line: no-any */\n    let newArray: any[] = [];\n\n    if (!this.items.length) {\n      newArray = [dragItem.item];\n    } else if (dragItem.i > i) {\n      newArray = [\n        ...this.items.slice(0, i),\n        dragItem.item,\n        ...this.items.slice(i, dragItem.i),\n        ...this.items.slice(dragItem.i + 1)\n      ];\n    } else {\n      // this.draggedItem.i < i\n      newArray = [\n        ...this.items.slice(0, dragItem.i),\n        ...this.items.slice(dragItem.i + 1, i + 1),\n        dragItem.item,\n        ...this.items.slice(i + 1)\n      ];\n    }\n    this.items = newArray;\n    dragItem.i = i;\n    this.activeItem = i;\n    this.updatePlaceholderState();\n  }\n\n  cancelEvent(event: DragEvent): void {\n    if (!this.transfer.getItem() || !event) {\n      return;\n    }\n    event.preventDefault();\n  }\n\n  onDrop(item: DraggableItem): void {\n    if (\n      item &&\n      item.overZoneIndex !== this.currentZoneIndex &&\n      item.lastZoneIndex === this.currentZoneIndex\n    ) {\n      this.items = this.items.filter(\n        (x: SortableItem, i: number) => i !== item.i\n      );\n      this.updatePlaceholderState();\n    }\n    this.resetActiveItem(undefined);\n  }\n\n  resetActiveItem(event: DragEvent): void {\n    this.cancelEvent(event);\n    this.activeItem = -1;\n  }\n\n  registerOnChange(callback: () => void): void {\n    this.onChanged = callback;\n  }\n\n  registerOnTouched(callback: () => void): void {\n    this.onTouched = callback;\n  }\n\n  /* tslint:disable-next-line: no-any */\n  writeValue(value: any[]): void {\n    if (value) {\n      /* tslint:disable-next-line: no-any */\n      this.items = value.map((x: any, i: number) => ({\n        id: i,\n        initData: x,\n        value: this.fieldName ? x[this.fieldName] : x\n      }));\n    } else {\n      this.items = [];\n    }\n    this.updatePlaceholderState();\n  }\n\n  updatePlaceholderState(): void {\n    this.showPlaceholder = !this._items.length;\n  }\n\n  getItemStyle(isActive: boolean): {} {\n    return isActive\n      ? Object.assign({}, this.itemStyle, this.itemActiveStyle)\n      : this.itemStyle;\n  }\n\n  // tslint:disable-next-line\n  private initDragstartEvent(event: DragEvent): void {\n    // it is necessary for mozilla\n    // data type should be 'Text' instead of 'text/plain' to keep compatibility\n    // with IE\n    event.dataTransfer.setData('Text', 'placeholder');\n  }\n}\n\nexport declare interface SortableItem {\n  id: number;\n  value: string;\n  /* tslint:disable-next-line: no-any */\n  initData: any;\n}\n"]}

package/sortable/esm5/sortable.module.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SortableComponent } from './sortable.component';
+import { DraggableItemService } from './draggable-item.service';
+var SortableModule = /** @class */ (function () {
+    function SortableModule() {
+    }
+    /**
+     * @return {?}
+     */
+    SortableModule.forRoot = /**
+     * @return {?}
+     */
+    function () {
+        return { ngModule: SortableModule, providers: [DraggableItemService] };
+    };
+    SortableModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [SortableComponent],
+                    imports: [CommonModule],
+                    exports: [SortableComponent]
+                },] }
+    ];
+    return SortableModule;
+}());
+export { SortableModule };
+function SortableModule_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    SortableModule.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    SortableModule.ctorParameters;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydGFibGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LWJvb3RzdHJhcC9zb3J0YWJsZS8iLCJzb3VyY2VzIjpbInNvcnRhYmxlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsT0FBTyxFQUFFLFFBQVEsRUFBdUIsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRS9DLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDOzs7Ozs7O0lBUXZELHNCQUFPOzs7SUFBZDtRQUNFLE1BQU0sQ0FBQyxFQUFFLFFBQVEsRUFBRSxjQUFjLEVBQUUsU0FBUyxFQUFFLENBQUMsb0JBQW9CLENBQUMsRUFBRSxDQUFDO0tBQ3hFOztnQkFSRixRQUFRLFNBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsaUJBQWlCLENBQUM7b0JBQ2pDLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsaUJBQWlCLENBQUM7aUJBQzdCOzt5QkFWRDs7U0FXYSxjQUFjIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbmltcG9ydCB7IFNvcnRhYmxlQ29tcG9uZW50IH0gZnJvbSAnLi9zb3J0YWJsZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgRHJhZ2dhYmxlSXRlbVNlcnZpY2UgfSBmcm9tICcuL2RyYWdnYWJsZS1pdGVtLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTb3J0YWJsZUNvbXBvbmVudF0sXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBleHBvcnRzOiBbU29ydGFibGVDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIFNvcnRhYmxlTW9kdWxlIHtcbiAgc3RhdGljIGZvclJvb3QoKTogTW9kdWxlV2l0aFByb3ZpZGVycyB7XG4gICAgcmV0dXJuIHsgbmdNb2R1bGU6IFNvcnRhYmxlTW9kdWxlLCBwcm92aWRlcnM6IFtEcmFnZ2FibGVJdGVtU2VydmljZV0gfTtcbiAgfVxufVxuIl19