@progress/kendo-angular-popup 4.0.6-dev.202203161114 → 5.0.0-dev.202204191152

package/dist/es/popup.service.js

@@ -1,254 +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 { ApplicationRef, ComponentFactoryResolver, ElementRef, InjectionToken, Injectable, Injector, Inject, Optional, TemplateRef } from '@angular/core';
-import { PopupComponent } from './popup.component';
-var removeElement = function (element) {
-    if (element && element.parentNode) {
-        element.parentNode.removeChild(element);
-    }
-};
-var ɵ0 = removeElement;
-/**
- * Used to inject the Popup container. If not provided, the first root component of
- * the application is used.
- *
- * > The `POPUP_CONTAINER` can be used only with the [`PopupService`]({% slug service_popup %}) class.
- *
- * @example
- *
- * ```ts-no-run
- * // Import the Popup module
- * import { PopupModule, POPUP_CONTAINER } from '@progress/kendo-angular-popup';
- *
- * // The browser platform with a compiler
- * import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
- *
- * import { ElementRef, 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],
- *     providers: [{
- *       provide: POPUP_CONTAINER,
- *       useFactory: () => {
- *          //return the container ElementRef, where the popup will be injected
- *          return { nativeElement: document.body } as ElementRef;
- *       }
- *     }]
- * })
- * export class AppModule {}
- *
- * // Compile and launch the module
- * platformBrowserDynamic().bootstrapModule(AppModule);
- * ```
- */
-export var POPUP_CONTAINER = new InjectionToken('Popup Container');
-/**
- * A service for opening Popup components dynamically
- * ([see example]({% slug service_popup %})).
- *
- * @export
- * @class PopupService
- */
-var PopupService = /** @class */ (function () {
-    function PopupService(applicationRef, componentFactoryResolver, injector, container) {
-        this.applicationRef = applicationRef;
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.injector = injector;
-        this.container = container;
-    }
-    Object.defineProperty(PopupService.prototype, "rootViewContainer", {
-        /**
-         * Gets the root view container into which the component will be injected.
-         *
-         * @returns {ComponentRef<any>}
-         */
-        get: function () {
-            // https://github.com/angular/angular/blob/4.0.x/packages/core/src/application_ref.ts#L571
-            var rootComponents = this.applicationRef.components || [];
-            if (rootComponents[0]) {
-                return rootComponents[0];
-            }
-            throw new Error("\n            View Container not found! Inject the POPUP_CONTAINER or define a specific ViewContainerRef via the appendTo option.\n            See http://www.telerik.com/kendo-angular-ui/components/popup/api/POPUP_CONTAINER/ for more details.\n        ");
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(PopupService.prototype, "rootViewContainerNode", {
-        /**
-         * Sets or gets the HTML element of the root component container.
-         *
-         * @returns {HTMLElement}
-         */
-        get: function () {
-            return this.container ? this.container.nativeElement : this.getComponentRootNode(this.rootViewContainer);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Opens a Popup component. Created Popups are mounted
-     * in the DOM directly in the root application component.
-     *
-     * @param {PopupSettings} options - The options which define the Popup.
-     * @returns {ComponentRef<PopupComponent>} - A reference to the Popup object.
-     *
-     * @example
-     *
-     * ```ts-no-run
-     * _@Component({
-     *   selector: 'my-app',
-     *   template: `
-     *     <ng-template #template>
-     *      Popup content
-     *     </ng-template>
-     *     <button #anchor kendoButton (click)="open(anchor, template)">Open</button>
-     *   `
-     * })
-     * export class AppComponent {
-     *     public popupRef: PopupRef;
-     *
-     *     constructor( private popupService: PopupService ) {}
-     *
-     *     public open(anchor: ElementRef, template: TemplateRef<any>): void {
-     *         if (this.popupRef) {
-     *              this.popupRef.close();
-     *              this.popupRef = null;
-     *              return;
-     *         }
-     *
-     *         this.popupRef = this.popupService.open({
-     *           anchor: anchor,
-     *           content: template
-     *         });
-     *     }
-     * }
-     * ```
-     */
-    PopupService.prototype.open = function (options) {
-        if (options === void 0) { options = {}; }
-        var _a = this.contentFrom(options.content), component = _a.component, nodes = _a.nodes;
-        var popupComponentRef = this.appendPopup(nodes, options.appendTo);
-        var popupInstance = popupComponentRef.instance;
-        this.projectComponentInputs(popupComponentRef, options);
-        popupComponentRef.changeDetectorRef.detectChanges();
-        if (component) {
-            component.changeDetectorRef.detectChanges();
-        }
-        var popupElement = this.getComponentRootNode(popupComponentRef);
-        return {
-            close: function () {
-                if (component) {
-                    component.destroy();
-                }
-                popupComponentRef.destroy();
-                // Angular will not remove the element unless the change detection is triggered
-                removeElement(popupElement);
-            },
-            content: component,
-            popup: popupComponentRef,
-            popupAnchorViewportLeave: popupInstance.anchorViewportLeave,
-            popupClose: popupInstance.close,
-            popupElement: popupElement,
-            popupOpen: popupInstance.open,
-            popupPositionChange: popupInstance.positionChange
-        };
-    };
-    PopupService.prototype.appendPopup = function (nodes, container) {
-        var 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
-     * @returns {HTMLElement}
-     */
-    PopupService.prototype.getComponentRootNode = function (componentRef) {
-        return componentRef.location.nativeElement;
-    };
-    /**
-     * Gets the `ComponentFactory` instance by its type.
-     *
-     * @param {*} componentClass
-     * @param {*} nodes
-     * @returns {ComponentRef<any>}
-     */
-    PopupService.prototype.getComponentFactory = function (componentClass) {
-        return this.componentFactoryResolver.resolveComponentFactory(componentClass);
-    };
-    /**
-     * Creates a component reference from a `Component` type class.
-     *
-     * @param {*} componentClass
-     * @param {*} nodes
-     * @returns {ComponentRef<any>}
-     */
-    PopupService.prototype.createComponent = function (componentClass, nodes, container) {
-        var factory = this.getComponentFactory(componentClass);
-        if (container) {
-            return container.createComponent(factory, undefined, this.injector, nodes);
-        }
-        else {
-            var component = factory.create(this.injector, nodes);
-            this.applicationRef.attachView(component.hostView);
-            return component;
-        }
-    };
-    /**
-     * Projects the inputs on the component.
-     *
-     * @param {ComponentRef<any>} component
-     * @param {*} options
-     * @returns {ComponentRef<any>}
-     */
-    PopupService.prototype.projectComponentInputs = function (component, options) {
-        Object.getOwnPropertyNames(options)
-            .filter(function (prop) { return prop !== 'content' || options.content instanceof TemplateRef; })
-            .map(function (prop) {
-            component.instance[prop] = options[prop];
-        });
-        return component;
-    };
-    /**
-     * Gets the component and the nodes to append from the `content` option.
-     *
-     * @param {*} content
-     * @returns {any}
-     */
-    PopupService.prototype.contentFrom = function (content) {
-        if (!content || content instanceof TemplateRef) {
-            return { component: null, nodes: [[]] };
-        }
-        var component = this.createComponent(content);
-        var nodes = component ? [component.location.nativeElement] : [];
-        return {
-            component: component,
-            nodes: [
-                nodes // <ng-content>
-            ]
-        };
-    };
-    PopupService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__param(3, Inject(POPUP_CONTAINER)), tslib_1.__param(3, Optional()),
-        tslib_1.__metadata("design:paramtypes", [ApplicationRef,
-            ComponentFactoryResolver,
-            Injector,
-            ElementRef])
-    ], PopupService);
-    return PopupService;
-}());
-export { PopupService };
-export { ɵ0 };

package/dist/es/scale.js

@@ -1,21 +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 { InjectionToken } from '@angular/core';
-/**
- * Used to set the document scale when using 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. Detecting the scale is not reliable and must be set by providing a value for SCALE. See [Support for Document Scale]({% slug documentscale_popup %}).
- *
- * > Using this token is not necessary for user-applied browser zoom.
- *
- * {% meta height:300 %}
- * {% embed_file scale/app.component.ts preview %}
- * {% embed_file shared/app.module.ts %}
- * {% embed_file shared/main.ts %}
- * {% endmeta %}
- *
- *
- */
-export var SCALE = new InjectionToken('Popup Document Scale');

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

@@ -1,64 +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, Inject, Optional } from '@angular/core';
-import { DOMService } from './dom.service';
-import { eitherRect, removeStackingOffset, scaleRect } from '../util';
-import { SCALE } from '../scale';
-/**
- * @hidden
- */
-var AlignService = /** @class */ (function () {
-    function AlignService(_dom, scale) {
-        if (scale === void 0) { scale = 1; }
-        this._dom = _dom;
-        this.scale = scale;
-    }
-    AlignService.prototype.alignElement = function (settings) {
-        var anchor = settings.anchor, element = settings.element, anchorAlign = settings.anchorAlign, elementAlign = settings.elementAlign, margin = settings.margin, offset = settings.offset, positionMode = settings.positionMode;
-        var scale = this.scale || 1;
-        var fixedMode = positionMode === 'fixed' || !this._dom.hasOffsetParent(element);
-        var anchorRect = fixedMode ? this.absoluteRect(anchor, element, offset, scale) : this.relativeRect(anchor, element, offset, scale);
-        var elementRect = scaleRect(this._dom.offset(element.nativeElement), scale);
-        var result = this._dom.align({
-            anchorAlign: anchorAlign,
-            anchorRect: anchorRect,
-            elementAlign: elementAlign,
-            elementRect: elementRect,
-            margin: margin
-        });
-        return result;
-    };
-    AlignService.prototype.absoluteRect = function (anchor, element, offset, scale) {
-        var scrollPos = this.elementScrollPosition(anchor, element);
-        var rect = eitherRect(this._dom.offset(anchor), offset);
-        var stackScale = 2 * scale;
-        var stackScroll = this._dom.stackingElementScroll(element);
-        if (scale !== 1 && stackScroll) {
-            stackScroll.x /= stackScale;
-            stackScroll.y /= stackScale;
-        }
-        var 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);
-    };
-    AlignService.prototype.elementScrollPosition = function (anchor, element) {
-        return anchor ? { x: 0, y: 0 } : this._dom.scrollPosition(element);
-    };
-    AlignService.prototype.relativeRect = function (anchor, element, offset, scale) {
-        var rect = eitherRect(this._dom.position(anchor, element, scale), offset);
-        return scaleRect(rect, scale);
-    };
-    AlignService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__param(1, Inject(SCALE)), tslib_1.__param(1, Optional()),
-        tslib_1.__metadata("design:paramtypes", [DOMService, Number])
-    ], AlignService);
-    return AlignService;
-}());
-export { AlignService };

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

@@ -1,137 +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, isDevMode, EventEmitter } from '@angular/core';
-import { animate, style, AnimationBuilder } from '@angular/animations';
-var LEFT = 'left';
-var RIGHT = 'right';
-var DOWN = 'down';
-var UP = 'up';
-var DEFAULT_TYPE = 'slide';
-var DEFAULT_DURATION = 100;
-var animationTypes = {};
-/* tslint:disable:object-literal-sort-keys */
-animationTypes.expand = function (direction) {
-    var scale = direction === UP || direction === DOWN ? 'scaleY' : 'scaleX';
-    var startScale = 0;
-    var endScale = 1;
-    var 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 = function (direction) {
-    var translate = direction === LEFT || direction === RIGHT ? 'translateX' : 'translateY';
-    var start = direction === RIGHT || direction === DOWN ? -100 : 100;
-    var end = 0;
-    return {
-        start: { transform: translate + "(" + start + "%)" },
-        end: { transform: translate + "(" + end + "%)" }
-    };
-};
-animationTypes.fade = function () {
-    return {
-        start: { opacity: 0 },
-        end: { opacity: 1 }
-    };
-};
-animationTypes.zoom = function () {
-    var start = 0;
-    var end = 1;
-    return {
-        start: { transform: "scale(" + start + ")" },
-        end: { transform: "scale(" + end + ")" }
-    };
-};
-/**
- * @hidden
- */
-var AnimationService = /** @class */ (function () {
-    function AnimationService(animationBuilder) {
-        this.animationBuilder = animationBuilder;
-        this.start = new EventEmitter();
-        this.end = new EventEmitter();
-    }
-    AnimationService.prototype.play = function (element, options, flip) {
-        if (!this.flip || this.flip.horizontal !== flip.horizontal ||
-            this.flip.vertical !== flip.vertical) {
-            this.flip = flip;
-            var type = options.type || DEFAULT_TYPE;
-            var statesFn = animationTypes[type];
-            if (statesFn) {
-                var direction = this.getDirection(flip, options);
-                var 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.");
-            }
-        }
-    };
-    AnimationService.prototype.ngOnDestroy = function () {
-        this.stopPlayer();
-    };
-    AnimationService.prototype.playStates = function (element, states, options) {
-        var _this = this;
-        this.stopPlayer();
-        var duration = options.duration || DEFAULT_DURATION;
-        var factory = this.animationBuilder.build([
-            style(states.start),
-            animate(duration + "ms ease-in", style(states.end))
-        ]);
-        var player = this.player = factory.create(element);
-        player.onDone(function () {
-            _this.end.emit();
-            _this.stopPlayer();
-        });
-        this.start.emit();
-        player.play();
-    };
-    AnimationService.prototype.getDirection = function (flip, options) {
-        var 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;
-    };
-    AnimationService.prototype.stopPlayer = function () {
-        if (this.player) {
-            this.player.destroy();
-            this.player = null;
-        }
-    };
-    AnimationService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [AnimationBuilder])
-    ], AnimationService);
-    return AnimationService;
-}());
-export { AnimationService };

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

