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

package/esm2022/popup.component.mjs

@@ -1,370 +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 { Component, ElementRef, EventEmitter, Input, Output, NgZone, Renderer2, ViewChild } from '@angular/core';
-import { AlignService } from './services/align.service';
-import { DOMService } from './services/dom.service';
-import { PositionService } from './services/position.service';
-import { ResizeService } from './services/resize.service';
-import { ScrollableService } from './services/scrollable.service';
-import { AnimationService } from './services/animation.service';
-import { isDifferentOffset } from './util';
-import { hasObservers, isDocumentAvailable, ResizeSensorComponent } from '@progress/kendo-angular-common';
-import { from } from 'rxjs';
-import { validatePackage } from '@progress/kendo-licensing';
-import { packageMetadata } from './package-metadata';
-import { NgClass, NgTemplateOutlet } from '@angular/common';
-import * as i0 from "@angular/core";
-import * as i1 from "./services/align.service";
-import * as i2 from "./services/dom.service";
-import * as i3 from "./services/position.service";
-import * as i4 from "./services/resize.service";
-import * as i5 from "./services/scrollable.service";
-import * as i6 from "./services/animation.service";
-const DEFAULT_OFFSET = { left: -10000, top: 0 };
-const ANIMATION_CONTAINER = 'k-animation-container';
-const ANIMATION_CONTAINER_FIXED = 'k-animation-container-fixed';
-/**
- * Represents the [Kendo UI Popup component for Angular]({% slug overview_popup %}).
- *
- * @example
- * ```html
- * <button #anchor (click)="show = !show">Toggle</button>
- * @if (show) {
- *   <kendo-popup [anchor]="anchor">
- *     <strong>Popup content!</strong>
- *   </kendo-popup>
- * }
- * ```
- */
-export class PopupComponent {
-    container;
-    _alignService;
-    domService;
-    _positionService;
-    _resizeService;
-    _scrollableService;
-    animationService;
-    _renderer;
-    _zone;
-    /**
-     * Controls the Popup animation. By default, the opening and closing animations are enabled ([see example]({% slug animations_popup %})).
-     * @default true
-     */
-    animate = true;
-    /**
-     * Sets the element to use as an anchor. The Popup opens next to this element. ([See example]({% slug alignmentpositioning_popup %}#toc-aligning-to-components)).
-     */
-    anchor;
-    /**
-     * Sets the anchor pivot point ([see example]({% slug alignmentpositioning_popup %}#toc-positioning)).
-     * @default '{ horizontal: "left", vertical: "bottom" }'
-     */
-    anchorAlign = { horizontal: 'left', vertical: 'bottom' };
-    /**
-     * Sets the collision behavior of the Popup ([see example]({% slug viewportboundarydetection_popup %})).
-     * @default '{ horizontal: "fit", vertical: "flip" }'
-     */
-    collision = { horizontal: 'fit', vertical: 'flip' };
-    /**
-     * Sets the pivot point of the Popup ([see example]({% slug alignmentpositioning_popup %}#toc-positioning)).
-     * @default '{ horizontal: "left", vertical: "top" }'
-     */
-    popupAlign = { horizontal: 'left', vertical: 'top' };
-    /**
-     * Controls whether the component copies the `anchor` font styles.
-     * @default false
-     */
-    copyAnchorStyles = false;
-    /**
-     * Sets a list of CSS classes to add to the internal animated element ([see example]({% slug appearance_popup %})).
-     *
-     * > To style the content of the Popup, use this property binding.
-     */
-    popupClass;
-    /**
-     * Sets the position mode of the component. By default, the Popup uses fixed positioning. To use absolute positioning, set this option to `absolute`.
-     *
-     * To support mobile browsers with the zoom option, use the `absolute` positioning of the Popup.
-     * @default 'fixed'
-     */
-    positionMode = 'fixed';
-    /**
-     * Sets the absolute position of the element ([see example]({% slug alignmentpositioning_popup %}#toc-aligning-to-absolute-points)).
-     * The Popup opens next to this point. The Popup pivot point is defined by the `popupAlign` option. The boundary detection uses the window viewport.
-     * @default '{ left: -10000, top: 0 }'
-     */
-    offset = DEFAULT_OFFSET;
-    /**
-     * Sets the margin value in pixels. Adds blank space between the Popup and the anchor ([see example]({% slug alignmentpositioning_popup %}#toc-adding-a-margin)).
-     */
-    margin;
-    /**
-     * Fires when the anchor scrolls outside the screen boundaries. ([See example]({% slug closing_popup %}#toc-after-leaving-the-viewport)).
-     */
-    anchorViewportLeave = new EventEmitter();
-    /**
-     * Fires after the component closes.
-     */
-    close = new EventEmitter();
-    /**
-     * Fires after the component opens and the opening animation ends.
-     */
-    open = new EventEmitter();
-    /**
-     * Fires after the component is opened and the Popup is positioned.
-     */
-    positionChange = new EventEmitter();
-    /**
-     * @hidden
-     */
-    contentContainer;
-    /**
-     * @hidden
-     */
-    resizeSensor;
-    /**
-     * @hidden
-     */
-    content;
-    /**
-     * @hidden
-     */
-    renderDefaultClass = true;
-    resolvedPromise = Promise.resolve(null);
-    _currentOffset;
-    animationSubscriptions;
-    repositionSubscription;
-    initialCheck = true;
-    constructor(container, _alignService, domService, _positionService, _resizeService, _scrollableService, animationService, _renderer, _zone) {
-        this.container = container;
-        this._alignService = _alignService;
-        this.domService = domService;
-        this._positionService = _positionService;
-        this._resizeService = _resizeService;
-        this._scrollableService = _scrollableService;
-        this.animationService = animationService;
-        this._renderer = _renderer;
-        this._zone = _zone;
-        validatePackage(packageMetadata);
-        this._renderer.addClass(container.nativeElement, ANIMATION_CONTAINER);
-        this.updateFixedClass();
-    }
-    ngOnInit() {
-        this.reposition = this.reposition.bind(this);
-        this._resizeService.subscribe(this.reposition);
-        this.animationSubscriptions = this.animationService.start.subscribe(this.onAnimationStart.bind(this));
-        this.animationSubscriptions.add(this.animationService.end.subscribe(this.onAnimationEnd.bind(this)));
-        this._scrollableService.forElement(this.domService.nativeElement(this.anchor) || this.container.nativeElement).subscribe(this.onScroll.bind(this));
-        this.currentOffset = DEFAULT_OFFSET;
-        // we intentionally set the zIndex here as an exception to the rule that it should come from the themes
-        // to be removed once https://github.com/telerik/kendo-angular-private/issues/5413 is addressed
-        this.setZIndex();
-        this.copyFontStyles();
-        this.updateFixedClass();
-        this.reposition();
-    }
-    ngOnChanges(changes) {
-        if (changes.copyAnchorStyles) {
-            this.copyFontStyles();
-        }
-        if (changes.positionMode) {
-            this.updateFixedClass();
-        }
-    }
-    ngAfterViewInit() {
-        if (!this.animate) {
-            this.resolvedPromise.then(() => {
-                this.onAnimationEnd();
-            });
-        }
-        this.reposition();
-    }
-    ngAfterViewChecked() {
-        if (this.initialCheck) {
-            this.initialCheck = false;
-            return;
-        }
-        this._zone.runOutsideAngular(() => {
-            // workarounds https://github.com/angular/angular/issues/19094
-            // uses promise because it is executed synchronously after the content is updated
-            // does not use onStable in case the current zone is not the angular one.
-            this.unsubscribeReposition();
-            this.repositionSubscription = from(this.resolvedPromise)
-                .subscribe(this.reposition);
-        });
-    }
-    ngOnDestroy() {
-        this.anchorViewportLeave.complete();
-        this.positionChange.complete();
-        this.close.emit();
-        this.close.complete();
-        this._resizeService.unsubscribe();
-        this._scrollableService.unsubscribe();
-        this.animationSubscriptions.unsubscribe();
-        this.unsubscribeReposition();
-    }
-    /**
-     * @hidden
-     */
-    onResize() {
-        this.reposition();
-    }
-    onAnimationStart() {
-        this._renderer.removeClass(this.container.nativeElement, 'k-animation-container-shown');
-    }
-    onAnimationEnd() {
-        this._renderer.addClass(this.container.nativeElement, 'k-animation-container-shown');
-        this.open.emit();
-        this.open.complete();
-    }
-    get currentOffset() {
-        return this._currentOffset;
-    }
-    set currentOffset(offset) {
-        this.setContainerStyle('left', `${offset.left}px`);
-        this.setContainerStyle('top', `${offset.top}px`);
-        this._currentOffset = offset;
-    }
-    setZIndex() {
-        if (this.anchor) {
-            this.setContainerStyle('z-index', String(this.domService.zIndex(this.domService.nativeElement(this.anchor), this.container)));
-        }
-    }
-    reposition() {
-        if (!isDocumentAvailable()) {
-            return;
-        }
-        const { flip, offset } = this.position();
-        if (!this.currentOffset || isDifferentOffset(this.currentOffset, offset)) {
-            this.currentOffset = offset;
-            if (hasObservers(this.positionChange)) {
-                this._zone.run(() => this.positionChange.emit({ offset, flip }));
-            }
-        }
-        if (this.animate) {
-            this.animationService.play(this.contentContainer.nativeElement, this.animate, flip);
-        }
-        this.resizeSensor.acceptSize();
-    }
-    position() {
-        const alignedOffset = this._alignService.alignElement({
-            anchor: this.domService.nativeElement(this.anchor),
-            anchorAlign: this.anchorAlign,
-            element: this.container,
-            elementAlign: this.popupAlign,
-            margin: this.margin,
-            offset: this.offset,
-            positionMode: this.positionMode
-        });
-        return this._positionService.positionElement({
-            anchor: this.domService.nativeElement(this.anchor),
-            anchorAlign: this.anchorAlign,
-            collisions: this.collision,
-            currentLocation: alignedOffset,
-            element: this.container,
-            elementAlign: this.popupAlign,
-            margin: this.margin
-        });
-    }
-    onScroll(isInViewPort) {
-        const hasLeaveObservers = hasObservers(this.anchorViewportLeave);
-        if (isInViewPort || !hasLeaveObservers) {
-            this.reposition();
-        }
-        else if (hasLeaveObservers) {
-            this._zone.run(() => {
-                this.anchorViewportLeave.emit();
-            });
-        }
-    }
-    copyFontStyles() {
-        if (!this.anchor || !this.copyAnchorStyles) {
-            return;
-        }
-        this.domService.getFontStyles(this.domService.nativeElement(this.anchor))
-            .forEach((s) => this.setContainerStyle(s.key, s.value));
-    }
-    updateFixedClass() {
-        const action = this.positionMode === 'fixed' ? 'addClass' : 'removeClass';
-        this._renderer[action](this.container.nativeElement, ANIMATION_CONTAINER_FIXED);
-    }
-    setContainerStyle(name, value) {
-        this._renderer.setStyle(this.container.nativeElement, name, value);
-    }
-    unsubscribeReposition() {
-        if (this.repositionSubscription) {
-            this.repositionSubscription.unsubscribe();
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupComponent, deps: [{ token: i0.ElementRef }, { token: i1.AlignService }, { token: i2.DOMService }, { token: i3.PositionService }, { token: i4.ResizeService }, { token: i5.ScrollableService }, { token: i6.AnimationService }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PopupComponent, isStandalone: true, selector: "kendo-popup", inputs: { animate: "animate", anchor: "anchor", anchorAlign: "anchorAlign", collision: "collision", popupAlign: "popupAlign", copyAnchorStyles: "copyAnchorStyles", popupClass: "popupClass", positionMode: "positionMode", offset: "offset", margin: "margin" }, outputs: { anchorViewportLeave: "anchorViewportLeave", close: "close", open: "open", positionChange: "positionChange" }, providers: [AlignService, AnimationService, DOMService, PositionService, ResizeService, ScrollableService], viewQueries: [{ propertyName: "contentContainer", first: true, predicate: ["container"], descendants: true, static: true }, { propertyName: "resizeSensor", first: true, predicate: ResizeSensorComponent, descendants: true, static: true }], exportAs: ["kendo-popup"], usesOnChanges: true, ngImport: i0, template: `
-        <div class="k-child-animation-container">
-          <div [class.k-popup]="renderDefaultClass" [ngClass]="popupClass" #container>
-            <ng-content></ng-content>
-            @if (content) {
-              <ng-template [ngTemplateOutlet]="content"></ng-template>
-            }
-            <kendo-resize-sensor [rateLimit]="100" (resize)="onResize()">
-            </kendo-resize-sensor>
-          </div>
-        </div>
-        `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: ResizeSensorComponent, selector: "kendo-resize-sensor", inputs: ["rateLimit"], outputs: ["resize"] }] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupComponent, decorators: [{
-            type: Component,
-            args: [{
-                    exportAs: 'kendo-popup',
-                    providers: [AlignService, AnimationService, DOMService, PositionService, ResizeService, ScrollableService],
-                    selector: 'kendo-popup',
-                    template: `
-        <div class="k-child-animation-container">
-          <div [class.k-popup]="renderDefaultClass" [ngClass]="popupClass" #container>
-            <ng-content></ng-content>
-            @if (content) {
-              <ng-template [ngTemplateOutlet]="content"></ng-template>
-            }
-            <kendo-resize-sensor [rateLimit]="100" (resize)="onResize()">
-            </kendo-resize-sensor>
-          </div>
-        </div>
-        `,
-                    standalone: true,
-                    imports: [NgClass, NgTemplateOutlet, ResizeSensorComponent]
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.AlignService }, { type: i2.DOMService }, { type: i3.PositionService }, { type: i4.ResizeService }, { type: i5.ScrollableService }, { type: i6.AnimationService }, { type: i0.Renderer2 }, { type: i0.NgZone }], propDecorators: { animate: [{
-                type: Input
-            }], anchor: [{
-                type: Input
-            }], anchorAlign: [{
-                type: Input
-            }], collision: [{
-                type: Input
-            }], popupAlign: [{
-                type: Input
-            }], copyAnchorStyles: [{
-                type: Input
-            }], popupClass: [{
-                type: Input
-            }], positionMode: [{
-                type: Input
-            }], offset: [{
-                type: Input
-            }], margin: [{
-                type: Input
-            }], anchorViewportLeave: [{
-                type: Output
-            }], close: [{
-                type: Output
-            }], open: [{
-                type: Output
-            }], positionChange: [{
-                type: Output
-            }], contentContainer: [{
-                type: ViewChild,
-                args: ['container', { static: true }]
-            }], resizeSensor: [{
-                type: ViewChild,
-                args: [ResizeSensorComponent, { static: true }]
-            }] } });

package/esm2022/popup.module.mjs

@@ -1,54 +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 { NgModule } from '@angular/core';
-import { KENDO_RESIZESENSOR, ResizeBatchService } from '@progress/kendo-angular-common';
-import { PopupService } from './popup.service';
-import { KENDO_POPUP } from './directives';
-import * as i0 from "@angular/core";
-import * as i1 from "@progress/kendo-angular-common";
-import * as i2 from "./popup.component";
-//IMPORTANT: NgModule export kept for backwards compatibility
-/**
- * Required for adding all Popup features in NgModule-based Angular applications.
- *
- * @example
- * ```ts-no-run
- * // Import the Popup module
- * import { PopupModule } from '@progress/kendo-angular-popup';
- *
- * // The browser platform with a compiler
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- *
- * import { NgModule } from '@angular/core';
- *
- * // Import the app component
- * import { AppComponent } from './app.component';
- *
- * // Define the app module
- * _@NgModule({
- *     declarations: [AppComponent], // declare app component
- *     imports:      [BrowserModule, PopupModule], // import Popup module
- *     bootstrap:    [AppComponent]
- * })
- * export class AppModule {}
- *
- * // Compile and launch the module
- * platformBrowserDynamic().bootstrapModule(AppModule);
- *
- * ```
- */
-export class PopupModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: PopupModule, imports: [i1.ResizeSensorComponent, i2.PopupComponent], exports: [i2.PopupComponent] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupModule, providers: [PopupService, ResizeBatchService], imports: [KENDO_RESIZESENSOR, KENDO_POPUP] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    exports: [...KENDO_POPUP],
-                    imports: [...KENDO_RESIZESENSOR, ...KENDO_POPUP],
-                    providers: [PopupService, ResizeBatchService]
-                }]
-        }] });

