@progress/kendo-vue-popup 3.5.0 → 3.5.1-dev.202208150613

package/dist/esm/models/Position.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/positionElementSettings.d.ts

@@ -0,0 +1,13 @@
+import { AlignStrategy, CollisionStrategy, OffsetPosition, ViewPort } from '@progress/kendo-popup-common';
+/**
+ * @hidden
+ */
+export interface PositionElementSettings {
+    anchor?: HTMLElement;
+    anchorAlign: AlignStrategy;
+    collisions: CollisionStrategy;
+    currentLocation: OffsetPosition;
+    element: HTMLElement;
+    elementAlign: AlignStrategy;
+    viewPort?: ViewPort;
+}

package/dist/esm/models/positionElementSettings.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/package-metadata.d.ts

@@ -0,0 +1,5 @@
+import { PackageMetadata } from '@progress/kendo-licensing';
+/**
+ * @hidden
+ */
+export declare const packageMetadata: PackageMetadata;

package/dist/esm/package-metadata.js

@@ -0,0 +1,11 @@
+/**
+ * @hidden
+ */
+export var packageMetadata = {
+    name: '@progress/kendo-vue-popup',
+    productName: 'Kendo UI for Vue',
+    productCodes: ['KENDOUIVUE', 'KENDOUICOMPLETE'],
+    publishDate: 1660542994,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-vue-ui/my-license/?utm_medium=product&utm_source=kendovue&utm_campaign=kendo-ui-vue-purchase-license-keys-warning'
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+                    "type": "module"
+                 }

package/dist/esm/services/alignService.d.ts

@@ -0,0 +1,14 @@
+import { DOMService } from './domService';
+import { OffsetPosition as Offset } from '@progress/kendo-popup-common';
+import { AlignElementSettings } from '../models/AlignElementSettings';
+/**
+ * @hidden
+ */
+export declare class AlignService {
+    private _dom;
+    constructor(_dom: DOMService);
+    alignElement(settings: AlignElementSettings): Offset;
+    private absoluteRect;
+    private elementScrollPosition;
+    private relativeRect;
+}

package/dist/esm/services/alignService.js

@@ -0,0 +1,43 @@
+import { eitherRect, removeStackingOffset } from '../util.js';
+/**
+ * @hidden
+ */
+var AlignService = /** @class */ (function () {
+    function AlignService(_dom) {
+        this._dom = _dom;
+    }
+    AlignService.prototype.alignElement = function (settings) {
+        var anchor = settings.anchor, element = settings.element, anchorAlign = settings.anchorAlign, elementAlign = settings.elementAlign, offset = settings.offset;
+        var fixedMode = !this._dom.hasOffsetParent(element);
+        var anchorRect = fixedMode ?
+            this.absoluteRect(anchor, element, offset) :
+            this.relativeRect(anchor, element, offset);
+        return this._dom.align({
+            anchorAlign: anchorAlign,
+            anchorRect: anchorRect,
+            elementAlign: elementAlign,
+            elementRect: this._dom.offset(element)
+        });
+    };
+    AlignService.prototype.absoluteRect = function (anchor, element, offset) {
+        var dom = this._dom;
+        var rect = eitherRect(dom.offset(anchor), offset);
+        var stackingOffset = dom.stackingElementOffset(element);
+        var removedOffset = removeStackingOffset(rect, stackingOffset);
+        var stackingScroll = dom.stackingElementScroll(element);
+        var withScroll = dom.addScroll(removedOffset, stackingScroll);
+        var scrollPosition = this.elementScrollPosition(anchor, element);
+        var result = dom.removeScroll(withScroll, scrollPosition);
+        result.left += window.scrollX || window.pageXOffset;
+        result.top += window.scrollY || window.pageYOffset;
+        return result;
+    };
+    AlignService.prototype.elementScrollPosition = function (anchor, element) {
+        return anchor ? { x: 0, y: 0 } : this._dom.scrollPosition(element);
+    };
+    AlignService.prototype.relativeRect = function (anchor, element, offset) {
+        return eitherRect(this._dom.position(anchor, element), offset);
+    };
+    return AlignService;
+}());
+export { AlignService };

