barsa-user-workspace 0.0.0-watch

package/esm2022/lib/utils/scroll.mjs

@@ -0,0 +1,233 @@
+import { animationFrameScheduler, fromEvent, interval, NEVER } from 'rxjs';
+import { distinctUntilChanged, map, switchMap, tap } from 'rxjs/operators';
+import { ktdNormalizePassiveListenerOptions } from './passive-listeners';
+import { getMutableClientRect } from './client-rect';
+import { ktdNoEmit } from './operators';
+/**
+ * Proximity, as a ratio to width/height at which to start auto-scrolling.
+ * The value comes from trying it out manually until it feels right.
+ */
+const SCROLL_PROXIMITY_THRESHOLD = 0.05;
+/**
+ * Increments the vertical scroll position of a node.
+ * @param node Node whose scroll position should change.
+ * @param amount Amount of pixels that the `node` should be scrolled.
+ */
+function incrementVerticalScroll(node, amount) {
+    if (node === window) {
+        node.scrollBy(0, amount);
+    }
+    else {
+        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.
+        node.scrollTop += amount;
+    }
+}
+/**
+ * Increments the horizontal scroll position of a node.
+ * @param node Node whose scroll position should change.
+ * @param amount Amount of pixels that the `node` should be scrolled.
+ */
+function incrementHorizontalScroll(node, amount) {
+    if (node === window) {
+        node.scrollBy(amount, 0);
+    }
+    else {
+        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.
+        node.scrollLeft += amount;
+    }
+}
+/**
+ * Gets whether the vertical auto-scroll direction of a node.
+ * @param clientRect Dimensions of the node.
+ * @param pointerY Position of the user's pointer along the y axis.
+ */
+function getVerticalScrollDirection(clientRect, pointerY) {
+    const { top, bottom, height } = clientRect;
+    const yThreshold = height * SCROLL_PROXIMITY_THRESHOLD;
+    if (pointerY >= top - yThreshold && pointerY <= top + yThreshold) {
+        return 1 /* AutoScrollVerticalDirection.UP */;
+    }
+    else if (pointerY >= bottom - yThreshold && pointerY <= bottom + yThreshold) {
+        return 2 /* AutoScrollVerticalDirection.DOWN */;
+    }
+    return 0 /* AutoScrollVerticalDirection.NONE */;
+}
+/**
+ * Gets whether the horizontal auto-scroll direction of a node.
+ * @param clientRect Dimensions of the node.
+ * @param pointerX Position of the user's pointer along the x axis.
+ */
+function getHorizontalScrollDirection(clientRect, pointerX) {
+    const { left, right, width } = clientRect;
+    const xThreshold = width * SCROLL_PROXIMITY_THRESHOLD;
+    if (pointerX >= left - xThreshold && pointerX <= left + xThreshold) {
+        return 1 /* AutoScrollHorizontalDirection.LEFT */;
+    }
+    else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {
+        return 2 /* AutoScrollHorizontalDirection.RIGHT */;
+    }
+    return 0 /* AutoScrollHorizontalDirection.NONE */;
+}
+/**
+ * Returns an observable that schedules a loop and apply scroll on the scrollNode into the specified direction/s.
+ * This observable doesn't emit, it just performs the 'scroll' side effect.
+ * @param scrollNode, node where the scroll would be applied.
+ * @param verticalScrollDirection, vertical direction of the scroll.
+ * @param horizontalScrollDirection, horizontal direction of the scroll.
+ * @param scrollStep, scroll step in CSS pixels that would be applied in every loop.
+ */
+function scrollToDirectionInterval$(scrollNode, verticalScrollDirection, horizontalScrollDirection, scrollStep = 2) {
+    return interval(0, animationFrameScheduler)
+        .pipe(tap(() => {
+        if (verticalScrollDirection === 1 /* AutoScrollVerticalDirection.UP */) {
+            incrementVerticalScroll(scrollNode, -scrollStep);
+        }
+        else if (verticalScrollDirection === 2 /* AutoScrollVerticalDirection.DOWN */) {
+            incrementVerticalScroll(scrollNode, scrollStep);
+        }
+        if (horizontalScrollDirection === 1 /* AutoScrollHorizontalDirection.LEFT */) {
+            incrementHorizontalScroll(scrollNode, -scrollStep);
+        }
+        else if (horizontalScrollDirection === 2 /* AutoScrollHorizontalDirection.RIGHT */) {
+            incrementHorizontalScroll(scrollNode, scrollStep);
+        }
+    }), ktdNoEmit());
+}
+/**
+ * Given a source$ observable with pointer location, scroll the scrollNode if the pointer is near to it.
+ * This observable doesn't emit, it just performs a 'scroll' side effect.
+ * @param scrollableParent, parent node in which the scroll would be performed.
+ * @param options, configuration options.
+ */
+export function ktdScrollIfNearElementClientRect$(scrollableParent, options) {
+    let scrollNode;
+    let scrollableParentClientRect;
+    let scrollableParentScrollWidth;
+    if (scrollableParent === document) {
+        scrollNode = document.defaultView;
+        const { width, height } = getViewportSize();
+        scrollableParentClientRect = { width, height, top: 0, right: width, bottom: height, left: 0 };
+        scrollableParentScrollWidth = getDocumentScrollWidth();
+    }
+    else {
+        scrollNode = scrollableParent;
+        scrollableParentClientRect = getMutableClientRect(scrollableParent);
+        scrollableParentScrollWidth = scrollableParent.scrollWidth;
+    }
+    /**
+     * IMPORTANT: By design, only let scroll horizontal if the scrollable parent has explicitly an scroll horizontal.
+     * This layout solution is not designed in mind to have any scroll horizontal, but exceptionally we allow it in this
+     * specific use case.
+     */
+    options = options || {};
+    if (options.disableHorizontal == null && scrollableParentScrollWidth <= scrollableParentClientRect.width) {
+        options.disableHorizontal = true;
+    }
+    return (source$) => source$.pipe(map(({ pointerX, pointerY }) => {
+        let verticalScrollDirection = getVerticalScrollDirection(scrollableParentClientRect, pointerY);
+        let horizontalScrollDirection = getHorizontalScrollDirection(scrollableParentClientRect, pointerX);
+        // Check if scroll directions are disabled.
+        if (options?.disableVertical) {
+            verticalScrollDirection = 0 /* AutoScrollVerticalDirection.NONE */;
+        }
+        if (options?.disableHorizontal) {
+            horizontalScrollDirection = 0 /* AutoScrollHorizontalDirection.NONE */;
+        }
+        return { verticalScrollDirection, horizontalScrollDirection };
+    }), distinctUntilChanged((prev, actual) => {
+        return prev.verticalScrollDirection === actual.verticalScrollDirection
+            && prev.horizontalScrollDirection === actual.horizontalScrollDirection;
+    }), switchMap(({ verticalScrollDirection, horizontalScrollDirection }) => {
+        if (verticalScrollDirection || horizontalScrollDirection) {
+            return scrollToDirectionInterval$(scrollNode, verticalScrollDirection, horizontalScrollDirection, options?.scrollStep);
+        }
+        else {
+            return NEVER;
+        }
+    }));
+}
+/**
+ * Emits on EVERY scroll event and returns the accumulated scroll offset relative to the initial scroll position.
+ * @param scrollableParent, node in which scroll events would be listened.
+ */
+export function ktdGetScrollTotalRelativeDifference$(scrollableParent) {
+    let scrollInitialPosition;
+    // Calculate initial scroll position
+    if (scrollableParent === document) {
+        scrollInitialPosition = getViewportScrollPosition();
+    }
+    else {
+        scrollInitialPosition = {
+            top: scrollableParent.scrollTop,
+            left: scrollableParent.scrollLeft
+        };
+    }
+    return fromEvent(scrollableParent, 'scroll', ktdNormalizePassiveListenerOptions({ capture: true })).pipe(map(() => {
+        let newTop;
+        let newLeft;
+        if (scrollableParent === document) {
+            const viewportScrollPosition = getViewportScrollPosition();
+            newTop = viewportScrollPosition.top;
+            newLeft = viewportScrollPosition.left;
+        }
+        else {
+            newTop = scrollableParent.scrollTop;
+            newLeft = scrollableParent.scrollLeft;
+        }
+        const topDifference = scrollInitialPosition.top - newTop;
+        const leftDifference = scrollInitialPosition.left - newLeft;
+        return { top: topDifference, left: leftDifference };
+    }));
+}
+/** Returns the viewport's width and height. */
+function getViewportSize() {
+    const _window = document.defaultView || window;
+    return {
+        width: _window.innerWidth,
+        height: _window.innerHeight
+    };
+}
+/** Gets a ClientRect for the viewport's bounds. */
+function getViewportRect() {
+    // Use the document element's bounding rect rather than the window scroll properties
+    // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll
+    // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different
+    // conceptual viewports. Under most circumstances these viewports are equivalent, but they
+    // can disagree when the page is pinch-zoomed (on devices that support touch).
+    // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4
+    // We use the documentElement instead of the body because, by default (without a css reset)
+    // browsers typically give the document body an 8px margin, which is not included in
+    // getBoundingClientRect().
+    const scrollPosition = getViewportScrollPosition();
+    const { width, height } = getViewportSize();
+    return {
+        top: scrollPosition.top,
+        left: scrollPosition.left,
+        bottom: scrollPosition.top + height,
+        right: scrollPosition.left + width,
+        height,
+        width,
+    };
+}
+/** Gets the (top, left) scroll position of the viewport. */
+function getViewportScrollPosition() {
+    // The top-left-corner of the viewport is determined by the scroll position of the document
+    // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about
+    // whether `document.body` or `document.documentElement` is the scrolled element, so reading
+    // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of
+    // `document.documentElement` works consistently, where the `top` and `left` values will
+    // equal negative the scroll position.
+    const windowRef = document.defaultView || window;
+    const documentElement = document.documentElement;
+    const documentRect = documentElement.getBoundingClientRect();
+    const top = -documentRect.top || document.body.scrollTop || windowRef.scrollY ||
+        documentElement.scrollTop || 0;
+    const left = -documentRect.left || document.body.scrollLeft || windowRef.scrollX ||
+        documentElement.scrollLeft || 0;
+    return { top, left };
+}
+/** Returns the document scroll width */
+function getDocumentScrollWidth() {
+    return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scroll.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/utils/scroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAc,MAAM,MAAM,CAAC;AACvF,OAAO,EAAE,oBAAoB,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC3E,OAAO,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAiB,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;;GAGG;AACH,MAAM,0BAA0B,GAAG,IAAI,CAAC;AAcxC;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,IAA0B,EAAE,MAAc;IACvE,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACjB,IAAe,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC;SAAM,CAAC;QACJ,0FAA0F;QACzF,IAAoB,CAAC,SAAS,IAAI,MAAM,CAAC;IAC9C,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,SAAS,yBAAyB,CAAC,IAA0B,EAAE,MAAc;IACzE,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;QACjB,IAAe,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACzC,CAAC;SAAM,CAAC;QACJ,0FAA0F;QACzF,IAAoB,CAAC,UAAU,IAAI,MAAM,CAAC;IAC/C,CAAC;AACL,CAAC;AAGD;;;;GAIG;AACH,SAAS,0BAA0B,CAAC,UAAyB,EAAE,QAAgB;IAC3E,MAAM,EAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAC,GAAG,UAAU,CAAC;IACzC,MAAM,UAAU,GAAG,MAAM,GAAG,0BAA0B,CAAC;IAEvD,IAAI,QAAQ,IAAI,GAAG,GAAG,UAAU,IAAI,QAAQ,IAAI,GAAG,GAAG,UAAU,EAAE,CAAC;QAC/D,8CAAsC;IAC1C,CAAC;SAAM,IAAI,QAAQ,IAAI,MAAM,GAAG,UAAU,IAAI,QAAQ,IAAI,MAAM,GAAG,UAAU,EAAE,CAAC;QAC5E,gDAAwC;IAC5C,CAAC;IAED,gDAAwC;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAS,4BAA4B,CAAC,UAAyB,EAAE,QAAgB;IAC7E,MAAM,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,GAAG,UAAU,CAAC;IACxC,MAAM,UAAU,GAAG,KAAK,GAAG,0BAA0B,CAAC;IAEtD,IAAI,QAAQ,IAAI,IAAI,GAAG,UAAU,IAAI,QAAQ,IAAI,IAAI,GAAG,UAAU,EAAE,CAAC;QACjE,kDAA0C;IAC9C,CAAC;SAAM,IAAI,QAAQ,IAAI,KAAK,GAAG,UAAU,IAAI,QAAQ,IAAI,KAAK,GAAG,UAAU,EAAE,CAAC;QAC1E,mDAA2C;IAC/C,CAAC;IAED,kDAA0C;AAC9C,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,0BAA0B,CAAC,UAAgC,EAAE,uBAAoD,EAAE,yBAAwD,EAAE,aAAqB,CAAC;IACxM,OAAO,QAAQ,CAAC,CAAC,EAAE,uBAAuB,CAAC;SACtC,IAAI,CACD,GAAG,CAAC,GAAG,EAAE;QACL,IAAI,uBAAuB,2CAAmC,EAAE,CAAC;YAC7D,uBAAuB,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC;QACrD,CAAC;aAAM,IAAI,uBAAuB,6CAAqC,EAAE,CAAC;YACtE,uBAAuB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACpD,CAAC;QAED,IAAI,yBAAyB,+CAAuC,EAAE,CAAC;YACnE,yBAAyB,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC;QACvD,CAAC;aAAM,IAAI,yBAAyB,gDAAwC,EAAE,CAAC;YAC3E,yBAAyB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QACtD,CAAC;IACL,CAAC,CAAC,EACF,SAAS,EAAE,CACd,CAAC;AACV,CAAC;AAQD;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAC,gBAAwC,EAAE,OAAuC;IAE/H,IAAI,UAAgC,CAAC;IACrC,IAAI,0BAAyC,CAAC;IAC9C,IAAI,2BAAmC,CAAC;IAExC,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAChC,UAAU,GAAG,QAAQ,CAAC,WAAqB,CAAC;QAC5C,MAAM,EAAC,KAAK,EAAE,MAAM,EAAC,GAAG,eAAe,EAAE,CAAC;QAC1C,0BAA0B,GAAG,EAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAC,CAAC;QAC5F,2BAA2B,GAAG,sBAAsB,EAAE,CAAC;IAC3D,CAAC;SAAM,CAAC;QACJ,UAAU,GAAG,gBAA+B,CAAC;QAC7C,0BAA0B,GAAG,oBAAoB,CAAC,gBAA+B,CAAC,CAAC;QACnF,2BAA2B,GAAI,gBAAgC,CAAC,WAAW,CAAC;IAChF,CAAC;IAED;;;;OAIG;IACH,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IACxB,IAAI,OAAO,CAAC,iBAAiB,IAAI,IAAI,IAAI,2BAA2B,IAAI,0BAA0B,CAAC,KAAK,EAAE,CAAC;QACvG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IACrC,CAAC;IAED,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAC5B,GAAG,CAAC,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAC,EAAE,EAAE;QACzB,IAAI,uBAAuB,GAAG,0BAA0B,CAAC,0BAA0B,EAAE,QAAQ,CAAC,CAAC;QAC/F,IAAI,yBAAyB,GAAG,4BAA4B,CAAC,0BAA0B,EAAE,QAAQ,CAAC,CAAC;QAEnG,2CAA2C;QAC3C,IAAI,OAAO,EAAE,eAAe,EAAE,CAAC;YAC3B,uBAAuB,2CAAmC,CAAC;QAC/D,CAAC;QACD,IAAI,OAAO,EAAE,iBAAiB,EAAE,CAAC;YAC7B,yBAAyB,6CAAqC,CAAC;QACnE,CAAC;QAED,OAAO,EAAC,uBAAuB,EAAE,yBAAyB,EAAC,CAAC;IAChE,CAAC,CAAC,EACF,oBAAoB,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;QAClC,OAAO,IAAI,CAAC,uBAAuB,KAAK,MAAM,CAAC,uBAAuB;eAC/D,IAAI,CAAC,yBAAyB,KAAK,MAAM,CAAC,yBAAyB,CAAC;IAC/E,CAAC,CAAC,EACF,SAAS,CAAC,CAAC,EAAC,uBAAuB,EAAE,yBAAyB,EAAC,EAAE,EAAE;QAC/D,IAAI,uBAAuB,IAAI,yBAAyB,EAAE,CAAC;YACvD,OAAO,0BAA0B,CAAC,UAAU,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3H,CAAC;aAAM,CAAC;YACJ,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC,CAAC,CACL,CAAC;AACN,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oCAAoC,CAAC,gBAAwC;IACzF,IAAI,qBAAqB,CAAC;IAE1B,oCAAoC;IACpC,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAChC,qBAAqB,GAAG,yBAAyB,EAAE,CAAC;IACxD,CAAC;SAAM,CAAC;QACJ,qBAAqB,GAAG;YACpB,GAAG,EAAG,gBAAgC,CAAC,SAAS;YAChD,IAAI,EAAG,gBAAgC,CAAC,UAAU;SACrD,CAAC;IACN,CAAC;IAED,OAAO,SAAS,CAAC,gBAAgB,EAAE,QAAQ,EAAE,kCAAkC,CAAC,EAAC,OAAO,EAAE,IAAI,EAAC,CAA4B,CAAC,CAAC,IAAI,CAC7H,GAAG,CAAC,GAAG,EAAE;QACL,IAAI,MAAc,CAAC;QACnB,IAAI,OAAe,CAAC;QAEpB,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,sBAAsB,GAAG,yBAAyB,EAAE,CAAC;YAC3D,MAAM,GAAG,sBAAsB,CAAC,GAAG,CAAC;YACpC,OAAO,GAAG,sBAAsB,CAAC,IAAI,CAAC;QAC1C,CAAC;aAAM,CAAC;YACJ,MAAM,GAAI,gBAAgC,CAAC,SAAS,CAAC;YACrD,OAAO,GAAI,gBAAgC,CAAC,UAAU,CAAC;QAC3D,CAAC;QAED,MAAM,aAAa,GAAG,qBAAqB,CAAC,GAAG,GAAG,MAAM,CAAC;QACzD,MAAM,cAAc,GAAG,qBAAqB,CAAC,IAAI,GAAG,OAAO,CAAC;QAE5D,OAAO,EAAC,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAC,CAAC;IACtD,CAAC,CAAC,CACL,CAAC;AAEN,CAAC;AAED,+CAA+C;AAC/C,SAAS,eAAe;IACpB,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC;IAC/C,OAAO;QACH,KAAK,EAAE,OAAO,CAAC,UAAU;QACzB,MAAM,EAAE,OAAO,CAAC,WAAW;KAC9B,CAAC;AAEN,CAAC;AAED,mDAAmD;AACnD,SAAS,eAAe;IACpB,oFAAoF;IACpF,mFAAmF;IACnF,2FAA2F;IAC3F,0FAA0F;IAC1F,8EAA8E;IAC9E,sEAAsE;IACtE,2FAA2F;IAC3F,oFAAoF;IACpF,2BAA2B;IAC3B,MAAM,cAAc,GAAG,yBAAyB,EAAE,CAAC;IACnD,MAAM,EAAC,KAAK,EAAE,MAAM,EAAC,GAAG,eAAe,EAAE,CAAC;IAE1C,OAAO;QACH,GAAG,EAAE,cAAc,CAAC,GAAG;QACvB,IAAI,EAAE,cAAc,CAAC,IAAI;QACzB,MAAM,EAAE,cAAc,CAAC,GAAG,GAAG,MAAM;QACnC,KAAK,EAAE,cAAc,CAAC,IAAI,GAAG,KAAK;QAClC,MAAM;QACN,KAAK;KACR,CAAC;AACN,CAAC;AAED,4DAA4D;AAC5D,SAAS,yBAAyB;IAE9B,2FAA2F;IAC3F,0FAA0F;IAC1F,4FAA4F;IAC5F,oFAAoF;IACpF,wFAAwF;IACxF,sCAAsC;IACtC,MAAM,SAAS,GAAG,QAAQ,CAAC,WAAW,IAAI,MAAM,CAAC;IACjD,MAAM,eAAe,GAAG,QAAQ,CAAC,eAAgB,CAAC;IAClD,MAAM,YAAY,GAAG,eAAe,CAAC,qBAAqB,EAAE,CAAC;IAE7D,MAAM,GAAG,GAAG,CAAC,YAAY,CAAC,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,OAAO;QACzE,eAAe,CAAC,SAAS,IAAI,CAAC,CAAC;IAEnC,MAAM,IAAI,GAAG,CAAC,YAAY,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,UAAU,IAAI,SAAS,CAAC,OAAO;QAC5E,eAAe,CAAC,UAAU,IAAI,CAAC,CAAC;IAEpC,OAAO,EAAC,GAAG,EAAE,IAAI,EAAC,CAAC;AACvB,CAAC;AAED,wCAAwC;AACxC,SAAS,sBAAsB;IAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;AACrF,CAAC","sourcesContent":["import { animationFrameScheduler, fromEvent, interval, NEVER, Observable } from 'rxjs';\nimport { distinctUntilChanged, map, switchMap, tap } from 'rxjs/operators';\nimport { ktdNormalizePassiveListenerOptions } from './passive-listeners';\nimport { getMutableClientRect, KtdClientRect } from './client-rect';\nimport { ktdNoEmit } from './operators';\n\n/**\n * Proximity, as a ratio to width/height at which to start auto-scrolling.\n * The value comes from trying it out manually until it feels right.\n */\nconst SCROLL_PROXIMITY_THRESHOLD = 0.05;\n\n/** Vertical direction in which we can auto-scroll. */\nconst enum AutoScrollVerticalDirection {NONE, UP, DOWN}\n\n/** Horizontal direction in which we can auto-scroll. */\nconst enum AutoScrollHorizontalDirection {NONE, LEFT, RIGHT}\n\nexport interface KtdScrollPosition {\n    top: number;\n    left: number;\n}\n\n\n/**\n * Increments the vertical scroll position of a node.\n * @param node Node whose scroll position should change.\n * @param amount Amount of pixels that the `node` should be scrolled.\n */\nfunction incrementVerticalScroll(node: HTMLElement | Window, amount: number) {\n    if (node === window) {\n        (node as Window).scrollBy(0, amount);\n    } else {\n        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.\n        (node as HTMLElement).scrollTop += amount;\n    }\n}\n\n/**\n * Increments the horizontal scroll position of a node.\n * @param node Node whose scroll position should change.\n * @param amount Amount of pixels that the `node` should be scrolled.\n */\nfunction incrementHorizontalScroll(node: HTMLElement | Window, amount: number) {\n    if (node === window) {\n        (node as Window).scrollBy(amount, 0);\n    } else {\n        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.\n        (node as HTMLElement).scrollLeft += amount;\n    }\n}\n\n\n/**\n * Gets whether the vertical auto-scroll direction of a node.\n * @param clientRect Dimensions of the node.\n * @param pointerY Position of the user's pointer along the y axis.\n */\nfunction getVerticalScrollDirection(clientRect: KtdClientRect, pointerY: number) {\n    const {top, bottom, height} = clientRect;\n    const yThreshold = height * SCROLL_PROXIMITY_THRESHOLD;\n\n    if (pointerY >= top - yThreshold && pointerY <= top + yThreshold) {\n        return AutoScrollVerticalDirection.UP;\n    } else if (pointerY >= bottom - yThreshold && pointerY <= bottom + yThreshold) {\n        return AutoScrollVerticalDirection.DOWN;\n    }\n\n    return AutoScrollVerticalDirection.NONE;\n}\n\n/**\n * Gets whether the horizontal auto-scroll direction of a node.\n * @param clientRect Dimensions of the node.\n * @param pointerX Position of the user's pointer along the x axis.\n */\nfunction getHorizontalScrollDirection(clientRect: KtdClientRect, pointerX: number) {\n    const {left, right, width} = clientRect;\n    const xThreshold = width * SCROLL_PROXIMITY_THRESHOLD;\n\n    if (pointerX >= left - xThreshold && pointerX <= left + xThreshold) {\n        return AutoScrollHorizontalDirection.LEFT;\n    } else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {\n        return AutoScrollHorizontalDirection.RIGHT;\n    }\n\n    return AutoScrollHorizontalDirection.NONE;\n}\n\n/**\n * Returns an observable that schedules a loop and apply scroll on the scrollNode into the specified direction/s.\n * This observable doesn't emit, it just performs the 'scroll' side effect.\n * @param scrollNode, node where the scroll would be applied.\n * @param verticalScrollDirection, vertical direction of the scroll.\n * @param horizontalScrollDirection, horizontal direction of the scroll.\n * @param scrollStep, scroll step in CSS pixels that would be applied in every loop.\n */\nfunction scrollToDirectionInterval$(scrollNode: HTMLElement | Window, verticalScrollDirection: AutoScrollVerticalDirection, horizontalScrollDirection: AutoScrollHorizontalDirection, scrollStep: number = 2) {\n    return interval(0, animationFrameScheduler)\n        .pipe(\n            tap(() => {\n                if (verticalScrollDirection === AutoScrollVerticalDirection.UP) {\n                    incrementVerticalScroll(scrollNode, -scrollStep);\n                } else if (verticalScrollDirection === AutoScrollVerticalDirection.DOWN) {\n                    incrementVerticalScroll(scrollNode, scrollStep);\n                }\n\n                if (horizontalScrollDirection === AutoScrollHorizontalDirection.LEFT) {\n                    incrementHorizontalScroll(scrollNode, -scrollStep);\n                } else if (horizontalScrollDirection === AutoScrollHorizontalDirection.RIGHT) {\n                    incrementHorizontalScroll(scrollNode, scrollStep);\n                }\n            }),\n            ktdNoEmit()\n        );\n}\n\nexport interface KtdScrollIfNearElementOptions {\n    scrollStep?: number;\n    disableVertical?: boolean;\n    disableHorizontal?: boolean;\n}\n\n/**\n * Given a source$ observable with pointer location, scroll the scrollNode if the pointer is near to it.\n * This observable doesn't emit, it just performs a 'scroll' side effect.\n * @param scrollableParent, parent node in which the scroll would be performed.\n * @param options, configuration options.\n */\nexport function ktdScrollIfNearElementClientRect$(scrollableParent: HTMLElement | Document, options?: KtdScrollIfNearElementOptions): (source$: Observable<{ pointerX: number, pointerY: number }>) => Observable<any> {\n\n    let scrollNode: Window | HTMLElement;\n    let scrollableParentClientRect: KtdClientRect;\n    let scrollableParentScrollWidth: number;\n\n    if (scrollableParent === document) {\n        scrollNode = document.defaultView as Window;\n        const {width, height} = getViewportSize();\n        scrollableParentClientRect = {width, height, top: 0, right: width, bottom: height, left: 0};\n        scrollableParentScrollWidth = getDocumentScrollWidth();\n    } else {\n        scrollNode = scrollableParent as HTMLElement;\n        scrollableParentClientRect = getMutableClientRect(scrollableParent as HTMLElement);\n        scrollableParentScrollWidth = (scrollableParent as HTMLElement).scrollWidth;\n    }\n\n    /**\n     * IMPORTANT: By design, only let scroll horizontal if the scrollable parent has explicitly an scroll horizontal.\n     * This layout solution is not designed in mind to have any scroll horizontal, but exceptionally we allow it in this\n     * specific use case.\n     */\n    options = options || {};\n    if (options.disableHorizontal == null && scrollableParentScrollWidth <= scrollableParentClientRect.width) {\n        options.disableHorizontal = true;\n    }\n\n    return (source$) => source$.pipe(\n        map(({pointerX, pointerY}) => {\n            let verticalScrollDirection = getVerticalScrollDirection(scrollableParentClientRect, pointerY);\n            let horizontalScrollDirection = getHorizontalScrollDirection(scrollableParentClientRect, pointerX);\n\n            // Check if scroll directions are disabled.\n            if (options?.disableVertical) {\n                verticalScrollDirection = AutoScrollVerticalDirection.NONE;\n            }\n            if (options?.disableHorizontal) {\n                horizontalScrollDirection = AutoScrollHorizontalDirection.NONE;\n            }\n\n            return {verticalScrollDirection, horizontalScrollDirection};\n        }),\n        distinctUntilChanged((prev, actual) => {\n            return prev.verticalScrollDirection === actual.verticalScrollDirection\n                && prev.horizontalScrollDirection === actual.horizontalScrollDirection;\n        }),\n        switchMap(({verticalScrollDirection, horizontalScrollDirection}) => {\n            if (verticalScrollDirection || horizontalScrollDirection) {\n                return scrollToDirectionInterval$(scrollNode, verticalScrollDirection, horizontalScrollDirection, options?.scrollStep);\n            } else {\n                return NEVER;\n            }\n        })\n    );\n}\n\n/**\n * Emits on EVERY scroll event and returns the accumulated scroll offset relative to the initial scroll position.\n * @param scrollableParent, node in which scroll events would be listened.\n */\nexport function ktdGetScrollTotalRelativeDifference$(scrollableParent: HTMLElement | Document): Observable<{ top: number, left: number }> {\n    let scrollInitialPosition;\n\n    // Calculate initial scroll position\n    if (scrollableParent === document) {\n        scrollInitialPosition = getViewportScrollPosition();\n    } else {\n        scrollInitialPosition = {\n            top: (scrollableParent as HTMLElement).scrollTop,\n            left: (scrollableParent as HTMLElement).scrollLeft\n        };\n    }\n\n    return fromEvent(scrollableParent, 'scroll', ktdNormalizePassiveListenerOptions({capture: true}) as AddEventListenerOptions).pipe(\n        map(() => {\n            let newTop: number;\n            let newLeft: number;\n\n            if (scrollableParent === document) {\n                const viewportScrollPosition = getViewportScrollPosition();\n                newTop = viewportScrollPosition.top;\n                newLeft = viewportScrollPosition.left;\n            } else {\n                newTop = (scrollableParent as HTMLElement).scrollTop;\n                newLeft = (scrollableParent as HTMLElement).scrollLeft;\n            }\n\n            const topDifference = scrollInitialPosition.top - newTop;\n            const leftDifference = scrollInitialPosition.left - newLeft;\n\n            return {top: topDifference, left: leftDifference};\n        })\n    );\n\n}\n\n/** Returns the viewport's width and height. */\nfunction getViewportSize(): { width: number, height: number } {\n    const _window = document.defaultView || window;\n    return {\n        width: _window.innerWidth,\n        height: _window.innerHeight\n    };\n\n}\n\n/** Gets a ClientRect for the viewport's bounds. */\nfunction getViewportRect(): KtdClientRect {\n    // Use the document element's bounding rect rather than the window scroll properties\n    // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\n    // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\n    // conceptual viewports. Under most circumstances these viewports are equivalent, but they\n    // can disagree when the page is pinch-zoomed (on devices that support touch).\n    // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\n    // We use the documentElement instead of the body because, by default (without a css reset)\n    // browsers typically give the document body an 8px margin, which is not included in\n    // getBoundingClientRect().\n    const scrollPosition = getViewportScrollPosition();\n    const {width, height} = getViewportSize();\n\n    return {\n        top: scrollPosition.top,\n        left: scrollPosition.left,\n        bottom: scrollPosition.top + height,\n        right: scrollPosition.left + width,\n        height,\n        width,\n    };\n}\n\n/** Gets the (top, left) scroll position of the viewport. */\nfunction getViewportScrollPosition(): { top: number, left: number } {\n\n    // The top-left-corner of the viewport is determined by the scroll position of the document\n    // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\n    // whether `document.body` or `document.documentElement` is the scrolled element, so reading\n    // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\n    // `document.documentElement` works consistently, where the `top` and `left` values will\n    // equal negative the scroll position.\n    const windowRef = document.defaultView || window;\n    const documentElement = document.documentElement!;\n    const documentRect = documentElement.getBoundingClientRect();\n\n    const top = -documentRect.top || document.body.scrollTop || windowRef.scrollY ||\n        documentElement.scrollTop || 0;\n\n    const left = -documentRect.left || document.body.scrollLeft || windowRef.scrollX ||\n        documentElement.scrollLeft || 0;\n\n    return {top, left};\n}\n\n/** Returns the document scroll width */\nfunction getDocumentScrollWidth() {\n    return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth);\n}\n\n"]}

package/esm2022/lib/utils/transition-duration.mjs

@@ -0,0 +1,34 @@
+/**
+ * Transition duration utilities.
+ * This file is taken from Angular Material repository.
+ */
+/* eslint-disable @katoid/prefix-exported-code */
+/** Parses a CSS time value to milliseconds. */
+function parseCssTimeUnitsToMs(value) {
+    // Some browsers will return it in seconds, whereas others will return milliseconds.
+    const multiplier = value.toLowerCase().indexOf('ms') > -1 ? 1 : 1000;
+    return parseFloat(value) * multiplier;
+}
+/** Gets the transform transition duration, including the delay, of an element in milliseconds. */
+export function getTransformTransitionDurationInMs(element) {
+    const computedStyle = getComputedStyle(element);
+    const transitionedProperties = parseCssPropertyValue(computedStyle, 'transition-property');
+    const property = transitionedProperties.find(prop => prop === 'transform' || prop === 'all');
+    // If there's no transition for `all` or `transform`, we shouldn't do anything.
+    if (!property) {
+        return 0;
+    }
+    // Get the index of the property that we're interested in and match
+    // it up to the same index in `transition-delay` and `transition-duration`.
+    const propertyIndex = transitionedProperties.indexOf(property);
+    const rawDurations = parseCssPropertyValue(computedStyle, 'transition-duration');
+    const rawDelays = parseCssPropertyValue(computedStyle, 'transition-delay');
+    return parseCssTimeUnitsToMs(rawDurations[propertyIndex]) +
+        parseCssTimeUnitsToMs(rawDelays[propertyIndex]);
+}
+/** Parses out multiple values from a computed style into an array. */
+function parseCssPropertyValue(computedStyle, name) {
+    const value = computedStyle.getPropertyValue(name);
+    return value.split(',').map(part => part.trim());
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils.mjs

@@ -0,0 +1,14 @@
+/**
+ * Removes and item from an array. Returns a new array instance (it doesn't mutate the source array).
+ * @param array source array to be returned without the element to remove
+ * @param condition function that will return true for the item that we want to remove
+ */
+export function ktdArrayRemoveItem(array, condition) {
+    const arrayCopy = [...array];
+    const index = array.findIndex((item) => condition(item));
+    if (index > -1) {
+        arrayCopy.splice(index, 1);
+    }
+    return arrayCopy;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS11c2VyLXdvcmtzcGFjZS9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQUksS0FBVSxFQUFFLFNBQStCO0lBQzdFLE1BQU0sU0FBUyxHQUFHLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQztJQUM3QixNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUN6RCxJQUFJLEtBQUssR0FBRyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ2IsU0FBUyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUNELE9BQU8sU0FBUyxDQUFDO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogUmVtb3ZlcyBhbmQgaXRlbSBmcm9tIGFuIGFycmF5LiBSZXR1cm5zIGEgbmV3IGFycmF5IGluc3RhbmNlIChpdCBkb2Vzbid0IG11dGF0ZSB0aGUgc291cmNlIGFycmF5KS5cclxuICogQHBhcmFtIGFycmF5IHNvdXJjZSBhcnJheSB0byBiZSByZXR1cm5lZCB3aXRob3V0IHRoZSBlbGVtZW50IHRvIHJlbW92ZVxyXG4gKiBAcGFyYW0gY29uZGl0aW9uIGZ1bmN0aW9uIHRoYXQgd2lsbCByZXR1cm4gdHJ1ZSBmb3IgdGhlIGl0ZW0gdGhhdCB3ZSB3YW50IHRvIHJlbW92ZVxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGt0ZEFycmF5UmVtb3ZlSXRlbTxUPihhcnJheTogVFtdLCBjb25kaXRpb246IChpdGVtOiBUKSA9PiBib29sZWFuKTogYW55IHtcclxuICAgIGNvbnN0IGFycmF5Q29weSA9IFsuLi5hcnJheV07XHJcbiAgICBjb25zdCBpbmRleCA9IGFycmF5LmZpbmRJbmRleCgoaXRlbSkgPT4gY29uZGl0aW9uKGl0ZW0pKTtcclxuICAgIGlmIChpbmRleCA+IC0xKSB7XHJcbiAgICAgICAgYXJyYXlDb3B5LnNwbGljZShpbmRleCwgMSk7XHJcbiAgICB9XHJcbiAgICByZXR1cm4gYXJyYXlDb3B5O1xyXG59XHJcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,15 @@
+/*
+ * Public API Surface of grid
+ */
+export { ktdGridCompact, ktdTrackById } from './lib/utils/grid.utils';
+export * from './lib/directives/drag-handle';
+export * from './lib/directives/resize-handle';
+export * from './lib/directives/placeholder';
+export * from './lib/grid-item/grid-item.component';
+export * from './lib/grid.definitions';
+export * from './lib/grid/grid.component';
+export * from './lib/nav-container/nav-container.component';
+export * from './lib/layout-container/layout-container.component';
+export * from './lib/report-grid-layout/report-grid-layout.component';
+export * from './lib/barsa-user-workspace.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2JhcnNhLXVzZXItd29ya3NwYWNlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxZQUFZLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUV0RSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsbURBQW1ELENBQUM7QUFDbEUsY0FBYyx1REFBdUQsQ0FBQztBQUN0RSxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBncmlkXG4gKi9cbmV4cG9ydCB7IGt0ZEdyaWRDb21wYWN0LCBrdGRUcmFja0J5SWQgfSBmcm9tICcuL2xpYi91dGlscy9ncmlkLnV0aWxzJztcbmV4cG9ydCB7IEt0ZENsaWVudFJlY3QgfSBmcm9tICcuL2xpYi91dGlscy9jbGllbnQtcmVjdCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL2RyYWctaGFuZGxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMvcmVzaXplLWhhbmRsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL3BsYWNlaG9sZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dyaWQtaXRlbS9ncmlkLWl0ZW0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2dyaWQuZGVmaW5pdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZ3JpZC9ncmlkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9uYXYtY29udGFpbmVyL25hdi1jb250YWluZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2xheW91dC1jb250YWluZXIvbGF5b3V0LWNvbnRhaW5lci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcmVwb3J0LWdyaWQtbGF5b3V0L3JlcG9ydC1ncmlkLWxheW91dC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYmFyc2EtdXNlci13b3Jrc3BhY2UubW9kdWxlJztcblxuIl19

package/esm2022/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS11c2VyLXdvcmtzcGFjZS9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgS3RkRGljdGlvbmFyeTxUPiB7XG4gICAgW2tleTogc3RyaW5nXTogVDtcbn1cbiJdfQ==