@progress/kendo-angular-popup 21.4.1-develop.1 → 22.0.0-develop.1

package/esm2022/scale.mjs

@@ -1,13 +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 { InjectionToken } from '@angular/core';
-/**
- * Use the `SCALE` injection token to set the document scale when you use a [scale transform](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale).
- *
- * The document or container scale is required to compute the popup position correctly. Set the value for `SCALE` to ensure correct positioning. See [Support for Document Scale]({% slug documentscale_popup %}).
- *
- * > You do not need to use this token for user-applied browser zoom.
- */
-export const SCALE = new InjectionToken('Popup Document Scale');

package/esm2022/services/align.service.mjs

@@ -1,69 +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, Inject, Optional } from '@angular/core';
-import { DOMService } from './dom.service';
-import { eitherRect, removeStackingOffset, scaleRect } from '../util';
-import { SCALE } from '../scale';
-import * as i0 from "@angular/core";
-import * as i1 from "./dom.service";
-/**
- * @hidden
- */
-export class AlignService {
-    _dom;
-    scale;
-    constructor(_dom, scale = 1) {
-        this._dom = _dom;
-        this.scale = scale;
-    }
-    alignElement(settings) {
-        const { anchor, element, anchorAlign, elementAlign, margin, offset, positionMode } = settings;
-        const scale = this.scale || 1;
-        const fixedMode = positionMode === 'fixed' || !this._dom.hasOffsetParent(element);
-        const anchorRect = fixedMode ? this.absoluteRect(anchor, element, offset, scale) : this.relativeRect(anchor, element, offset, scale);
-        const elementRect = scaleRect(this._dom.offset(element.nativeElement), scale);
-        const result = this._dom.align({
-            anchorAlign: anchorAlign,
-            anchorRect: anchorRect,
-            elementAlign: elementAlign,
-            elementRect: elementRect,
-            margin
-        });
-        return result;
-    }
-    absoluteRect(anchor, element, offset, scale) {
-        const scrollPos = this.elementScrollPosition(anchor, element);
-        const rect = eitherRect(this._dom.offset(anchor), offset);
-        const stackScale = 2 * scale;
-        const stackScroll = this._dom.stackingElementScroll(element);
-        if (scale !== 1 && stackScroll) {
-            stackScroll.x /= stackScale;
-            stackScroll.y /= stackScale;
-        }
-        const stackOffset = this._dom.stackingElementOffset(element);
-        if (scale !== 1 && stackOffset) {
-            stackOffset.left /= stackScale;
-            stackOffset.top /= stackScale;
-        }
-        return this._dom.removeScroll(this._dom.addScroll(removeStackingOffset(scaleRect(rect, scale), stackOffset), stackScroll), scrollPos);
-    }
-    elementScrollPosition(anchor, element) {
-        return anchor ? { x: 0, y: 0 } : this._dom.scrollPosition(element);
-    }
-    relativeRect(anchor, element, offset, scale) {
-        const rect = eitherRect(this._dom.position(anchor, element, scale), offset);
-        return scaleRect(rect, scale);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlignService, deps: [{ token: i1.DOMService }, { token: SCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlignService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AlignService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DOMService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [SCALE]
-                }, {
-                    type: Optional
-                }] }] });

package/esm2022/services/animation.service.mjs