package/dist/esm/services/domService.d.ts

@@ -0,0 +1,34 @@
+import { AlignSettings, BoundingRect, ElementRect, OffsetPosition, PositionSettings, ScrollInfo, ViewPort } from '@progress/kendo-popup-common';
+import { Position } from '../models/Position';
+/**
+ * @hidden
+ */
+export declare class DOMService {
+    addOffset(current: OffsetPosition, addition: OffsetPosition): OffsetPosition;
+    align(settings: AlignSettings): OffsetPosition;
+    boundingOffset(el: HTMLElement): BoundingRect;
+    getWindow(): Window & typeof globalThis;
+    isBodyOffset(el: HTMLElement): boolean;
+    hasOffsetParent(el: HTMLElement): boolean | null;
+    offset(el: HTMLElement): ElementRect;
+    staticOffset(element: HTMLElement): ElementRect;
+    position(element: HTMLElement, popup: HTMLElement): ElementRect;
+    relativeOffset(el: HTMLElement, currentLocation: OffsetPosition): ElementRect;
+    addScroll(rect: ElementRect, scroll: ScrollInfo): ElementRect;
+    removeScroll(rect: ElementRect, scroll: ScrollInfo): ElementRect;
+    restrictToView(settings: PositionSettings): Position;
+    scrollPosition(el: HTMLElement): ScrollInfo;
+    scrollableParents(el: HTMLElement): Array<HTMLElement>;
+    stackingElementOffset(el: HTMLElement): ElementRect;
+    stackingElementScroll(el: HTMLElement): ScrollInfo;
+    stackingElementViewPort(el: HTMLElement): {
+        height: number;
+        width: number;
+    };
+    getRelativeContextElement(el: HTMLElement): HTMLElement;
+    useRelativePosition(el: HTMLElement): boolean;
+    windowViewPort(el: HTMLElement): ViewPort;
+    zIndex(anchor: HTMLElement, container: HTMLElement): number;
+    zoomLevel(): number;
+    isZoomed(): boolean;
+}

package/dist/esm/services/domService.js

