@progress/kendo-angular-menu 3.0.6 → 4.0.0-next.202203230842

package/dist/es/services/actions.service.js

@@ -1,178 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { NgZone, Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { MenuEvent } from '../menu-event';
-import { hasObservers } from '@progress/kendo-angular-common';
-var canPerformAction = function (item, action) {
-    return !((action === 'open' && item.opened) || (action === 'close' && !item.opened));
-};
-var ɵ0 = canPerformAction;
-/**
- * @hidden
- */
-var ActionsService = /** @class */ (function () {
-    function ActionsService(ngZone, items) {
-        this.ngZone = ngZone;
-        this.items = items;
-        this.actions = [];
-    }
-    ActionsService.prototype.open = function (item, finished) {
-        if (item.disabled) {
-            return;
-        }
-        if (item.hasContent && !item.opened) {
-            this.actions.push({
-                name: 'open',
-                requiresZone: item.hasContentTemplates(),
-                item: item,
-                finished: finished
-            });
-        }
-        else if (finished) {
-            finished();
-        }
-    };
-    ActionsService.prototype.close = function (item) {
-        this.closeChildren(item);
-        this.closeItem(item);
-    };
-    ActionsService.prototype.closeItem = function (item) {
-        if (item.opened) {
-            this.actions.push({
-                name: 'close',
-                item: item
-            });
-        }
-    };
-    ActionsService.prototype.closeToRoot = function (item) {
-        this.closeChildren(item);
-        var current = item;
-        do {
-            this.closeItem(current);
-            current = this.items.parent(current);
-        } while (current);
-    };
-    ActionsService.prototype.closeOthers = function (item) {
-        this.closeChildren(item);
-        var current = item;
-        while (current) {
-            var siblings = this.items.otherSiblings(current);
-            this.closeItems(siblings);
-            current = this.items.parent(current);
-        }
-    };
-    ActionsService.prototype.closeAll = function () {
-        var _this = this;
-        this.items.forEach(function (item) {
-            if (item.opened && item.level === 0) {
-                _this.close(item);
-            }
-        });
-    };
-    ActionsService.prototype.select = function (item, domEvent, prevented, finished) {
-        this.actions.push({
-            name: 'select',
-            item: item,
-            prevented: prevented,
-            finished: finished,
-            domEvent: domEvent
-        });
-    };
-    ActionsService.prototype.emit = function (name, item, domEvent) {
-        var owner = this.owner;
-        var eventArgs = new MenuEvent({
-            sender: owner,
-            item: item.item,
-            index: item.index,
-            originalEvent: domEvent,
-            hasContent: item.hasContent
-        });
-        owner[name].emit(eventArgs);
-        if (owner.contextService) {
-            owner.contextService.emit(name, eventArgs);
-        }
-        return eventArgs.isDefaultPrevented();
-    };
-    Object.defineProperty(ActionsService.prototype, "hasPending", {
-        get: function () {
-            return this.actions.length > 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ActionsService.prototype.execute = function (toExecute) {
-        var _this = this;
-        if (!this.hasPending && !toExecute) {
-            return;
-        }
-        var actions = toExecute || this.clear();
-        if (!NgZone.isInAngularZone() && this.requiresZone(actions)) {
-            this.ngZone.run(function () {
-                _this.executeActions(actions);
-            });
-        }
-        else {
-            this.executeActions(actions);
-        }
-    };
-    ActionsService.prototype.clear = function () {
-        var actions = this.actions;
-        this.actions = [];
-        return actions;
-    };
-    ActionsService.prototype.executeActions = function (actions) {
-        for (var idx = 0; idx < actions.length; idx++) {
-            var _a = actions[idx], item = _a.item, name_1 = _a.name, prevented = _a.prevented, finished = _a.finished, domEvent = _a.domEvent;
-            if (!canPerformAction(item, name_1)) {
-                continue;
-            }
-            if (!this.emit(name_1, item, domEvent)) {
-                if (item[name_1]) {
-                    item[name_1]();
-                }
-                if (finished) {
-                    finished();
-                }
-            }
-            else if (prevented) {
-                prevented();
-            }
-        }
-    };
-    ActionsService.prototype.requiresZone = function (toExecute) {
-        var actions = toExecute || this.actions;
-        var owner = this.owner;
-        var contextService = owner.contextService;
-        for (var idx = 0; idx < actions.length; idx++) {
-            var action = actions[idx];
-            var name_2 = action.name;
-            if (action.requiresZone || (name_2 && (hasObservers(owner[name_2]) || (contextService && contextService.hasObservers(name_2))))) {
-                return true;
-            }
-        }
-        return false;
-    };
-    ActionsService.prototype.closeChildren = function (item) {
-        if (!item.opened) {
-            return;
-        }
-        var children = this.items.children(item);
-        this.closeItems(children);
-    };
-    ActionsService.prototype.closeItems = function (items) {
-        for (var idx = 0; idx < items.length; idx++) {
-            this.close(items[idx]);
-        }
-    };
-    ActionsService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [NgZone, ItemsService])
-    ], ActionsService);
-    return ActionsService;
-}());
-export { ActionsService };
-export { ɵ0 };

package/dist/es/services/hover.service.js

@@ -1,136 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { ActionsService } from './actions.service';
-var DISABLE_OPEN_ON_OVER_DELAY = 500;
-/**
- * @hidden
- */
-var HoverService = /** @class */ (function () {
-    function HoverService(actions, items) {
-        this.actions = actions;
-        this.items = items;
-        this.delay = 100;
-        this._openOnOver = true;
-        this.scheduled = [];
-    }
-    Object.defineProperty(HoverService.prototype, "openOnOver", {
-        get: function () {
-            return this._openOnOver;
-        },
-        set: function (value) {
-            this.cancelActions();
-            this._openOnOver = value;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(HoverService.prototype, "hovered", {
-        get: function () {
-            return this.items.get(this.hoveredIdx);
-        },
-        set: function (item) {
-            this.hoveredIdx = item ? item.index : null;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    HoverService.prototype.ngOnDestroy = function () {
-        this.cancelActions();
-    };
-    HoverService.prototype.over = function (item) {
-        var _this = this;
-        this.cancelActions(function (action) { return action.name === 'openOnOver'; });
-        if (!this.hovered || this.hovered !== item) {
-            this.actions.closeOthers(item);
-            this.hovered = item;
-            if ((item.level > 0 || this.openOnOver) && !item.disabled) {
-                this.actions.open(item);
-                this.cancelActions(function (action) {
-                    return (action.name === 'close' && (item === action.item || _this.items.hasParent(item, action.item))) ||
-                        (action.name === 'open' && !_this.items.hasParent(item, action.item));
-                });
-            }
-            this.scheduleActions();
-        }
-    };
-    HoverService.prototype.leave = function (disableOpenOnOver) {
-        var hovered = this.hovered;
-        if (hovered) {
-            this.actions.closeToRoot(hovered);
-            this.cancelActions(function (action) { return action.name === 'open'; });
-            this.scheduleActions();
-        }
-        if (disableOpenOnOver && this._openOnOver) {
-            this.scheduleDisableOpenOnOver();
-        }
-        this.hovered = null;
-    };
-    HoverService.prototype.closeCurrent = function () {
-        var hovered = this.hovered;
-        if (hovered) {
-            this.actions.closeToRoot(hovered);
-            this.hovered = null;
-        }
-    };
-    HoverService.prototype.scheduleActions = function () {
-        var _this = this;
-        if (this.actions.hasPending) {
-            var item_1 = {};
-            item_1.actions = this.actions.clear();
-            item_1.id = setTimeout(function () {
-                _this.actions.execute(item_1.actions);
-                _this.removeScheduled(item_1);
-            }, this.delay);
-            this.scheduled.push(item_1);
-        }
-    };
-    HoverService.prototype.scheduleDisableOpenOnOver = function () {
-        var _this = this;
-        var item = {
-            actions: [{ name: 'openOnOver' }]
-        };
-        item.id = setTimeout(function () {
-            _this._openOnOver = false;
-            _this.removeScheduled(item);
-        }, Math.max(this.delay, DISABLE_OPEN_ON_OVER_DELAY));
-        this.scheduled.push(item);
-    };
-    HoverService.prototype.removeScheduled = function (item) {
-        var scheduled = this.scheduled;
-        for (var idx = 0; idx < scheduled.length; idx++) {
-            if (scheduled[idx] === item) {
-                scheduled.splice(idx, 1);
-                return;
-            }
-        }
-    };
-    HoverService.prototype.cancelActions = function (predicate) {
-        var scheduled = this.scheduled;
-        for (var idx = scheduled.length - 1; idx >= 0; idx--) {
-            var item = scheduled[idx];
-            var actions = item.actions;
-            if (predicate) {
-                for (var actionIdx = actions.length - 1; actionIdx >= 0; actionIdx--) {
-                    if (predicate(actions[actionIdx])) {
-                        actions.splice(actionIdx, 1);
-                    }
-                }
-            }
-            if (!predicate || actions.length === 0) {
-                clearTimeout(item.id);
-                scheduled.splice(idx, 1);
-            }
-        }
-    };
-    HoverService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [ActionsService, ItemsService])
-    ], HoverService);
-    return HoverService;
-}());
-export { HoverService };

package/dist/es/services/items.service.js

@@ -1,140 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable } from '@angular/core';
-var PARENT_REGEX = /_?\d+$/;
-var SEPARATOR = '_';
-var id = 0;
-var itemIndexComparer = function (a, b) { return a.siblingIndex - b.siblingIndex; };
-var ɵ0 = itemIndexComparer;
-var next = function (idx, items, dir) {
-    var current = items[idx + dir];
-    while (!current) {
-        if (idx < 0) {
-            idx = items.length - 1;
-        }
-        else if (idx >= items.length) {
-            idx = 0;
-        }
-        else {
-            idx += dir;
-        }
-        current = items[idx];
-    }
-    return current;
-};
-var ɵ1 = next;
-/**
- * @hidden
- */
-var ItemsService = /** @class */ (function () {
-    function ItemsService() {
-        this.items = {};
-        this.lists = [];
-        this.idPrefix = "k-menu" + id++;
-    }
-    Object.defineProperty(ItemsService.prototype, "hasItems", {
-        get: function () {
-            return Object.keys(this.items).length > 0;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ItemsService.prototype.childId = function (index) {
-        return this.idPrefix + "-child" + index;
-    };
-    ItemsService.prototype.itemIndex = function (parentIndex, index) {
-        return (parentIndex ? parentIndex + SEPARATOR : '') + index;
-    };
-    ItemsService.prototype.get = function (index) {
-        return this.items[index];
-    };
-    ItemsService.prototype.add = function (item) {
-        this.items[item.index] = item;
-    };
-    ItemsService.prototype.remove = function (item) {
-        if (this.items[item.index] === item) {
-            delete this.items[item.index];
-        }
-    };
-    ItemsService.prototype.addList = function (list) {
-        this.lists.push(list);
-    };
-    ItemsService.prototype.removeList = function (list) {
-        var index = this.lists.indexOf(list);
-        if (index >= 0) {
-            this.lists.splice(index, 1);
-        }
-    };
-    ItemsService.prototype.containsList = function (element) {
-        return Boolean(this.lists.find(function (list) { return list.element.nativeElement === element; }));
-    };
-    ItemsService.prototype.siblings = function (item) {
-        var _this = this;
-        var parentIndex = this.parentIndex(item.index);
-        return this.filter(function (index) { return _this.parentIndex(index) === parentIndex; });
-    };
-    ItemsService.prototype.otherSiblings = function (item) {
-        var _this = this;
-        var parentIndex = this.parentIndex(item.index);
-        return this.filter(function (index) { return _this.parentIndex(index) === parentIndex && index !== item.index; });
-    };
-    ItemsService.prototype.children = function (item) {
-        var _this = this;
-        return this.filter(function (index) { return _this.parentIndex(index) === item.index; });
-    };
-    ItemsService.prototype.parent = function (item) {
-        return this.items[this.parentIndex(item.index)];
-    };
-    ItemsService.prototype.root = function (item) {
-        return this.items[this.indices(item.index)[0]];
-    };
-    ItemsService.prototype.indices = function (index) {
-        return index.split(SEPARATOR);
-    };
-    ItemsService.prototype.filter = function (predicate) {
-        var result = [];
-        var items = this.items;
-        for (var index in items) {
-            if (predicate(index, items[index])) {
-                result.push(items[index]);
-            }
-        }
-        return result.sort(itemIndexComparer);
-    };
-    ItemsService.prototype.previous = function (item) {
-        var siblings = this.siblings(item);
-        var itemIndex = siblings.indexOf(item);
-        return next(itemIndex, siblings, -1);
-    };
-    ItemsService.prototype.next = function (item) {
-        var siblings = this.siblings(item);
-        var itemIndex = siblings.indexOf(item);
-        return next(itemIndex, siblings, 1);
-    };
-    ItemsService.prototype.hasParent = function (item, parent) {
-        return item.index.startsWith(parent.index);
-    };
-    ItemsService.prototype.areSiblings = function (item1, item2) {
-        return item1 !== item2 && this.parent(item1) === this.parent(item2);
-    };
-    ItemsService.prototype.forEach = function (callback) {
-        var items = this.items;
-        for (var index in items) {
-            if (items.hasOwnProperty(index)) {
-                callback(items[index]);
-            }
-        }
-    };
-    ItemsService.prototype.parentIndex = function (index) {
-        return index.replace(PARENT_REGEX, '');
-    };
-    ItemsService = tslib_1.__decorate([
-        Injectable()
-    ], ItemsService);
-    return ItemsService;
-}());
-export { ItemsService };
-export { ɵ0, ɵ1 };