ngx-bootstrap 3.0.1 → 3.1.4

package/sortable/bundles/ngx-bootstrap-sortable.umd.js

@@ -0,0 +1,464 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('@angular/forms'), require('@angular/common')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/sortable', ['exports', '@angular/core', 'rxjs', '@angular/forms', '@angular/common'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].sortable = {}),global.ng.core,global.rxjs,global.ng.forms,global.ng.common));
+}(this, (function (exports,core,rxjs,forms,common) { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var DraggableItemService = (function () {
+        function DraggableItemService() {
+            this.onCapture = new rxjs.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: core.Injectable }
+        ];
+        return DraggableItemService;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var SortableComponent = (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 core.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 = __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 = __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: core.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: forms.NG_VALUE_ACCESSOR,
+                                useExisting: core.forwardRef(function () { return SortableComponent; }),
+                                multi: true
+                            }
+                        ]
+                    }] }
+        ];
+        /** @nocollapse */
+        SortableComponent.ctorParameters = function () {
+            return [
+                { type: DraggableItemService, },
+            ];
+        };
+        SortableComponent.propDecorators = {
+            "fieldName": [{ type: core.Input },],
+            "wrapperClass": [{ type: core.Input },],
+            "wrapperStyle": [{ type: core.Input },],
+            "itemClass": [{ type: core.Input },],
+            "itemStyle": [{ type: core.Input },],
+            "itemActiveClass": [{ type: core.Input },],
+            "itemActiveStyle": [{ type: core.Input },],
+            "placeholderClass": [{ type: core.Input },],
+            "placeholderStyle": [{ type: core.Input },],
+            "placeholderItem": [{ type: core.Input },],
+            "itemTemplate": [{ type: core.Input },],
+            "onChange": [{ type: core.Output },],
+        };
+        return SortableComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var SortableModule = (function () {
+        function SortableModule() {
+        }
+        /**
+         * @return {?}
+         */
+        SortableModule.forRoot = /**
+         * @return {?}
+         */
+            function () {
+                return { ngModule: SortableModule, providers: [DraggableItemService] };
+            };
+        SortableModule.decorators = [
+            { type: core.NgModule, args: [{
+                        declarations: [SortableComponent],
+                        imports: [common.CommonModule],
+                        exports: [SortableComponent]
+                    },] }
+        ];
+        return SortableModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    exports.SortableModule = SortableModule;
+    exports.SortableComponent = SortableComponent;
+    exports.DraggableItemService = DraggableItemService;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-sortable.umd.js.map","sources":["node_modules/tslib/tslib.es6.js","ng://ngx-bootstrap/sortable/draggable-item.service.ts","ng://ngx-bootstrap/sortable/sortable.component.ts","ng://ngx-bootstrap/sortable/sortable.module.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { DraggableItem } from './draggable-item';\n\n@Injectable()\nexport class DraggableItemService {\n  private draggableItem: DraggableItem;\n\n  private onCapture: Subject<DraggableItem> = new Subject<DraggableItem>();\n\n  dragStart(item: DraggableItem): void {\n    this.draggableItem = item;\n  }\n\n  getItem(): DraggableItem {\n    return this.draggableItem;\n  }\n\n  captureItem(overZoneIndex: number, newIndex: number): DraggableItem {\n    if (this.draggableItem.overZoneIndex !== overZoneIndex) {\n      this.draggableItem.lastZoneIndex = this.draggableItem.overZoneIndex;\n      this.draggableItem.overZoneIndex = overZoneIndex;\n      this.onCapture.next(this.draggableItem);\n      this.draggableItem = Object.assign({}, this.draggableItem, {\n        overZoneIndex,\n        i: newIndex\n      });\n    }\n\n    return this.draggableItem;\n  }\n\n  onCaptureItem(): Subject<DraggableItem> {\n    return this.onCapture;\n  }\n}\n","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","import { NgModule, ModuleWithProviders } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport { SortableComponent } from './sortable.component';\nimport { DraggableItemService } from './draggable-item.service';\n\n@NgModule({\n  declarations: [SortableComponent],\n  imports: [CommonModule],\n  exports: [SortableComponent]\n})\nexport class SortableModule {\n  static forRoot(): ModuleWithProviders {\n    return { ngModule: SortableModule, providers: [DraggableItemService] };\n  }\n}\n"],"names":["Subject","Injectable","EventEmitter","Component","NG_VALUE_ACCESSOR","forwardRef","Input","Output","NgModule","CommonModule"],"mappings":"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"}

package/sortable/bundles/ngx-bootstrap-sortable.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-bootstrap-sortable.umd.js.map","sources":["node_modules/tslib/tslib.es6.js","ng://ngx-bootstrap/sortable/draggable-item.service.ts","ng://ngx-bootstrap/sortable/sortable.component.ts","ng://ngx-bootstrap/sortable/sortable.module.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import { Injectable } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { DraggableItem } from './draggable-item';\n\n@Injectable()\nexport class DraggableItemService {\n  private draggableItem: DraggableItem;\n\n  private onCapture: Subject<DraggableItem> = new Subject<DraggableItem>();\n\n  dragStart(item: DraggableItem): void {\n    this.draggableItem = item;\n  }\n\n  getItem(): DraggableItem {\n    return this.draggableItem;\n  }\n\n  captureItem(overZoneIndex: number, newIndex: number): DraggableItem {\n    if (this.draggableItem.overZoneIndex !== overZoneIndex) {\n      this.draggableItem.lastZoneIndex = this.draggableItem.overZoneIndex;\n      this.draggableItem.overZoneIndex = overZoneIndex;\n      this.onCapture.next(this.draggableItem);\n      this.draggableItem = Object.assign({}, this.draggableItem, {\n        overZoneIndex,\n        i: newIndex\n      });\n    }\n\n    return this.draggableItem;\n  }\n\n  onCaptureItem(): Subject<DraggableItem> {\n    return this.onCapture;\n  }\n}\n","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","import { NgModule, ModuleWithProviders } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nimport { SortableComponent } from './sortable.component';\nimport { DraggableItemService } from './draggable-item.service';\n\n@NgModule({\n  declarations: [SortableComponent],\n  imports: [CommonModule],\n  exports: [SortableComponent]\n})\nexport class SortableModule {\n  static forRoot(): ModuleWithProviders {\n    return { ngModule: SortableModule, providers: [DraggableItemService] };\n  }\n}\n"],"names":["Subject","Injectable","EventEmitter","Component","NG_VALUE_ACCESSOR","forwardRef","Input","Output","NgModule","CommonModule"],"mappings":"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"}

package/sortable/bundles/ngx-bootstrap-sortable.umd.min.js

@@ -0,0 +1,2 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@angular/core"),require("rxjs"),require("@angular/forms"),require("@angular/common")):"function"==typeof define&&define.amd?define("ngx-bootstrap/sortable",["exports","@angular/core","rxjs","@angular/forms","@angular/common"],t):t((e["ngx-bootstrap"]=e["ngx-bootstrap"]||{},e["ngx-bootstrap"].sortable={}),e.ng.core,e.rxjs,e.ng.forms,e.ng.common)}(this,function(e,r,t,i,n){"use strict";function o(e,t){var n="function"==typeof Symbol&&e[Symbol.iterator];if(!n)return e;var r,i,o=n.call(e),a=[];try{for(;(void 0===t||0<t--)&&!(r=o.next()).done;)a.push(r.value)}catch(s){i={error:s}}finally{try{r&&!r.done&&(n=o["return"])&&n.call(o)}finally{if(i)throw i.error}}return a}function a(){for(var e=[],t=0;t<arguments.length;t++)e=e.concat(o(arguments[t]));return e}var s=function(){function e(){this.onCapture=new t.Subject}return e.prototype.dragStart=function(e){this.draggableItem=e},e.prototype.getItem=function(){return this.draggableItem},e.prototype.captureItem=function(e,t){return this.draggableItem.overZoneIndex!==e&&(this.draggableItem.lastZoneIndex=this.draggableItem.overZoneIndex,this.draggableItem.overZoneIndex=e,this.onCapture.next(this.draggableItem),this.draggableItem=Object.assign({},this.draggableItem,{overZoneIndex:e,i:t})),this.draggableItem},e.prototype.onCaptureItem=function(){return this.onCapture},e.decorators=[{type:r.Injectable}],e}(),l=function(){function n(e){var t=this;this.wrapperClass="",this.wrapperStyle={},this.itemClass="",this.itemStyle={},this.itemActiveClass="",this.itemActiveStyle={},this.placeholderClass="",this.placeholderStyle={},this.placeholderItem="",this.onChange=new r.EventEmitter,this.showPlaceholder=!1,this.activeItem=-1,this.onTouched=Function.prototype,this.onChanged=Function.prototype,this.transfer=e,this.currentZoneIndex=n.globalZoneIndex++,this.transfer.onCaptureItem().subscribe(function(e){return t.onDrop(e)})}return Object.defineProperty(n.prototype,"items",{get:function(){return this._items},set:function(e){this._items=e;var t=this.items.map(function(e){return e.initData});this.onChanged(t),this.onChange.emit(t)},enumerable:!0,configurable:!0}),n.prototype.onItemDragstart=function(e,t,n){this.initDragstartEvent(e),this.onTouched(),this.transfer.dragStart({event:e,item:t,i:n,initialIndex:n,lastZoneIndex:this.currentZoneIndex,overZoneIndex:this.currentZoneIndex})},n.prototype.onItemDragover=function(e,t){if(this.transfer.getItem()){e.preventDefault();var n=this.transfer.captureItem(this.currentZoneIndex,this.items.length),r=[];r=this.items.length?n.i>t?a(this.items.slice(0,t),[n.item],this.items.slice(t,n.i),this.items.slice(n.i+1)):a(this.items.slice(0,n.i),this.items.slice(n.i+1,t+1),[n.item],this.items.slice(t+1)):[n.item],this.items=r,n.i=t,this.activeItem=t,this.updatePlaceholderState()}},n.prototype.cancelEvent=function(e){this.transfer.getItem()&&e&&e.preventDefault()},n.prototype.onDrop=function(n){n&&n.overZoneIndex!==this.currentZoneIndex&&n.lastZoneIndex===this.currentZoneIndex&&(this.items=this.items.filter(function(e,t){return t!==n.i}),this.updatePlaceholderState()),this.resetActiveItem(undefined)},n.prototype.resetActiveItem=function(e){this.cancelEvent(e),this.activeItem=-1},n.prototype.registerOnChange=function(e){this.onChanged=e},n.prototype.registerOnTouched=function(e){this.onTouched=e},n.prototype.writeValue=function(e){var n=this;this.items=e?e.map(function(e,t){return{id:t,initData:e,value:n.fieldName?e[n.fieldName]:e}}):[],this.updatePlaceholderState()},n.prototype.updatePlaceholderState=function(){this.showPlaceholder=!this._items.length},n.prototype.getItemStyle=function(e){return e?Object.assign({},this.itemStyle,this.itemActiveStyle):this.itemStyle},n.prototype.initDragstartEvent=function(e){e.dataTransfer.setData("Text","placeholder")},n.globalZoneIndex=0,n.decorators=[{type:r.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:i.NG_VALUE_ACCESSOR,useExisting:r.forwardRef(function(){return n}),multi:!0}]}]}],n.ctorParameters=function(){return[{type:s}]},n.propDecorators={fieldName:[{type:r.Input}],wrapperClass:[{type:r.Input}],wrapperStyle:[{type:r.Input}],itemClass:[{type:r.Input}],itemStyle:[{type:r.Input}],itemActiveClass:[{type:r.Input}],itemActiveStyle:[{type:r.Input}],placeholderClass:[{type:r.Input}],placeholderStyle:[{type:r.Input}],placeholderItem:[{type:r.Input}],itemTemplate:[{type:r.Input}],onChange:[{type:r.Output}]},n}(),p=function(){function e(){}return e.forRoot=function(){return{ngModule:e,providers:[s]}},e.decorators=[{type:r.NgModule,args:[{declarations:[l],imports:[n.CommonModule],exports:[l]}]}],e}();e.SortableModule=p,e.SortableComponent=l,e.DraggableItemService=s,Object.defineProperty(e,"__esModule",{value:!0})});
+//# sourceMappingURL=ngx-bootstrap-sortable.umd.min.js.map