@@ -0,0 +1,139 @@
+import { align, applyLocationOffset, boundingOffset, getWindowViewPort, isBodyOffset, offset, positionWithScroll, restrictToView, addScroll, removeScroll, scrollPosition, siblingContainer } from '@progress/kendo-popup-common';
+import { isDocumentAvailable, isWindowAvailable, HAS_RELATIVE_STACKING_CONTEXT, scrollableParents, zIndex } from '../util.js';
+/**
+ * @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.align = function (settings) {
+        return align(settings);
+    };
+    DOMService.prototype.boundingOffset = function (el) {
+        return boundingOffset(el);
+    };
+    DOMService.prototype.getWindow = function () {
+        return isWindowAvailable() ? window : null;
+    };
+    DOMService.prototype.isBodyOffset = function (el) {
+        return isBodyOffset(el);
+    };
+    DOMService.prototype.hasOffsetParent = function (el) {
+        if (!el) {
+            return false;
+        }
+        var offsetParentEl = el.offsetParent;
+        return offsetParentEl &&
+            !(offsetParentEl.nodeName === 'BODY' &&
+                window.getComputedStyle(offsetParentEl).position === 'static');
+    };
+    DOMService.prototype.offset = function (el) {
+        if (!el) {
+            return null;
+        }
+        return offset(el);
+    };
+    DOMService.prototype.staticOffset = function (element) {
+        if (!element) {
+            return null;
+        }
+        var _a = element.style, left = _a.left, top = _a.top;
+        element.style.left = '0px';
+        element.style.top = '0px';
+        var currentOffset = offset(element);
+        element.style.left = left;
+        element.style.top = top;
+        return currentOffset;
+    };
+    DOMService.prototype.position = function (element, popup) {
+        if (!element || !popup) {
+            return null;
+        }
+        var parentSibling = siblingContainer(element, popup);
+        return positionWithScroll(element, parentSibling);
+    };
+    DOMService.prototype.relativeOffset = function (el, currentLocation) {
+        return applyLocationOffset(this.offset(el), currentLocation, this.isBodyOffset(el));
+    };
+    DOMService.prototype.addScroll = function (rect, scroll) {
+        return addScroll(rect, scroll);
+    };
+    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(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.stackingElementViewPort = function (el) {
+        var relativeContextElement = this.getRelativeContextElement(el);
+        if (!relativeContextElement) {
+            return null;
+        }
+        return {
+            height: relativeContextElement.scrollHeight,
+            width: relativeContextElement.scrollWidth
+        };
+    };
+    DOMService.prototype.getRelativeContextElement = function (el) {
+        if (!el || !HAS_RELATIVE_STACKING_CONTEXT) {
+            return null;
+        }
+        var parent = 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(el);
+    };
+    DOMService.prototype.zIndex = function (anchor, container) {
+        return zIndex(anchor, container);
+    };
+    DOMService.prototype.zoomLevel = function () {
+        if (!isDocumentAvailable() || !isWindowAvailable()) {
+            return 1;
+        }
+        return parseFloat((document.documentElement.clientWidth / window.innerWidth).toFixed(2));
+    };
+    DOMService.prototype.isZoomed = function () {
+        return this.zoomLevel() > 1;
+    };
+    return DOMService;
+}());
+export { DOMService };

package/dist/esm/services/positionService.d.ts

@@ -0,0 +1,12 @@
+import { PositionElementSettings } from '../models/positionElementSettings';
+import { Position } from '../models/Position';
+import { DOMService } from './domService';
+/**
+ * @hidden
+ */
+export declare class PositionService {
+    private _dom;
+    constructor(_dom: DOMService);
+    positionElement(settings: PositionElementSettings): Position;
+    private elementRect;
+}

package/dist/esm/services/positionService.js

@@ -0,0 +1,34 @@
+import { eitherRect, replaceOffset } from '../util.js';
+/**
+ * @hidden
+ */
+var PositionService = /** @class */ (function () {
+    function PositionService(_dom) {
+        this._dom = _dom;
+    }
+    PositionService.prototype.positionElement = function (settings) {
+        var anchor = settings.anchor, currentLocation = settings.currentLocation, element = settings.element, anchorAlign = settings.anchorAlign, elementAlign = settings.elementAlign, collisions = settings.collisions;
+        var dom = this._dom;
+        var viewPort = settings.viewPort || dom.stackingElementViewPort(element) || dom.windowViewPort(element);
+        var anchorRect = eitherRect(dom.offset(anchor), currentLocation);
+        var initialElementRect = replaceOffset(dom.staticOffset(element), currentLocation);
+        var elementRect = this.elementRect(element, initialElementRect);
+        var result = dom.restrictToView({
+            anchorAlign: anchorAlign,
+            anchorRect: anchorRect,
+            collisions: collisions,
+            elementAlign: elementAlign,
+            elementRect: elementRect,
+            viewPort: viewPort
+        });
+        return {
+            flipped: result.flipped,
+            offset: dom.addOffset(initialElementRect, result.offset)
+        };
+    };
+    PositionService.prototype.elementRect = function (element, rect) {
+        return this._dom.removeScroll(rect, this._dom.scrollPosition(element));
+    };
+    return PositionService;
+}());
+export { PositionService };

package/dist/esm/util.d.ts

