@progress/kendo-angular-dialog 6.0.2 → 7.0.0-dev.202204191040

package/dist/es/window/drag-resize.service.js

@@ -1,351 +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, NgZone, EventEmitter } from "@angular/core";
-import { Subscription } from 'rxjs';
-import { tap, map, switchMap, takeUntil } from 'rxjs/operators';
-import { isPresent, OFFSET_STYLES, preventDefault } from '../common/util';
-import { scrollPosition, offset, getDocumentElement, positionWithScroll, getWindowViewPort } from '@progress/kendo-popup-common';
-/**
- * @hidden
- */
-var newZIndex = 10002;
-/**
- * @hidden
- */
-var DEFAULT_OPTIONS = {
-    draggable: true,
-    height: null,
-    left: null,
-    minHeight: 100,
-    minWidth: 120,
-    position: 'absolute',
-    resizable: true,
-    state: 'default',
-    top: null,
-    width: null
-};
-/**
- * @hidden
- */
-var createMoveStream = function (el, ev) { return function (mouseDown) {
-    return el.kendoDrag
-        .pipe(takeUntil(el.kendoRelease.pipe(tap(function () { ev.emit(); }))), map(function (_a) {
-        var pageX = _a.pageX, pageY = _a.pageY;
-        return ({
-            originalX: mouseDown.pageX,
-            originalY: mouseDown.pageY,
-            pageX: pageX,
-            pageY: pageY
-        });
-    }));
-}; };
-var ɵ0 = createMoveStream;
-/**
- * @hidden
- */
-var DragResizeService = /** @class */ (function () {
-    function DragResizeService(ngZone) {
-        this.ngZone = ngZone;
-        this.close = new EventEmitter();
-        this.focus = new EventEmitter();
-        this.change = new EventEmitter();
-        this.stateChange = new EventEmitter();
-        this.dragStart = new EventEmitter();
-        this.dragEnd = new EventEmitter();
-        this.resizeStart = new EventEmitter();
-        this.resizeEnd = new EventEmitter();
-        this.options = Object.assign({}, DEFAULT_OPTIONS);
-        this.lastAction = null;
-        this.subscriptions = new Subscription();
-        this.dragSubscription = new Subscription();
-    }
-    DragResizeService.prototype.ngOnDestroy = function () {
-        if (this.subscriptions) {
-            this.subscriptions.unsubscribe();
-        }
-        if (this.dragSubscription) {
-            this.dragSubscription.unsubscribe();
-        }
-    };
-    DragResizeService.prototype.init = function (el) {
-        var state = this.options.state;
-        var options = this.options;
-        this.window = el;
-        if (state !== 'default') {
-            this.restoreOptions = Object.assign({}, options);
-        }
-        if (state === 'minimized') {
-            options.height = 0;
-            options.minHeight = 0;
-        }
-        if (state === 'maximized') {
-            options.position = 'fixed';
-        }
-    };
-    DragResizeService.prototype.onDrag = function (el) {
-        var _this = this;
-        this.subscriptions.add(this.ngZone.runOutsideAngular(function () {
-            var startPosition;
-            var dragStarted;
-            _this.dragSubscription = el.kendoPress
-                .pipe(tap(function (ev) {
-                if (!ev.isTouch) {
-                    preventDefault(ev);
-                }
-                _this.focus.emit();
-                startPosition = _this.currentPosition();
-                dragStarted = false;
-            }), switchMap(createMoveStream(el, _this.dragEnd)))
-                .subscribe(function (_a) {
-                var pageX = _a.pageX, pageY = _a.pageY, originalX = _a.originalX, originalY = _a.originalY;
-                if (!dragStarted) {
-                    _this.ensureWidth();
-                    _this.dragStart.emit();
-                    dragStarted = true;
-                }
-                _this.handleDrag({
-                    originalX: originalX, originalY: originalY,
-                    pageX: pageX, pageY: pageY, startPosition: startPosition
-                });
-            });
-        }));
-    };
-    DragResizeService.prototype.handleDrag = function (_a) {
-        var originalX = _a.originalX, originalY = _a.originalY, pageX = _a.pageX, pageY = _a.pageY, startPosition = _a.startPosition;
-        this.options.left = startPosition.x + pageX - originalX;
-        this.options.top = startPosition.y + pageY - originalY;
-        if (this.options.state === 'minimized' && isPresent(this.restoreOptions)) {
-            this.restoreOptions.left = this.options.left;
-            this.restoreOptions.top = this.options.top;
-        }
-        this.change.emit({
-            left: startPosition.x + pageX - originalX,
-            top: startPosition.y + pageY - originalY
-        });
-    };
-    DragResizeService.prototype.onResize = function (handle, direction) {
-        var _this = this;
-        this.subscriptions.add(this.ngZone.runOutsideAngular(function () {
-            var startOffsetAndPosition;
-            var resizeStarted = false;
-            handle.kendoPress.pipe(tap(function (ev) {
-                preventDefault(ev);
-                _this.focus.emit();
-                startOffsetAndPosition = _this.currentOffsetAndPosition();
-                resizeStarted = false;
-            }), switchMap(createMoveStream(handle, _this.resizeEnd)))
-                .subscribe(function (_a) {
-                var pageX = _a.pageX, pageY = _a.pageY, originalX = _a.originalX, originalY = _a.originalY;
-                if (!resizeStarted) {
-                    _this.resizeStart.emit(direction);
-                    resizeStarted = true;
-                }
-                var deltaX = pageX - originalX;
-                var deltaY = pageY - originalY;
-                _this.handleResize(startOffsetAndPosition, direction, deltaX, deltaY);
-            });
-        }));
-    };
-    DragResizeService.prototype.handleResize = function (initial, dir, deltaX, deltaY) {
-        var _this = this;
-        var old = this.options;
-        var ev = {};
-        if (dir.indexOf('e') >= 0) {
-            var newWidth = initial.width + deltaX;
-            if (newWidth !== old.width && newWidth >= old.minWidth) {
-                ev.width = newWidth;
-            }
-        }
-        if (dir.indexOf('n') >= 0) {
-            var newHeight = initial.height - deltaY;
-            var newTop = initial.y + deltaY;
-            if (newHeight !== old.height && newHeight >= old.minHeight && newTop !== old.top) {
-                ev.height = newHeight;
-                ev.top = newTop;
-            }
-        }
-        if (dir.indexOf('s') >= 0) {
-            var newHeight = initial.height + deltaY;
-            if (newHeight !== old.height && newHeight >= old.minHeight) {
-                ev.height = newHeight;
-            }
-        }
-        if (dir.indexOf('w') >= 0) {
-            var newLeft = initial.x + deltaX;
-            var newWidth = initial.width - deltaX;
-            if (newWidth !== old.width && newWidth >= old.minWidth && newLeft !== old.left) {
-                ev.width = newWidth;
-                ev.left = newLeft;
-            }
-        }
-        if (isPresent(ev.width) || isPresent(ev.height)) {
-            OFFSET_STYLES.forEach(function (style) {
-                if (isPresent(ev[style])) {
-                    _this.options[style] = ev[style];
-                }
-            });
-            this.change.emit(ev);
-        }
-    };
-    DragResizeService.prototype.restoreAction = function () {
-        this.lastAction = 'restore';
-        this.defaultState();
-    };
-    DragResizeService.prototype.defaultState = function () {
-        if (isPresent(this.restoreOptions)) {
-            this.options = Object.assign({}, this.restoreOptions);
-        }
-        this.options.state = 'default';
-        this.stateChange.emit('default');
-    };
-    DragResizeService.prototype.storeOptions = function () {
-        this.restoreOptions = Object.assign({}, this.options);
-    };
-    DragResizeService.prototype.maximizeAction = function () {
-        this.lastAction = 'maximize';
-        this.maximizeState();
-    };
-    DragResizeService.prototype.maximizeState = function () {
-        this.storeOptions();
-        var wnd = this.windowViewPort;
-        this.options = Object.assign({}, this.options, {
-            height: wnd.height,
-            left: 0,
-            position: 'fixed',
-            state: 'maximized',
-            top: 0,
-            width: wnd.width
-        });
-        this.stateChange.emit('maximized');
-    };
-    DragResizeService.prototype.minimizeAction = function () {
-        this.lastAction = 'minimize';
-        this.minimizeState();
-    };
-    DragResizeService.prototype.minimizeState = function () {
-        this.storeOptions();
-        this.options = Object.assign({}, this.options, {
-            height: null,
-            minHeight: 0,
-            state: 'minimized'
-        });
-        this.stateChange.emit('minimized');
-    };
-    /**
-     * Handles manual changes of the 'state' property.
-     * Required to distinguish them from action clicks.
-     */
-    DragResizeService.prototype.applyManualState = function () {
-        var state = this.options.state;
-        switch (state) {
-            case 'default':
-                this.clearHeight();
-                this.defaultState();
-                break;
-            case 'maximized':
-                this.clearHeight();
-                this.maximizeState();
-                break;
-            case 'minimized':
-                this.minimizeState();
-                break;
-            default:
-                break;
-        }
-    };
-    DragResizeService.prototype.closeAction = function () {
-        this.close.emit();
-    };
-    DragResizeService.prototype.ensureWidth = function () {
-        var windowOffset = offset(this.window.nativeElement);
-        if (!isPresent(this.options.width)) {
-            this.options.width = windowOffset.width;
-            this.change.emit({ width: windowOffset.width });
-        }
-    };
-    DragResizeService.prototype.clearHeight = function () {
-        if (this.options.height === 0) {
-            delete this.options.height;
-        }
-        if (this.options.minHeight === 0) {
-            delete this.options.minHeight;
-        }
-    };
-    DragResizeService.prototype.center = function () {
-        if (this.options.state === 'maximized') {
-            return;
-        }
-        var scroll = scrollPosition(this.window.nativeElement);
-        var wnd = this.windowViewPort;
-        var wrapper = offset(this.window.nativeElement);
-        var ev = {};
-        if (!isPresent(this.options.left)) {
-            this.options.left = scroll.x + Math.max(0, (wnd.width - wrapper.width) / 2);
-            ev.left = this.options.left;
-        }
-        if (!isPresent(this.options.top)) {
-            this.options.top = scroll.y + Math.max(0, (wnd.height - wrapper.height) / 2);
-            ev.top = this.options.top;
-        }
-        this.change.emit(ev);
-    };
-    DragResizeService.prototype.currentOffsetAndPosition = function () {
-        var o = this.options;
-        var off = offset(this.window.nativeElement);
-        return Object.assign({}, this.currentPosition(), {
-            height: o.height ? o.height : off.height,
-            width: o.width ? o.width : off.width
-        });
-    };
-    DragResizeService.prototype.currentPosition = function () {
-        var o = this.options;
-        if (!o.top || !o.left) {
-            this.setPosition();
-        }
-        return {
-            x: this.options.left,
-            y: this.options.top
-        };
-    };
-    DragResizeService.prototype.setPosition = function () {
-        var wrapper = positionWithScroll(this.window.nativeElement, getDocumentElement(this.window.nativeElement));
-        this.options.left = wrapper.left;
-        this.options.top = wrapper.top;
-    };
-    DragResizeService.prototype.setRestoreOption = function (style, value) {
-        if (isPresent(this.restoreOptions)) {
-            this.restoreOptions[style] = value;
-        }
-    };
-    Object.defineProperty(DragResizeService.prototype, "nextPossibleZIndex", {
-        get: function () {
-            return newZIndex;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DragResizeService.prototype, "nextZIndex", {
-        get: function () {
-            return newZIndex++;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(DragResizeService.prototype, "windowViewPort", {
-        get: function () {
-            return getWindowViewPort(this.window.nativeElement);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    DragResizeService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [NgZone])
-    ], DragResizeService);
-    return DragResizeService;
-}());
-export { DragResizeService };
-export { ɵ0 };

package/dist/es/window/navigation.service.js

@@ -1,155 +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, NgZone } from "@angular/core";
-import { DragResizeService } from './drag-resize.service';
-import { isPresent, OFFSET_STYLES, Keys } from '../common/util';
-/**
- * @hidden
- */
-var NavigationService = /** @class */ (function () {
-    function NavigationService(window, ngZone) {
-        this.window = window;
-        this.ngZone = ngZone;
-    }
-    NavigationService.prototype.process = function (ev) {
-        var _this = this;
-        var key = ev.keyCode;
-        switch (key) {
-            case Keys.up:
-            case Keys.down:
-            case Keys.left:
-            case Keys.right: {
-                ev.preventDefault();
-                this.ngZone.run(function () {
-                    _this.handleArrow(key, ev);
-                });
-                break;
-            }
-            case Keys.esc:
-                this.ngZone.run(function () {
-                    _this.handleEscape();
-                });
-                break;
-            default:
-                break;
-        }
-    };
-    NavigationService.prototype.handleArrow = function (key, ev) {
-        var options = this.window.options;
-        if (ev.altKey) {
-            this.handleStateChange(key, options.state);
-            return;
-        }
-        if ((ev.ctrlKey || ev.metaKey) && options.state === 'default') {
-            this.handleResize(key);
-        }
-        else {
-            this.handleDrag(key);
-        }
-    };
-    NavigationService.prototype.handleEscape = function () {
-        this.window.closeAction();
-    };
-    NavigationService.prototype.handleDrag = function (key) {
-        var options = this.window.options;
-        if (!options.draggable) {
-            return;
-        }
-        var offset = this.window.currentOffsetAndPosition();
-        var restoreOptions = this.window.restoreOptions;
-        var ev = {};
-        var delta = 10;
-        if (key === Keys.left || key === Keys.up) {
-            delta *= -1;
-        }
-        switch (key) {
-            case Keys.left:
-            case Keys.right: {
-                ev.left = offset.x + delta;
-                options.left = ev.left;
-                break;
-            }
-            case Keys.up:
-            case Keys.down: {
-                ev.top = offset.y + delta;
-                options.top = ev.top;
-                break;
-            }
-            default:
-                break;
-        }
-        if (options.state === 'minimized' && isPresent(restoreOptions)) {
-            restoreOptions.left = options.left;
-            restoreOptions.top = options.top;
-        }
-        this.window.change.emit(ev);
-    };
-    NavigationService.prototype.handleResize = function (key) {
-        var _this = this;
-        var options = this.window.options;
-        if (!options.resizable) {
-            return;
-        }
-        var offset = this.window.currentOffsetAndPosition();
-        var newWidth;
-        var newHeight;
-        var ev = {};
-        var delta = 10;
-        if (key === Keys.left || key === Keys.up) {
-            delta *= -1;
-        }
-        switch (key) {
-            case Keys.left:
-            case Keys.right: {
-                newWidth = offset.width + delta;
-                if (newWidth !== options.width && newWidth >= options.minWidth) {
-                    ev.width = newWidth;
-                }
-                break;
-            }
-            case Keys.up:
-            case Keys.down: {
-                newHeight = offset.height + delta;
-                if (newHeight !== options.height && newHeight >= options.minHeight) {
-                    ev.height = newHeight;
-                }
-                break;
-            }
-            default:
-                break;
-        }
-        if (isPresent(ev.width) || isPresent(ev.height)) {
-            OFFSET_STYLES.forEach(function (style) {
-                if (isPresent(ev[style])) {
-                    _this.window.options[style] = ev[style];
-                }
-            });
-            this.window.change.emit(ev);
-        }
-    };
-    NavigationService.prototype.handleStateChange = function (key, state) {
-        if ((state === 'minimized' && key === Keys.up) ||
-            (state === 'maximized' && key === Keys.down)) {
-            this.window.restoreAction();
-            return;
-        }
-        if (state === 'default') {
-            if (key === Keys.up) {
-                this.window.maximizeAction();
-            }
-            else if (key === Keys.down) {
-                this.window.minimizeAction();
-            }
-        }
-    };
-    NavigationService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [DragResizeService,
-            NgZone])
-    ], NavigationService);
-    return NavigationService;
-}());
-export { NavigationService };

package/dist/es/window/window-container.directive.js

@@ -1,31 +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 { Directive, ViewContainerRef } from '@angular/core';
-import { WindowContainerService } from './window-container.service';
-/**
- * Provides an insertion point for the Windows which are created through the
- * Window service ([see example]({% slug api_dialog_windowservice %}#toc-open)).
- * Created Windows will be mounted after that element.
- *
- * @example
- * ```html-no-run
- * <div kendoWindowContainer></div>
- * ```
- */
-var WindowContainerDirective = /** @class */ (function () {
-    function WindowContainerDirective(container, service) {
-        service.container = container;
-    }
-    WindowContainerDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoWindowContainer]'
-        }),
-        tslib_1.__metadata("design:paramtypes", [ViewContainerRef,
-            WindowContainerService])
-    ], WindowContainerDirective);
-    return WindowContainerDirective;
-}());
-export { WindowContainerDirective };