package/esm2022/popup.service.mjs

@@ -1,241 +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 { ApplicationRef, ComponentFactoryResolver, ElementRef, InjectionToken, Injectable, Injector, Inject, Optional, TemplateRef } from '@angular/core';
-import { PopupComponent } from './popup.component';
-import * as i0 from "@angular/core";
-const removeElement = (element) => {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
-    }
-};
-/**
- * Injects the Popup container. If not set, uses the first root component of the application.
- *
- * > Use `POPUP_CONTAINER` only with the `PopupService` class ([see example](slug:service_popup)).
- *
- * In standalone components:
- *
- * @example
- * ```ts
- * import { Component } from '@angular/core';
- * import { KENDO_POPUP, PopupService } from '@progress/kendo-angular-popup';
- *
- * @Component({
- *   standalone: true,
- *   imports: [KENDO_POPUP],
- *   providers: [PopupService, {
- *     provide: POPUP_CONTAINER,
- *       useFactory: () => {
- *         //return the container ElementRef, where the popup will be injected
- *         return { nativeElement: document.body } as ElementRef;
- *       }
- *   }],
- *   selector: 'app-root',
- *   templateUrl: './app.component.html',
- * })
- * export class AppComponent {}
- * ```
- *
- * In NgModule-based applications:
- *
- * @example
- * ```ts
- * import { PopupModule, POPUP_CONTAINER } from '@progress/kendo-angular-popup';
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- * import { ElementRef, NgModule } from '@angular/core';
- * import { AppComponent } from './app.component';
- *
- * _@NgModule({
- *     declarations: [AppComponent],
- *     imports:      [BrowserModule, PopupModule],
- *     bootstrap:    [AppComponent],
- *     providers: [{
- *       provide: POPUP_CONTAINER,
- *       useFactory: () => {
- *          //return the container ElementRef, where the popup will be injected
- *          return { nativeElement: document.body } as ElementRef;
- *       }
- *     }]
- * })
- * export class AppModule {}
- *
- * platformBrowserDynamic().bootstrapModule(AppModule);
- * ```
- */
-export const POPUP_CONTAINER = new InjectionToken('Popup Container');
-/**
- * Provides a service for opening Popup components dynamically ([see example]({% slug service_popup %})).
- *
- * @export
- * @class PopupService
- */
-export class PopupService {
-    applicationRef;
-    componentFactoryResolver;
-    injector;
-    container;
-    /**
-     * Gets the root view container for injecting the component.
-     *
-     * @returns {ComponentRef<any>} The root view container reference.
-     */
-    get rootViewContainer() {
-        // https://github.com/angular/angular/blob/4.0.x/packages/core/src/application_ref.ts#L571
-        const rootComponents = this.applicationRef.components || [];
-        if (rootComponents[0]) {
-            return rootComponents[0];
-        }
-        throw new Error(`
-            View Container not found! Inject the POPUP_CONTAINER or define a specific ViewContainerRef via the appendTo option.
-            See https://www.telerik.com/kendo-angular-ui/components/popup/api/POPUP_CONTAINER/ for more details.
-        `);
-    }
-    /**
-     * Gets the HTML element of the root component container.
-     *
-     * @returns {HTMLElement} The root container HTML element.
-     */
-    get rootViewContainerNode() {
-        return this.container ? this.container.nativeElement : this.getComponentRootNode(this.rootViewContainer);
-    }
-    constructor(applicationRef, componentFactoryResolver, injector, container) {
-        this.applicationRef = applicationRef;
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.injector = injector;
-        this.container = container;
-    }
-    /**
-     * Opens a Popup component. The Popup mounts in the DOM under the root application component.
-     *
-     * @param {PopupSettings} options - The options for the Popup.
-     * @returns {ComponentRef<PopupComponent>} A reference to the Popup object.
-     */
-    open(options = {}) {
-        const { component, nodes } = this.contentFrom(options.content);
-        const popupComponentRef = this.appendPopup(nodes, options.appendTo);
-        const popupInstance = popupComponentRef.instance;
-        this.projectComponentInputs(popupComponentRef, options);
-        popupComponentRef.changeDetectorRef.detectChanges();
-        if (component) {
-            component.changeDetectorRef.detectChanges();
-        }
-        const popupElement = this.getComponentRootNode(popupComponentRef);
-        return {
-            close: () => {
-                if (component) {
-                    component.destroy();
-                }
-                popupComponentRef.destroy();
-                // Issue in Chrome causes https://github.com/telerik/kendo-angular/issues/4434
-                // To be fixed in Chrome, remove try..catch afterwards
-                // https://chromestatus.com/feature/5128696823545856
-                // https://issues.chromium.org/issues/41484175
-                try {
-                    // Angular will not remove the element unless the change detection is triggered
-                    removeElement(popupElement);
-                }
-                catch { /* noop */ }
-            },
-            content: component,
-            popup: popupComponentRef,
-            popupAnchorViewportLeave: popupInstance.anchorViewportLeave,
-            popupClose: popupInstance.close,
-            popupElement: popupElement,
-            popupOpen: popupInstance.open,
-            popupPositionChange: popupInstance.positionChange
-        };
-    }
-    appendPopup(nodes, container) {
-        const popupComponentRef = this.createComponent(PopupComponent, nodes, container);
-        if (!container) {
-            this.rootViewContainerNode.appendChild(this.getComponentRootNode(popupComponentRef));
-        }
-        return popupComponentRef;
-    }
-    /**
-     * Gets the HTML element for a component reference.
-     *
-     * @param {ComponentRef<any>} componentRef The component reference.
-     * @returns {HTMLElement} The root HTML element of the component.
-     */
-    getComponentRootNode(componentRef) {
-        return componentRef.location.nativeElement;
-    }
-    /**
-     * Gets the `ComponentFactory` instance by type.
-     *
-     * @param {*} componentClass The component class.
-     * @returns {ComponentFactory<any>} The component factory instance.
-     */
-    getComponentFactory(componentClass) {
-        return this.componentFactoryResolver.resolveComponentFactory(componentClass);
-    }
-    /**
-     * Creates a component reference from a `Component` class.
-     *
-     * @param {*} componentClass The component class.
-     * @param {*} nodes The nodes to project.
-     * @param {ViewContainerRef} container The container to use.
-     * @returns {ComponentRef<any>} The created component reference.
-     */
-    createComponent(componentClass, nodes, container) {
-        const factory = this.getComponentFactory(componentClass);
-        if (container) {
-            return container.createComponent(factory, undefined, this.injector, nodes);
-        }
-        else {
-            const component = factory.create(this.injector, nodes);
-            this.applicationRef.attachView(component.hostView);
-            return component;
-        }
-    }
-    /**
-     * Projects the input options onto the component instance.
-     *
-     * @param {ComponentRef<any>} component The component reference.
-     * @param {*} options The options to project.
-     * @returns {ComponentRef<any>} The updated component reference.
-     */
-    projectComponentInputs(component, options) {
-        Object.getOwnPropertyNames(options)
-            .filter(prop => prop !== 'content' || options.content instanceof TemplateRef)
-            .forEach((prop) => {
-            component.instance[prop] = options[prop];
-        });
-        return component;
-    }
-    /**
-     * Gets the component and nodes to append from the `content` option.
-     *
-     * @param {*} content The content to use.
-     * @returns {any} The component and nodes for projection.
-     */
-    contentFrom(content) {
-        if (!content || content instanceof TemplateRef) {
-            return { component: null, nodes: [[]] };
-        }
-        const component = this.createComponent(content);
-        const nodes = component ? [component.location.nativeElement] : [];
-        return {
-            component: component,
-            nodes: [
-                nodes // <ng-content>
-            ]
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupService, deps: [{ token: i0.ApplicationRef }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: POPUP_CONTAINER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PopupService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: i0.ApplicationRef }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ElementRef, decorators: [{
-                    type: Inject,
-                    args: [POPUP_CONTAINER]
-                }, {
-                    type: Optional
-                }] }] });

package/esm2022/progress-kendo-angular-popup.mjs

@@ -1,8 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';