@@ -0,0 +1,74 @@
+import { ElementRect, OffsetPosition } from '@progress/kendo-popup-common';
+/**
+ * @hidden
+ */
+export declare const eitherRect: (rect: ElementRect | null, offset: OffsetPosition) => ElementRect;
+/**
+ * @hidden
+ */
+export declare const replaceOffset: (rect: ElementRect, offset: OffsetPosition) => ElementRect;
+/**
+ * @hidden
+ */
+export declare const removeStackingOffset: (rect: ElementRect, stackingOffset: ElementRect | null) => ElementRect;
+/**
+ * @hidden
+ */
+export declare const isDifferentOffset: (oldOffset: OffsetPosition, newOffset: OffsetPosition) => boolean;
+/**
+ * @hidden
+ */
+export declare const isDocumentAvailable: () => boolean;
+/**
+ * @hidden
+ */
+export declare const isWindowAvailable: () => boolean;
+/**
+ * @hidden
+ */
+export declare const hasBoundingRect: (elem: HTMLElement) => boolean;
+/**
+ * @hidden
+ */
+export declare const OVERFLOW_REGEXP: RegExp;
+/**
+ * @hidden
+ */
+export declare const scrollableParents: (element: HTMLElement) => any[];
+/**
+ * @hidden
+ */
+export declare const FRAME_DURATION: number;
+/**
+ * @hidden
+ */
+export declare const hasRelativeStackingContext: () => boolean;
+/**
+ * @hidden
+ */
+export declare const HAS_RELATIVE_STACKING_CONTEXT: boolean;
+/**
+ * @hidden
+ */
+export declare const zIndex: (anchor: HTMLElement, container: HTMLElement) => number;
+/**
+ * @hidden
+ */
+export declare const CollisionType: {
+    fit: string;
+    flip: string;
+};
+/**
+ * @hidden
+ */
+export declare const AlignPoint: {
+    left: string;
+    center: string;
+    right: string;
+    bottom: string;
+    top: string;
+};
+/**
+ * @hidden
+ */
+export declare const throttle: (func: Function, wait: number, options?: any) => () => any;

package/dist/esm/util.js