@@ -1,158 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable } from '@angular/core';
-import { 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';
-var STYLES = [
-    'font-size',
-    'font-family',
-    'font-stretch',
-    'font-style',
-    'font-weight',
-    'line-height'
-];
-/**
- * @hidden
- */
-var DOMService = /** @class */ (function () {
-    function DOMService() {
-    }
-    DOMService.prototype.addOffset = function (current, addition) {
-        return {
-            left: current.left + addition.left,
-            top: current.top + addition.top
-        };
-    };
-    DOMService.prototype.addScroll = function (rect, scroll) {
-        return addScroll(rect, scroll);
-    };
-    DOMService.prototype.align = function (settings) {
-        return align(settings);
-    };
-    DOMService.prototype.boundingOffset = function (el) {
-        return boundingOffset(el);
-    };
-    DOMService.prototype.getFontStyles = function (el) {
-        var window = this.getWindow();
-        if (!window || !el) {
-            return [];
-        }
-        var computedStyles = window.getComputedStyle(el);
-        return STYLES.map(function (font) { return ({ key: font, value: computedStyles[font] }); });
-    };
-    DOMService.prototype.getWindow = function () {
-        return isWindowAvailable() ? window : null;
-    };
-    DOMService.prototype.hasOffsetParent = function (el) {
-        if (!el) {
-            return false;
-        }
-        return !!this.nativeElement(el).offsetParent;
-    };
-    DOMService.prototype.offset = function (el) {
-        if (!el) {
-            return null;
-        }
-        return offset(el);
-    };
-    DOMService.prototype.offsetAtPoint = function (el, currentLocation) {
-        if (!el) {
-            return null;
-        }
-        var element = this.nativeElement(el);
-        var _a = element.style, left = _a.left, top = _a.top, transition = _a.transition;
-        element.style.transition = 'none';
-        element.style.left = currentLocation.left + "px";
-        element.style.top = currentLocation.top + "px";
-        var currentOffset = offset(element);
-        element.style.left = left;
-        element.style.top = top;
-        // prevents elements with transition to be animated because of the change
-        // tslint:disable-next-line:no-unused-expression
-        element.offsetHeight;
-        element.style.transition = transition;
-        return currentOffset;
-    };
-    DOMService.prototype.nativeElement = function (el) {
-        if (!el) {
-            return null;
-        }
-        return el.nativeElement || el;
-    };
-    DOMService.prototype.position = function (element, popup, scale) {
-        if (scale === void 0) { scale = 1; }
-        if (!element || !popup) {
-            return null;
-        }
-        return positionWithScroll(element, this.nativeElement(popup), scale);
-    };
-    DOMService.prototype.removeScroll = function (rect, scroll) {
-        return removeScroll(rect, scroll);
-    };
-    DOMService.prototype.restrictToView = function (settings) {
-        return restrictToView(settings);
-    };
-    DOMService.prototype.scrollPosition = function (el) {
-        return scrollPosition(this.nativeElement(el));
-    };
-    DOMService.prototype.scrollableParents = function (el) {
-        return scrollableParents(el);
-    };
-    DOMService.prototype.stackingElementOffset = function (el) {
-        var relativeContextElement = this.getRelativeContextElement(el);
-        if (!relativeContextElement) {
-            return null;
-        }
-        return offset(relativeContextElement);
-    };
-    DOMService.prototype.stackingElementScroll = function (el) {
-        var relativeContextElement = this.getRelativeContextElement(el);
-        if (!relativeContextElement) {
-            return { x: 0, y: 0 };
-        }
-        return {
-            x: relativeContextElement.scrollLeft,
-            y: relativeContextElement.scrollTop
-        };
-    };
-    DOMService.prototype.getRelativeContextElement = function (el) {
-        if (!el || !hasRelativeStackingContext()) {
-            return null;
-        }
-        var parent = this.nativeElement(el).parentElement;
-        while (parent) {
-            if (window.getComputedStyle(parent).transform !== 'none') {
-                return parent;
-            }
-            parent = parent.parentElement;
-        }
-        return null;
-    };
-    DOMService.prototype.useRelativePosition = function (el) {
-        return !!this.getRelativeContextElement(el);
-    };
-    DOMService.prototype.windowViewPort = function (el) {
-        return getWindowViewPort(this.nativeElement(el));
-    };
-    DOMService.prototype.zIndex = function (anchor, container) {
-        return zIndex(anchor, this.nativeElement(container));
-    };
-    DOMService.prototype.zoomLevel = function () {
-        if (!isDocumentAvailable() || !isWindowAvailable()) {
-            return 1;
-        }
-        return parseFloat((document.documentElement.clientWidth / window.innerWidth).toFixed(2)) || 1;
-    };
-    DOMService.prototype.isZoomed = function () {
-        return this.zoomLevel() > 1;
-    };
-    DOMService = tslib_1.__decorate([
-        Injectable()
-    ], DOMService);
-    return DOMService;
-}());
-export { DOMService };

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

@@ -1,53 +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 { Inject, Injectable, Optional } from '@angular/core';
-import { DOMService } from './dom.service';
-import { eitherRect, scaleRect } from '../util';
-import { SCALE } from '../scale';
-/**
- * @hidden
- */
-var PositionService = /** @class */ (function () {
-    function PositionService(_dom, scale) {
-        if (scale === void 0) { scale = 1; }
-        this._dom = _dom;
-        this.scale = scale;
-    }
-    PositionService.prototype.positionElement = function (settings) {
-        var anchor = settings.anchor, currentLocation = settings.currentLocation, element = settings.element, anchorAlign = settings.anchorAlign, elementAlign = settings.elementAlign, collisions = settings.collisions, margin = settings.margin;
-        var dom = this._dom;
-        var scale = this.scale || 1;
-        var elementOffset = dom.offsetAtPoint(element, currentLocation);
-        var elementRect = scaleRect(elementOffset, scale);
-        var anchorOffset = scaleRect(dom.offset(anchor), scale);
-        var anchorRect = eitherRect(anchorOffset, currentLocation);
-        var viewPort = settings.viewPort || dom.windowViewPort(element);
-        viewPort.width = viewPort.width / scale;
-        viewPort.height = viewPort.height / scale;
-        var result = dom.restrictToView({
-            anchorAlign: anchorAlign,
-            anchorRect: anchorRect,
-            collisions: collisions,
-            elementAlign: elementAlign,
-            elementRect: elementRect,
-            margin: margin,
-            viewPort: viewPort
-        });
-        var offset = dom.addOffset(currentLocation, result.offset);
-        return {
-            flip: result.flip,
-            flipped: result.flipped,
-            offset: offset
-        };
-    };
-    PositionService = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__param(1, Inject(SCALE)), tslib_1.__param(1, Optional()),
-        tslib_1.__metadata("design:paramtypes", [DOMService, Number])
-    ], PositionService);
-    return PositionService;
-}());
-export { PositionService };