@@ -1,138 +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, isDevMode, EventEmitter } from '@angular/core';
-import { animate, style, AnimationBuilder } from '@angular/animations';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/animations";
-const LEFT = 'left';
-const RIGHT = 'right';
-const DOWN = 'down';
-const UP = 'up';
-const DEFAULT_TYPE = 'slide';
-const DEFAULT_DURATION = 100;
-const animationTypes = {};
-animationTypes.expand = (direction) => {
-    const scale = direction === UP || direction === DOWN ? 'scaleY' : 'scaleX';
-    const startScale = 0;
-    const endScale = 1;
-    let origin;
-    if (direction === DOWN) {
-        origin = 'top';
-    }
-    else if (direction === LEFT) {
-        origin = RIGHT;
-    }
-    else if (direction === RIGHT) {
-        origin = LEFT;
-    }
-    else {
-        origin = 'bottom';
-    }
-    return {
-        start: { transform: `${scale}(${startScale})`, transformOrigin: origin },
-        end: { transform: `${scale}(${endScale})` }
-    };
-};
-animationTypes.slide = (direction) => {
-    const translate = direction === LEFT || direction === RIGHT ? 'translateX' : 'translateY';
-    const start = direction === RIGHT || direction === DOWN ? -100 : 100;
-    const end = 0;
-    return {
-        start: { transform: `${translate}(${start}%)` },
-        end: { transform: `${translate}(${end}%)` }
-    };
-};
-animationTypes.fade = () => {
-    return {
-        start: { opacity: 0 },
-        end: { opacity: 1 }
-    };
-};
-animationTypes.zoom = () => {
-    const start = 0;
-    const end = 1;
-    return {
-        start: { transform: `scale(${start})` },
-        end: { transform: `scale(${end})` }
-    };
-};
-/**
- * @hidden
- */
-export class AnimationService {
-    animationBuilder;
-    start = new EventEmitter();
-    end = new EventEmitter();
-    flip;
-    player;
-    constructor(animationBuilder) {
-        this.animationBuilder = animationBuilder;
-    }
-    play(element, options, flip) {
-        if (!this.flip || this.flip.horizontal !== flip.horizontal ||
-            this.flip.vertical !== flip.vertical) {
-            this.flip = flip;
-            const type = options.type || DEFAULT_TYPE;
-            const statesFn = animationTypes[type];
-            if (statesFn) {
-                const direction = this.getDirection(flip, options);
-                const states = statesFn(direction);
-                this.playStates(element, states, options);
-            }
-            else if (isDevMode()) {
-                throw new Error(`Unsupported animation type: "${type}". The supported types are slide, expand, fade and zoom.`);
-            }
-        }
-    }
-    ngOnDestroy() {
-        this.stopPlayer();
-    }
-    playStates(element, states, options) {
-        this.stopPlayer();
-        const duration = options.duration || DEFAULT_DURATION;
-        const factory = this.animationBuilder.build([
-            style(states.start),
-            animate(`${duration}ms ease-in`, style(states.end))
-        ]);
-        const player = this.player = factory.create(element);
-        player.onDone(() => {
-            this.end.emit();
-            this.stopPlayer();
-        });
-        this.start.emit();
-        player.play();
-    }
-    getDirection(flip, options) {
-        let direction = options.direction || DOWN;
-        if (flip.horizontal) {
-            if (direction === LEFT) {
-                direction = RIGHT;
-            }
-            else if (direction === RIGHT) {
-                direction = LEFT;
-            }
-        }
-        if (flip.vertical) {
-            if (direction === DOWN) {
-                direction = UP;
-            }
-            else if (direction === UP) {
-                direction = DOWN;
-            }
-        }
-        return direction;
-    }
-    stopPlayer() {
-        if (this.player) {
-            this.player.destroy();
-            this.player = null;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnimationService, deps: [{ token: i1.AnimationBuilder }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnimationService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AnimationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.AnimationBuilder }] });

package/esm2022/services/dom.service.mjs