@@ -0,0 +1,254 @@
+import { parents, siblingContainer } from '@progress/kendo-popup-common';
+/**
+ * @hidden
+ */
+
+export var eitherRect = function eitherRect(rect, offset) {
+  if (!rect) {
+    return {
+      height: 0,
+      left: offset.left,
+      top: offset.top,
+      width: 0
+    };
+  }
+
+  return rect;
+};
+/**
+ * @hidden
+ */
+
+export var replaceOffset = function replaceOffset(rect, offset) {
+  if (!offset) {
+    return rect;
+  }
+
+  var result = {
+    height: rect.height,
+    left: offset.left,
+    top: offset.top,
+    width: rect.width
+  };
+  return result;
+};
+/**
+ * @hidden
+ */
+
+export var removeStackingOffset = function removeStackingOffset(rect, stackingOffset) {
+  if (!stackingOffset) {
+    return rect;
+  }
+
+  var result = {
+    height: rect.height,
+    left: rect.left - stackingOffset.left,
+    top: rect.top - stackingOffset.top,
+    width: rect.width
+  };
+  return result;
+};
+/**
+ * @hidden
+ */
+
+export var isDifferentOffset = function isDifferentOffset(oldOffset, newOffset) {
+  var oldLeft = oldOffset.left,
+      oldTop = oldOffset.top;
+  var newLeft = newOffset.left,
+      newTop = newOffset.top;
+  return Math.abs(oldLeft - newLeft) >= 1 || Math.abs(oldTop - newTop) >= 1;
+};
+/**
+ * @hidden
+ */
+
+export var isDocumentAvailable = function isDocumentAvailable() {
+  return typeof document !== 'undefined' && !!document.body;
+};
+/**
+ * @hidden
+ */
+
+export var isWindowAvailable = function isWindowAvailable() {
+  return typeof window !== 'undefined';
+};
+/**
+ * @hidden
+ */
+
+export var hasBoundingRect = function hasBoundingRect(elem) {
+  return !!elem.getBoundingClientRect;
+};
+/**
+ * @hidden
+ */
+
+export var OVERFLOW_REGEXP = /auto|scroll/;
+/**
+ * @hidden
+ */
+
+var overflowStyle = function overflowStyle(element) {
+  var styles = window.getComputedStyle(element);
+  return "".concat(styles.overflow).concat(styles.overflowX).concat(styles.overflowY);
+};
+/**
+ * @hidden
+ */
+
+
+export var scrollableParents = function scrollableParents(element) {
+  var parentElements = [];
+
+  if (!isDocumentAvailable() || !isWindowAvailable()) {
+    return parentElements;
+  }
+
+  var parent = element.parentElement;
+
+  while (parent) {
+    if (OVERFLOW_REGEXP.test(overflowStyle(parent))) {
+      parentElements.push(parent);
+    }
+
+    parent = parent.parentElement;
+  }
+
+  parentElements.push(window);
+  return parentElements;
+};
+/**
+ * @hidden
+ */
+
+export var FRAME_DURATION = 1000 / 60; // 1000ms divided by 60fps
+
+/**
+ * @hidden
+ */
+
+export var hasRelativeStackingContext = function hasRelativeStackingContext() {
+  if (!isDocumentAvailable()) {
+    return false;
+  }
+
+  var top = 10;
+  var parent = document.createElement('div');
+  parent.style.transform = 'matrix(10, 0, 0, 10, 0, 0)';
+  parent.innerHTML = "<div>child</div>";
+  document.body.appendChild(parent);
+
+  if (parent && parent.firstChild) {
+    var firstChild = parent.firstChild;
+    firstChild.style.position = 'fixed';
+    firstChild.style.top = "".concat(top, "px");
+  }
+
+  var isDifferent = parent.children[0].getBoundingClientRect().top !== top;
+  document.body.removeChild(parent);
+  return isDifferent;
+};
+/**
+ * @hidden
+ */
+
+export var HAS_RELATIVE_STACKING_CONTEXT = hasRelativeStackingContext();
+/**
+ * @hidden
+ */
+
+export var zIndex = function zIndex(anchor, container) {
+  if (!anchor || !isDocumentAvailable() || !isWindowAvailable()) {
+    return null;
+  }
+
+  var sibling = siblingContainer(anchor, container);
+
+  if (!sibling) {
+    return null;
+  }
+
+  var result = [anchor].concat(parents(anchor, sibling)).reduce(function (index, p) {
+    var zIndexStyle = p.style.zIndex || window.getComputedStyle(p).zIndex;
+    var current = parseInt(zIndexStyle, 10);
+    return current > index ? current : index;
+  }, 0);
+  return result ? result + 1 : null;
+};
+/**
+ * @hidden
+ */
+
+export var CollisionType = {
+  fit: 'fit',
+  flip: 'flip'
+};
+/**
+ * @hidden
+ */
+
+export var AlignPoint = {
+  left: 'left',
+  center: 'center',
+  right: 'right',
+  bottom: 'bottom',
+  top: 'top'
+};
+/**
+ * @hidden
+ */
+
+export var throttle = function throttle(func, wait, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var timeout, context, args, result;
+  var previous = 0;
+  options = options || {};
+
+  var later = function later() {
+    previous = options.leading === false ? 0 : new Date().getTime();
+    timeout = null;
+    result = func.apply(context, args);
+
+    if (!timeout) {
+      context = args = null;
+    }
+  };
+
+  var throttled = function throttled() {
+    var now = new Date().getTime();
+
+    if (!previous && options.leading === false) {
+      previous = now;
+    }
+
+    var remaining = wait - (now - previous); // @ts-ignore
+
+    context = this;
+    args = arguments;
+
+    if (remaining <= 0 || remaining > wait) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+
+      previous = now;
+      result = func.apply(context, args);
+
+      if (!timeout) {
+        context = args = null;
+      }
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(later, remaining);
+    }
+
+    return result;
+  };
+
+  return throttled;
+};