@progress/kendo-angular-menu 21.4.1 → 22.0.0

package/esm2022/rendering/popup-settings.mjs

@@ -1,74 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-const POPUP_ALIGN = {
-    vertical: 'top',
-    horizontal: 'left'
-};
-const POPUP_ALIGN_RTL = {
-    vertical: 'top',
-    horizontal: 'right'
-};
-const VERTICAL_COLLISION = {
-    vertical: 'flip',
-    horizontal: 'fit'
-};
-const HORIZONTAL_COLLISION = {
-    vertical: 'fit',
-    horizontal: 'flip'
-};
-/**
- * @hidden
- */
-export const DEFAULT_MARGIN = { horizontal: 0, vertical: 0 };
-/**
- * @hidden
- */
-export const POPUP_SETTINGS_RTL = {
-    vertical: {
-        anchor: {
-            vertical: 'bottom',
-            horizontal: 'right'
-        },
-        popup: POPUP_ALIGN_RTL,
-        collision: VERTICAL_COLLISION,
-        animate: 'down',
-        popupClass: ['k-rtl', 'k-menu-popup']
-    },
-    horizontal: {
-        anchor: {
-            vertical: 'top',
-            horizontal: 'left'
-        },
-        popup: POPUP_ALIGN_RTL,
-        collision: HORIZONTAL_COLLISION,
-        animate: 'left',
-        popupClass: ['k-rtl', 'k-menu-popup']
-    }
-};
-/**
- * @hidden
- */
-export const POPUP_SETTINGS = {
-    vertical: {
-        anchor: {
-            vertical: 'bottom',
-            horizontal: 'left'
-        },
-        popup: POPUP_ALIGN,
-        collision: VERTICAL_COLLISION,
-        animate: 'down',
-        popupClass: ['k-menu-popup']
-    },
-    horizontal: {
-        anchor: {
-            vertical: 'top',
-            horizontal: 'right'
-        },
-        popup: POPUP_ALIGN,
-        collision: HORIZONTAL_COLLISION,
-        animate: 'right',
-        popupClass: ['k-menu-popup']
-    }
-};

package/esm2022/services/actions.service.mjs