@@ -1,155 +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 { align, boundingOffset, getWindowViewPort, offset, positionWithScroll, restrictToView, addScroll, removeScroll, scrollPosition } from '@progress/kendo-popup-common';
-import { isWindowAvailable, hasRelativeStackingContext, scrollableParents, zIndex } from '../util';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-const STYLES = [
-    'font-size',
-    'font-family',
-    'font-stretch',
-    'font-style',
-    'font-weight',
-    'line-height'
-];
-/**
- * @hidden
- */
-export class DOMService {
-    _dummy;
-    addOffset(current, addition) {
-        return {
-            left: current.left + addition.left,
-            top: current.top + addition.top
-        };
-    }
-    addScroll(rect, scroll) {
-        return addScroll(rect, scroll);
-    }
-    align(settings) {
-        return align(settings);
-    }
-    boundingOffset(el) {
-        return boundingOffset(el);
-    }
-    getFontStyles(el) {
-        const window = this.getWindow();
-        if (!window || !el) {
-            return [];
-        }
-        const computedStyles = window.getComputedStyle(el);
-        return STYLES.map(key => ({ key: key, value: computedStyles[key] }));
-    }
-    getWindow() {
-        return isWindowAvailable() ? window : null;
-    }
-    hasOffsetParent(el) {
-        if (!el || !isDocumentAvailable()) {
-            return false;
-        }
-        return !!this.nativeElement(el).offsetParent;
-    }
-    offset(el) {
-        if (!el || !isDocumentAvailable()) {
-            return null;
-        }
-        return offset(el);
-    }
-    offsetAtPoint(el, currentLocation) {
-        if (!el || !isDocumentAvailable()) {
-            return null;
-        }
-        const element = this.nativeElement(el);
-        const { left, top, transition } = element.style;
-        element.style.transition = 'none';
-        element.style.left = `${currentLocation.left}px`;
-        element.style.top = `${currentLocation.top}px`;
-        const currentOffset = offset(element);
-        element.style.left = left;
-        element.style.top = top;
-        // prevents elements with transition to be animated because of the change
-        this._dummy = element.offsetHeight;
-        element.style.transition = transition;
-        return currentOffset;
-    }
-    nativeElement(el) {
-        if (!el || !isDocumentAvailable()) {
-            return null;
-        }
-        return el.nativeElement || el;
-    }
-    position(element, popup, scale = 1) {
-        if (!element || !popup) {
-            return null;
-        }
-        return positionWithScroll(element, this.nativeElement(popup), scale);
-    }
-    removeScroll(rect, scroll) {
-        return removeScroll(rect, scroll);
-    }
-    restrictToView(settings) {
-        return restrictToView(settings);
-    }
-    scrollPosition(el) {
-        return scrollPosition(this.nativeElement(el));
-    }
-    scrollableParents(el) {
-        return scrollableParents(el);
-    }
-    stackingElementOffset(el) {
-        const relativeContextElement = this.getRelativeContextElement(el);
-        if (!relativeContextElement) {
-            return null;
-        }
-        return offset(relativeContextElement);
-    }
-    stackingElementScroll(el) {
-        const relativeContextElement = this.getRelativeContextElement(el);
-        if (!relativeContextElement) {
-            return { x: 0, y: 0 };
-        }
-        return {
-            x: relativeContextElement.scrollLeft,
-            y: relativeContextElement.scrollTop
-        };
-    }
-    getRelativeContextElement(el) {
-        if (!el || !hasRelativeStackingContext()) {
-            return null;
-        }
-        let parent = this.nativeElement(el).parentElement;
-        while (parent) {
-            if (window.getComputedStyle(parent).transform !== 'none') {
-                return parent;
-            }
-            parent = parent.parentElement;
-        }
-        return null;
-    }
-    useRelativePosition(el) {
-        return !!this.getRelativeContextElement(el);
-    }
-    windowViewPort(el) {
-        return getWindowViewPort(this.nativeElement(el));
-    }
-    zIndex(anchor, container) {
-        return zIndex(anchor, this.nativeElement(container));
-    }
-    zoomLevel() {
-        if (!isDocumentAvailable() || !isWindowAvailable()) {
-            return 1;
-        }
-        return parseFloat((document.documentElement.clientWidth / window.innerWidth).toFixed(2)) || 1;
-    }
-    isZoomed() {
-        return this.zoomLevel() > 1;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DOMService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DOMService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DOMService, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/services/position.service.mjs

@@ -1,58 +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 { Inject, Injectable, Optional } from '@angular/core';
-import { DOMService } from './dom.service';
-import { eitherRect, scaleRect } from '../util';
-import { SCALE } from '../scale';
-import * as i0 from "@angular/core";
-import * as i1 from "./dom.service";
-/**
- * @hidden
- */
-export class PositionService {
-    _dom;
-    scale;
-    constructor(_dom, scale = 1) {
-        this._dom = _dom;
-        this.scale = scale;
-    }
-    positionElement(settings) {
-        const { anchor, currentLocation, element, anchorAlign, elementAlign, collisions, margin } = settings;
-        const dom = this._dom;
-        const scale = this.scale || 1;
-        const elementOffset = dom.offsetAtPoint(element, currentLocation);
-        const elementRect = scaleRect(elementOffset, scale);
-        const anchorOffset = scaleRect(dom.offset(anchor), scale);
-        const anchorRect = eitherRect(anchorOffset, currentLocation);
-        const viewPort = settings.viewPort || dom.windowViewPort(element);
-        viewPort.width = viewPort.width / scale;
-        viewPort.height = viewPort.height / scale;
-        const result = dom.restrictToView({
-            anchorAlign,
-            anchorRect,
-            collisions,
-            elementAlign,
-            elementRect,
-            margin,
-            viewPort
-        });
-        const offset = dom.addOffset(currentLocation, result.offset);
-        return {
-            flip: result.flip,
-            flipped: result.flipped,
-            offset: offset
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PositionService, deps: [{ token: i1.DOMService }, { token: SCALE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PositionService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PositionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DOMService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [SCALE]
-                }, {
-                    type: Optional
-                }] }] });

package/esm2022/services/resize.service.mjs

@@ -1,48 +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, NgZone } from '@angular/core';
-import { fromEvent } from 'rxjs';
-import { auditTime } from 'rxjs/operators';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { FRAME_DURATION } from '../util';
-import { DOMService } from './dom.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./dom.service";
-/**
- * @hidden
- */
-export class ResizeService {
-    _dom;
-    _zone;
-    subscription;
-    constructor(_dom, _zone) {
-        this._dom = _dom;
-        this._zone = _zone;
-    }
-    subscribe(callback) {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        this._zone.runOutsideAngular(() => {
-            this.subscription = fromEvent(this._dom.getWindow(), "resize")
-                .pipe(auditTime(FRAME_DURATION))
-                .subscribe(() => callback());
-        });
-    }
-    unsubscribe() {
-        if (!this.subscription) {
-            return;
-        }
-        this.subscription.unsubscribe();
-    }
-    isUnsubscribed() {
-        return this.subscription && this.subscription.closed;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeService, deps: [{ token: i1.DOMService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ResizeService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DOMService }, { type: i0.NgZone }] });

