@hugogo/angular-grid-layout-hugo
Version:
Grid Layout with draggable and resizable items for Angular
233 lines • 35.4 kB
JavaScript
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 /* UP */;
}
else if (pointerY >= bottom - yThreshold && pointerY <= bottom + yThreshold) {
return 2 /* DOWN */;
}
return 0 /* 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 /* LEFT */;
}
else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {
return 2 /* RIGHT */;
}
return 0 /* 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 /* UP */) {
incrementVerticalScroll(scrollNode, -scrollStep);
}
else if (verticalScrollDirection === 2 /* DOWN */) {
incrementVerticalScroll(scrollNode, scrollStep);
}
if (horizontalScrollDirection === 1 /* LEFT */) {
incrementHorizontalScroll(scrollNode, -scrollStep);
}
else if (horizontalScrollDirection === 2 /* 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 === null || options === void 0 ? void 0 : options.disableVertical) {
verticalScrollDirection = 0 /* NONE */;
}
if (options === null || options === void 0 ? void 0 : options.disableHorizontal) {
horizontalScrollDirection = 0 /* 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 === null || options === void 0 ? void 0 : 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":"../../../projects/angular-grid-layout-hugo/src/","sources":["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,EAAE,MAAM,eAAe,CAAC;AACrD,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;QAChB,IAAe,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;KACxC;SAAM;QACH,0FAA0F;QACzF,IAAoB,CAAC,SAAS,IAAI,MAAM,CAAC;KAC7C;AACL,CAAC;AAED;;;;GAIG;AACH,SAAS,yBAAyB,CAAC,IAA0B,EAAE,MAAc;IACzE,IAAI,IAAI,KAAK,MAAM,EAAE;QAChB,IAAe,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;KACxC;SAAM;QACH,0FAA0F;QACzF,IAAoB,CAAC,UAAU,IAAI,MAAM,CAAC;KAC9C;AACL,CAAC;AAGD;;;;GAIG;AACH,SAAS,0BAA0B,CAAC,UAAsB,EAAE,QAAgB;IACxE,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;QAC9D,kBAAsC;KACzC;SAAM,IAAI,QAAQ,IAAI,MAAM,GAAG,UAAU,IAAI,QAAQ,IAAI,MAAM,GAAG,UAAU,EAAE;QAC3E,oBAAwC;KAC3C;IAED,oBAAwC;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAS,4BAA4B,CAAC,UAAsB,EAAE,QAAgB;IAC1E,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;QAChE,oBAA0C;KAC7C;SAAM,IAAI,QAAQ,IAAI,KAAK,GAAG,UAAU,IAAI,QAAQ,IAAI,KAAK,GAAG,UAAU,EAAE;QACzE,qBAA2C;KAC9C;IAED,oBAA0C;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,eAAmC,EAAE;YAC5D,uBAAuB,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC;SACpD;aAAM,IAAI,uBAAuB,iBAAqC,EAAE;YACrE,uBAAuB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;SACnD;QAED,IAAI,yBAAyB,iBAAuC,EAAE;YAClE,yBAAyB,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC;SACtD;aAAM,IAAI,yBAAyB,kBAAwC,EAAE;YAC1E,yBAAyB,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;SACrD;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,0BAAsC,CAAC;IAC3C,IAAI,2BAAmC,CAAC;IAExC,IAAI,gBAAgB,KAAK,QAAQ,EAAE;QAC/B,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;KAC1D;SAAM;QACH,UAAU,GAAG,gBAA+B,CAAC;QAC7C,0BAA0B,GAAG,oBAAoB,CAAC,gBAA+B,CAAC,CAAC;QACnF,2BAA2B,GAAI,gBAAgC,CAAC,WAAW,CAAC;KAC/E;IAED;;;;OAIG;IACH,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IACxB,IAAI,OAAO,CAAC,iBAAiB,IAAI,IAAI,IAAI,2BAA2B,IAAI,0BAA0B,CAAC,KAAK,EAAE;QACtG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;KACpC;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,aAAP,OAAO,uBAAP,OAAO,CAAE,eAAe,EAAE;YAC1B,uBAAuB,eAAmC,CAAC;SAC9D;QACD,IAAI,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,iBAAiB,EAAE;YAC5B,yBAAyB,eAAqC,CAAC;SAClE;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;YACtD,OAAO,0BAA0B,CAAC,UAAU,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,UAAU,CAAC,CAAC;SAC1H;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;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;QAC/B,qBAAqB,GAAG,yBAAyB,EAAE,CAAC;KACvD;SAAM;QACH,qBAAqB,GAAG;YACpB,GAAG,EAAG,gBAAgC,CAAC,SAAS;YAChD,IAAI,EAAG,gBAAgC,CAAC,UAAU;SACrD,CAAC;KACL;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;YAC/B,MAAM,sBAAsB,GAAG,yBAAyB,EAAE,CAAC;YAC3D,MAAM,GAAG,sBAAsB,CAAC,GAAG,CAAC;YACpC,OAAO,GAAG,sBAAsB,CAAC,IAAI,CAAC;SACzC;aAAM;YACH,MAAM,GAAI,gBAAgC,CAAC,SAAS,CAAC;YACrD,OAAO,GAAI,gBAAgC,CAAC,UAAU,CAAC;SAC1D;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 } 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: ClientRect, 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: ClientRect, 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: ClientRect;\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(): ClientRect {\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"]}