@@ -1,192 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { NgZone, Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { hasObservers, PreventableEvent } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-import * as i1 from "./items.service";
-const canPerformAction = (item, action) => !((action === 'open' && item.opened) || (action === 'close' && !item.opened));
-/**
- * Used to remove cyclic dependency error. Dublicates MenuEvent
- * @hidden
- */
-export class MenuStateEvent extends PreventableEvent {
-    /**
-     * The MenuComponent that triggered the event.
-     */
-    sender;
-    /**
-     * The item data of the event.
-     */
-    item;
-    /**
-     * The item index of the event.
-     */
-    index;
-    constructor(args) {
-        super();
-        Object.assign(this, args);
-    }
-}
-/**
- * @hidden
- */
-export class ActionsService {
-    ngZone;
-    items;
-    owner;
-    actions = [];
-    constructor(ngZone, items) {
-        this.ngZone = ngZone;
-        this.items = items;
-    }
-    open(item, finished) {
-        if (item.disabled) {
-            return;
-        }
-        if (item.hasContent && !item.opened) {
-            this.actions.push({
-                name: 'open',
-                requiresZone: item.hasContentTemplates(),
-                item,
-                finished
-            });
-        }
-        else if (finished) {
-            finished();
-        }
-    }
-    close(item) {
-        this.closeChildren(item);
-        this.closeItem(item);
-    }
-    closeItem(item) {
-        if (item.opened) {
-            this.actions.push({
-                name: 'close',
-                item
-            });
-        }
-    }
-    closeToRoot(item) {
-        this.closeChildren(item);
-        let current = item;
-        do {
-            this.closeItem(current);
-            current = this.items.parent(current);
-        } while (current);
-    }
-    closeOthers(item) {
-        this.closeChildren(item);
-        let current = item;
-        while (current) {
-            const siblings = this.items.otherSiblings(current);
-            this.closeItems(siblings);
-            current = this.items.parent(current);
-        }
-    }
-    closeAll() {
-        this.items.forEach((item) => {
-            if (item.opened && item.level === 0) {
-                this.close(item);
-            }
-        });
-    }
-    select(item, domEvent, prevented, finished) {
-        this.actions.push({
-            name: 'select',
-            item,
-            prevented,
-            finished,
-            domEvent
-        });
-    }
-    emit(name, item, domEvent) {
-        const owner = this.owner;
-        const eventArgs = new MenuStateEvent({
-            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();
-    }
-    get hasPending() {
-        return this.actions.length > 0;
-    }
-    execute(toExecute) {
-        if (!this.hasPending && !toExecute) {
-            return;
-        }
-        const actions = toExecute || this.clear();
-        if (!NgZone.isInAngularZone() && this.requiresZone(actions)) {
-            this.ngZone.run(() => {
-                this.executeActions(actions);
-            });
-        }
-        else {
-            this.executeActions(actions);
-        }
-    }
-    clear() {
-        const actions = this.actions;
-        this.actions = [];
-        return actions;
-    }
-    executeActions(actions) {
-        for (let idx = 0; idx < actions.length; idx++) {
-            const { item, name, prevented, finished, domEvent } = actions[idx];
-            if (!canPerformAction(item, name)) {
-                continue;
-            }
-            if (!this.emit(name, item, domEvent)) {
-                if (item[name]) {
-                    item[name]();
-                }
-                if (finished) {
-                    finished();
-                }
-            }
-            else if (prevented) {
-                prevented();
-            }
-        }
-    }
-    requiresZone(toExecute) {
-        const actions = toExecute || this.actions;
-        const owner = this.owner;
-        const contextService = owner.contextService;
-        for (let idx = 0; idx < actions.length; idx++) {
-            const action = actions[idx];
-            const name = action.name;
-            if (action.requiresZone || (name && (hasObservers(owner[name]) || (contextService && contextService.hasObservers(name))))) {
-                return true;
-            }
-        }
-        return false;
-    }
-    closeChildren(item) {
-        if (!item.opened) {
-            return;
-        }
-        const children = this.items.children(item);
-        this.closeItems(children);
-    }
-    closeItems(items) {
-        for (let idx = 0; idx < items.length; idx++) {
-            this.close(items[idx]);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ActionsService, deps: [{ token: i0.NgZone }, { token: i1.ItemsService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ActionsService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ActionsService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1.ItemsService }] });

package/esm2022/services/hover.service.mjs

@@ -1,127 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import { ItemsService } from './items.service';
-import { ActionsService } from './actions.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./actions.service";
-import * as i2 from "./items.service";
-const DISABLE_OPEN_ON_OVER_DELAY = 500;
-/**
- * @hidden
- */
-export class HoverService {
-    actions;
-    items;
-    delay = 100;
-    get openOnOver() {
-        return this._openOnOver;
-    }
-    set openOnOver(value) {
-        this.cancelActions();
-        this._openOnOver = value;
-    }
-    _openOnOver = true;
-    hoveredIdx;
-    get hovered() {
-        return this.items.get(this.hoveredIdx);
-    }
-    set hovered(item) {
-        this.hoveredIdx = item ? item.index : null;
-    }
-    scheduled = [];
-    constructor(actions, items) {
-        this.actions = actions;
-        this.items = items;
-    }
-    ngOnDestroy() {
-        this.cancelActions();
-    }
-    over(item) {
-        this.cancelActions((action) => 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((action) => (action.name === 'close' && (item === action.item || this.items.hasParent(item, action.item))) ||
-                    (action.name === 'open' && !this.items.hasParent(item, action.item)));
-            }
-            this.scheduleActions();
-        }
-    }
-    leave(disableOpenOnOver) {
-        const hovered = this.hovered;
-        if (hovered) {
-            this.actions.closeToRoot(hovered);
-            this.cancelActions(action => action.name === 'open');
-            this.scheduleActions();
-        }
-        if (disableOpenOnOver && this._openOnOver) {
-            this.scheduleDisableOpenOnOver();
-        }
-        this.hovered = null;
-    }
-    closeCurrent() {
-        const hovered = this.hovered;
-        if (hovered) {
-            this.actions.closeToRoot(hovered);
-            this.hovered = null;
-        }
-    }
-    scheduleActions() {
-        if (this.actions.hasPending) {
-            const item = {};
-            item.actions = this.actions.clear();
-            item.id = setTimeout(() => {
-                this.actions.execute(item.actions);
-                this.removeScheduled(item);
-            }, this.delay);
-            this.scheduled.push(item);
-        }
-    }
-    scheduleDisableOpenOnOver() {
-        const item = {
-            actions: [{ name: 'openOnOver' }]
-        };
-        item.id = setTimeout(() => {
-            this._openOnOver = false;
-            this.removeScheduled(item);
-        }, Math.max(this.delay, DISABLE_OPEN_ON_OVER_DELAY));
-        this.scheduled.push(item);
-    }
-    removeScheduled(item) {
-        const scheduled = this.scheduled;
-        for (let idx = 0; idx < scheduled.length; idx++) {
-            if (scheduled[idx] === item) {
-                scheduled.splice(idx, 1);
-                return;
-            }
-        }
-    }
-    cancelActions(predicate) {
-        const scheduled = this.scheduled;
-        for (let idx = scheduled.length - 1; idx >= 0; idx--) {
-            const item = scheduled[idx];
-            const actions = item.actions;
-            if (predicate) {
-                for (let 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);
-            }
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoverService, deps: [{ token: i1.ActionsService }, { token: i2.ItemsService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoverService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HoverService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.ActionsService }, { type: i2.ItemsService }] });

package/esm2022/services/items.service.mjs

@@ -1,128 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
-const PARENT_REGEX = /_?\d+$/;
-const SEPARATOR = '_';
-let id = 0;
-const itemIndexComparer = (a, b) => a.siblingIndex - b.siblingIndex;
-const next = (idx, items, dir) => {
-    let 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;
-};
-/**
- * @hidden
- */
-export class ItemsService {
-    items = {};
-    lists = [];
-    idPrefix = `k-menu${id++}`;
-    get hasItems() {
-        return Object.keys(this.items).length > 0;
-    }
-    childId(index) {
-        return `${this.idPrefix}-child${index}`;
-    }
-    itemIndex(parentIndex, index) {
-        return (parentIndex ? parentIndex + SEPARATOR : '') + index;
-    }
-    get(index) {
-        return this.items[index];
-    }
-    add(item) {
-        this.items[item.index] = item;
-    }
-    remove(item) {
-        if (this.items[item.index] === item) {
-            delete this.items[item.index];
-        }
-    }
-    addList(list) {
-        this.lists.push(list);
-    }
-    removeList(list) {
-        const index = this.lists.indexOf(list);
-        if (index >= 0) {
-            this.lists.splice(index, 1);
-        }
-    }
-    containsList(element) {
-        return Boolean(this.lists.find(list => list.element.nativeElement === element));
-    }
-    siblings(item) {
-        const parentIndex = this.parentIndex(item.index);
-        return this.filter((index) => this.parentIndex(index) === parentIndex);
-    }
-    otherSiblings(item) {
-        const parentIndex = this.parentIndex(item.index);
-        return this.filter((index) => this.parentIndex(index) === parentIndex && index !== item.index);
-    }
-    children(item) {
-        return this.filter((index) => this.parentIndex(index) === item.index);
-    }
-    parent(item) {
-        return this.items[this.parentIndex(item.index)];
-    }
-    root(item) {
-        return this.items[this.indices(item.index)[0]];
-    }
-    indices(index) {
-        return index.split(SEPARATOR);
-    }
-    filter(predicate) {
-        const result = [];
-        const items = this.items;
-        for (const index in items) {
-            if (predicate(index, items[index])) {
-                result.push(items[index]);
-            }
-        }
-        return result.sort(itemIndexComparer);
-    }
-    previous(item) {
-        const siblings = this.siblings(item);
-        const itemIndex = siblings.indexOf(item);
-        return next(itemIndex, siblings, -1);
-    }
-    next(item) {
-        const siblings = this.siblings(item);
-        const itemIndex = siblings.indexOf(item);
-        return next(itemIndex, siblings, 1);
-    }
-    hasParent(item, parent) {
-        return item.index.startsWith(parent.index);
-    }
-    areSiblings(item1, item2) {
-        return item1 !== item2 && this.parent(item1) === this.parent(item2);
-    }
-    forEach(callback) {
-        const items = this.items;
-        for (const index in items) {
-            if (items.hasOwnProperty(index)) {
-                callback(items[index]);
-            }
-        }
-    }
-    parentIndex(index) {
-        return index.replace(PARENT_REGEX, '');
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ItemsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ItemsService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ItemsService, decorators: [{
-            type: Injectable
-        }] });