package/esm2022/services/scrollable.service.mjs

@@ -1,81 +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, NgZone } from '@angular/core';
-import { fromEvent, merge } from 'rxjs';
-import { auditTime } from 'rxjs/operators';
-import { isDocumentAvailable } from '@progress/kendo-angular-common';
-import { DOMService } from './dom.service';
-import { FRAME_DURATION } from '../util';
-import * as i0 from "@angular/core";
-import * as i1 from "./dom.service";
-/**
- * @hidden
- */
-export const THRESHOLD_DIFF = 1;
-/**
- * @hidden
- */
-export class ScrollableService {
-    _dom;
-    _zone;
-    element;
-    subscription;
-    constructor(_dom, _zone) {
-        this._dom = _dom;
-        this._zone = _zone;
-    }
-    forElement(element) {
-        this.unsubscribe();
-        this.element = element;
-        return this;
-    }
-    subscribe(callback) {
-        if (!callback || !isDocumentAvailable() || !this.element) {
-            return;
-        }
-        const parents = this._dom.scrollableParents(this.element);
-        this._zone.runOutsideAngular(() => {
-            const observables = parents.map(p => fromEvent(p, "scroll").pipe(auditTime(FRAME_DURATION)));
-            const subscriber = (e) => {
-                const target = e.target;
-                const isParent = parents.filter(p => p === target).length > 0;
-                const isDocument = target === document;
-                const isWindow = target === window;
-                if (isParent || isDocument || isWindow) {
-                    callback(this.isVisible(this.element, target));
-                }
-            };
-            this.subscription = merge(...observables).subscribe(subscriber);
-        });
-    }
-    unsubscribe() {
-        if (!this.subscription) {
-            return;
-        }
-        this.subscription.unsubscribe();
-    }
-    isVisible(elem, container) {
-        const elemRect = this._dom.boundingOffset(elem);
-        const containerRect = this._dom.boundingOffset(this._dom.nativeElement(container));
-        if (THRESHOLD_DIFF < (containerRect.top - elemRect.bottom)) {
-            return false;
-        }
-        if (THRESHOLD_DIFF < (elemRect.top - containerRect.bottom)) {
-            return false;
-        }
-        if (THRESHOLD_DIFF < (elemRect.left - containerRect.right)) {
-            return false;
-        }
-        if (THRESHOLD_DIFF < (containerRect.left - elemRect.right)) {
-            return false;
-        }
-        return true;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollableService, deps: [{ token: i1.DOMService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollableService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ScrollableService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.DOMService }, { type: i0.NgZone }] });