package/dist/es/window/window-container.service.js

@@ -1,31 +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';
-/**
- * @hidden
- */
-var WindowContainerService = /** @class */ (function () {
-    function WindowContainerService() {
-    }
-    WindowContainerService_1 = WindowContainerService;
-    Object.defineProperty(WindowContainerService.prototype, "container", {
-        get: function () {
-            return WindowContainerService_1.container;
-        },
-        set: function (container) {
-            WindowContainerService_1.container = container;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    var WindowContainerService_1;
-    WindowContainerService.container = null;
-    WindowContainerService = WindowContainerService_1 = tslib_1.__decorate([
-        Injectable()
-    ], WindowContainerService);
-    return WindowContainerService;
-}());
-export { WindowContainerService };

package/dist/es/window/window-resize-handle.directive.js

@@ -1,78 +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 { Directive, Host, ElementRef, Input, HostBinding, Renderer2 } from '@angular/core';
-import { DraggableDirective } from '@progress/kendo-angular-common';
-import { DragResizeService } from './drag-resize.service';
-import { Subscription, of, merge } from 'rxjs';
-/**
- * @hidden
- */
-var ResizeHandleDirective = /** @class */ (function () {
-    function ResizeHandleDirective(draggable, el, renderer, service) {
-        this.draggable = draggable;
-        this.el = el;
-        this.renderer = renderer;
-        this.service = service;
-        this.subscriptions = new Subscription();
-    }
-    Object.defineProperty(ResizeHandleDirective.prototype, "hostClass", {
-        get: function () {
-            return true;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    ResizeHandleDirective.prototype.ngOnInit = function () {
-        var _this = this;
-        this.setDisplay();
-        this.renderer.addClass(this.el.nativeElement, 'k-resize-' + this.direction);
-        this.subscriptions.add(of(this.draggable).subscribe(function (handle) {
-            _this.service.onResize(handle, _this.direction);
-        }));
-        this.subscriptions.add(this.service.resizeStart.subscribe(function (dir) {
-            if (dir !== _this.direction) {
-                _this.setDisplay('none');
-            }
-        }));
-        this.subscriptions.add(this.service.dragStart.subscribe(function () {
-            _this.setDisplay('none');
-        }));
-        this.subscriptions.add(merge(this.service.resizeEnd, this.service.dragEnd).subscribe(function () {
-            _this.setDisplay('block');
-        }));
-        this.subscriptions.add(this.service.stateChange.subscribe(function (state) {
-            _this.setDisplay(state === 'default' ? 'block' : 'none');
-        }));
-    };
-    ResizeHandleDirective.prototype.ngOnDestroy = function () {
-        this.subscriptions.unsubscribe();
-    };
-    ResizeHandleDirective.prototype.setDisplay = function (value) {
-        if (value === void 0) { value = 'block'; }
-        this.renderer.setStyle(this.el.nativeElement, 'display', this.service.options.state === 'default' ? value : 'none');
-    };
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", String)
-    ], ResizeHandleDirective.prototype, "direction", void 0);
-    tslib_1.__decorate([
-        HostBinding('class.k-resize-handle'),
-        tslib_1.__metadata("design:type", Boolean),
-        tslib_1.__metadata("design:paramtypes", [])
-    ], ResizeHandleDirective.prototype, "hostClass", null);
-    ResizeHandleDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoWindowResizeHandle]'
-        }),
-        tslib_1.__param(0, Host()),
-        tslib_1.__metadata("design:paramtypes", [DraggableDirective,
-            ElementRef,
-            Renderer2,
-            DragResizeService])
-    ], ResizeHandleDirective);
-    return ResizeHandleDirective;
-}());
-export { ResizeHandleDirective };

package/dist/es/window/window-settings.js

@@ -1,34 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * The settings for the Window actions when the Window is opened through `WindowService`
- * ([see example]({% slug api_dialog_windowservice %}#toc-open)).
- */
-var WindowSettings = /** @class */ (function () {
-    function WindowSettings() {
-    }
-    return WindowSettings;
-}());
-export { WindowSettings };
-/**
- * Indicates that the **Close** button of a Window that is opened through `WindowService` is clicked.
- */
-var WindowCloseResult = /** @class */ (function () {
-    function WindowCloseResult() {
-    }
-    return WindowCloseResult;
-}());
-export { WindowCloseResult };
-/**
- * Holds references to the object instance of the Window.
- * Controls the Windows that were opened through `WindowService`
- * ([see example]({% slug api_dialog_windowservice %}#toc-open)).
- */
-var WindowRef = /** @class */ (function () {
-    function WindowRef() {
-    }
-    return WindowRef;
-}());
-export { WindowRef };