@katoid/angular-grid-layout
Version:
Grid Layout with draggable and resizable items for Angular
233 lines • 36.3 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 /* 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/angular-grid-layout/src/lib/utils/scroll.ts"],"names":[],"mappings":"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","sourcesContent":["import { animationFrameScheduler, fromEvent, interval, NEVER, Observable } from 'rxjs';\r\nimport { distinctUntilChanged, map, switchMap, tap } from 'rxjs/operators';\r\nimport { ktdNormalizePassiveListenerOptions } from './passive-listeners';\r\nimport { getMutableClientRect, KtdClientRect } from './client-rect';\r\nimport { ktdNoEmit } from './operators';\r\n\r\n/**\r\n * Proximity, as a ratio to width/height at which to start auto-scrolling.\r\n * The value comes from trying it out manually until it feels right.\r\n */\r\nconst SCROLL_PROXIMITY_THRESHOLD = 0.05;\r\n\r\n/** Vertical direction in which we can auto-scroll. */\r\nconst enum AutoScrollVerticalDirection {NONE, UP, DOWN}\r\n\r\n/** Horizontal direction in which we can auto-scroll. */\r\nconst enum AutoScrollHorizontalDirection {NONE, LEFT, RIGHT}\r\n\r\nexport interface KtdScrollPosition {\r\n    top: number;\r\n    left: number;\r\n}\r\n\r\n\r\n/**\r\n * Increments the vertical scroll position of a node.\r\n * @param node Node whose scroll position should change.\r\n * @param amount Amount of pixels that the `node` should be scrolled.\r\n */\r\nfunction incrementVerticalScroll(node: HTMLElement | Window, amount: number) {\r\n    if (node === window) {\r\n        (node as Window).scrollBy(0, amount);\r\n    } else {\r\n        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.\r\n        (node as HTMLElement).scrollTop += amount;\r\n    }\r\n}\r\n\r\n/**\r\n * Increments the horizontal scroll position of a node.\r\n * @param node Node whose scroll position should change.\r\n * @param amount Amount of pixels that the `node` should be scrolled.\r\n */\r\nfunction incrementHorizontalScroll(node: HTMLElement | Window, amount: number) {\r\n    if (node === window) {\r\n        (node as Window).scrollBy(amount, 0);\r\n    } else {\r\n        // Ideally we could use `Element.scrollBy` here as well, but IE and Edge don't support it.\r\n        (node as HTMLElement).scrollLeft += amount;\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * Gets whether the vertical auto-scroll direction of a node.\r\n * @param clientRect Dimensions of the node.\r\n * @param pointerY Position of the user's pointer along the y axis.\r\n */\r\nfunction getVerticalScrollDirection(clientRect: KtdClientRect, pointerY: number) {\r\n    const {top, bottom, height} = clientRect;\r\n    const yThreshold = height * SCROLL_PROXIMITY_THRESHOLD;\r\n\r\n    if (pointerY >= top - yThreshold && pointerY <= top + yThreshold) {\r\n        return AutoScrollVerticalDirection.UP;\r\n    } else if (pointerY >= bottom - yThreshold && pointerY <= bottom + yThreshold) {\r\n        return AutoScrollVerticalDirection.DOWN;\r\n    }\r\n\r\n    return AutoScrollVerticalDirection.NONE;\r\n}\r\n\r\n/**\r\n * Gets whether the horizontal auto-scroll direction of a node.\r\n * @param clientRect Dimensions of the node.\r\n * @param pointerX Position of the user's pointer along the x axis.\r\n */\r\nfunction getHorizontalScrollDirection(clientRect: KtdClientRect, pointerX: number) {\r\n    const {left, right, width} = clientRect;\r\n    const xThreshold = width * SCROLL_PROXIMITY_THRESHOLD;\r\n\r\n    if (pointerX >= left - xThreshold && pointerX <= left + xThreshold) {\r\n        return AutoScrollHorizontalDirection.LEFT;\r\n    } else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {\r\n        return AutoScrollHorizontalDirection.RIGHT;\r\n    }\r\n\r\n    return AutoScrollHorizontalDirection.NONE;\r\n}\r\n\r\n/**\r\n * Returns an observable that schedules a loop and apply scroll on the scrollNode into the specified direction/s.\r\n * This observable doesn't emit, it just performs the 'scroll' side effect.\r\n * @param scrollNode, node where the scroll would be applied.\r\n * @param verticalScrollDirection, vertical direction of the scroll.\r\n * @param horizontalScrollDirection, horizontal direction of the scroll.\r\n * @param scrollStep, scroll step in CSS pixels that would be applied in every loop.\r\n */\r\nfunction scrollToDirectionInterval$(scrollNode: HTMLElement | Window, verticalScrollDirection: AutoScrollVerticalDirection, horizontalScrollDirection: AutoScrollHorizontalDirection, scrollStep: number = 2) {\r\n    return interval(0, animationFrameScheduler)\r\n        .pipe(\r\n            tap(() => {\r\n                if (verticalScrollDirection === AutoScrollVerticalDirection.UP) {\r\n                    incrementVerticalScroll(scrollNode, -scrollStep);\r\n                } else if (verticalScrollDirection === AutoScrollVerticalDirection.DOWN) {\r\n                    incrementVerticalScroll(scrollNode, scrollStep);\r\n                }\r\n\r\n                if (horizontalScrollDirection === AutoScrollHorizontalDirection.LEFT) {\r\n                    incrementHorizontalScroll(scrollNode, -scrollStep);\r\n                } else if (horizontalScrollDirection === AutoScrollHorizontalDirection.RIGHT) {\r\n                    incrementHorizontalScroll(scrollNode, scrollStep);\r\n                }\r\n            }),\r\n            ktdNoEmit()\r\n        );\r\n}\r\n\r\nexport interface KtdScrollIfNearElementOptions {\r\n    scrollStep?: number;\r\n    disableVertical?: boolean;\r\n    disableHorizontal?: boolean;\r\n}\r\n\r\n/**\r\n * Given a source$ observable with pointer location, scroll the scrollNode if the pointer is near to it.\r\n * This observable doesn't emit, it just performs a 'scroll' side effect.\r\n * @param scrollableParent, parent node in which the scroll would be performed.\r\n * @param options, configuration options.\r\n */\r\nexport function ktdScrollIfNearElementClientRect$(scrollableParent: HTMLElement | Document, options?: KtdScrollIfNearElementOptions): (source$: Observable<{ pointerX: number, pointerY: number }>) => Observable<any> {\r\n\r\n    let scrollNode: Window | HTMLElement;\r\n    let scrollableParentClientRect: KtdClientRect;\r\n    let scrollableParentScrollWidth: number;\r\n\r\n    if (scrollableParent === document) {\r\n        scrollNode = document.defaultView as Window;\r\n        const {width, height} = getViewportSize();\r\n        scrollableParentClientRect = {width, height, top: 0, right: width, bottom: height, left: 0};\r\n        scrollableParentScrollWidth = getDocumentScrollWidth();\r\n    } else {\r\n        scrollNode = scrollableParent as HTMLElement;\r\n        scrollableParentClientRect = getMutableClientRect(scrollableParent as HTMLElement);\r\n        scrollableParentScrollWidth = (scrollableParent as HTMLElement).scrollWidth;\r\n    }\r\n\r\n    /**\r\n     * IMPORTANT: By design, only let scroll horizontal if the scrollable parent has explicitly an scroll horizontal.\r\n     * This layout solution is not designed in mind to have any scroll horizontal, but exceptionally we allow it in this\r\n     * specific use case.\r\n     */\r\n    options = options || {};\r\n    if (options.disableHorizontal == null && scrollableParentScrollWidth <= scrollableParentClientRect.width) {\r\n        options.disableHorizontal = true;\r\n    }\r\n\r\n    return (source$) => source$.pipe(\r\n        map(({pointerX, pointerY}) => {\r\n            let verticalScrollDirection = getVerticalScrollDirection(scrollableParentClientRect, pointerY);\r\n            let horizontalScrollDirection = getHorizontalScrollDirection(scrollableParentClientRect, pointerX);\r\n\r\n            // Check if scroll directions are disabled.\r\n            if (options?.disableVertical) {\r\n                verticalScrollDirection = AutoScrollVerticalDirection.NONE;\r\n            }\r\n            if (options?.disableHorizontal) {\r\n                horizontalScrollDirection = AutoScrollHorizontalDirection.NONE;\r\n            }\r\n\r\n            return {verticalScrollDirection, horizontalScrollDirection};\r\n        }),\r\n        distinctUntilChanged((prev, actual) => {\r\n            return prev.verticalScrollDirection === actual.verticalScrollDirection\r\n                && prev.horizontalScrollDirection === actual.horizontalScrollDirection;\r\n        }),\r\n        switchMap(({verticalScrollDirection, horizontalScrollDirection}) => {\r\n            if (verticalScrollDirection || horizontalScrollDirection) {\r\n                return scrollToDirectionInterval$(scrollNode, verticalScrollDirection, horizontalScrollDirection, options?.scrollStep);\r\n            } else {\r\n                return NEVER;\r\n            }\r\n        })\r\n    );\r\n}\r\n\r\n/**\r\n * Emits on EVERY scroll event and returns the accumulated scroll offset relative to the initial scroll position.\r\n * @param scrollableParent, node in which scroll events would be listened.\r\n */\r\nexport function ktdGetScrollTotalRelativeDifference$(scrollableParent: HTMLElement | Document): Observable<{ top: number, left: number }> {\r\n    let scrollInitialPosition;\r\n\r\n    // Calculate initial scroll position\r\n    if (scrollableParent === document) {\r\n        scrollInitialPosition = getViewportScrollPosition();\r\n    } else {\r\n        scrollInitialPosition = {\r\n            top: (scrollableParent as HTMLElement).scrollTop,\r\n            left: (scrollableParent as HTMLElement).scrollLeft\r\n        };\r\n    }\r\n\r\n    return fromEvent(scrollableParent, 'scroll', ktdNormalizePassiveListenerOptions({capture: true}) as AddEventListenerOptions).pipe(\r\n        map(() => {\r\n            let newTop: number;\r\n            let newLeft: number;\r\n\r\n            if (scrollableParent === document) {\r\n                const viewportScrollPosition = getViewportScrollPosition();\r\n                newTop = viewportScrollPosition.top;\r\n                newLeft = viewportScrollPosition.left;\r\n            } else {\r\n                newTop = (scrollableParent as HTMLElement).scrollTop;\r\n                newLeft = (scrollableParent as HTMLElement).scrollLeft;\r\n            }\r\n\r\n            const topDifference = scrollInitialPosition.top - newTop;\r\n            const leftDifference = scrollInitialPosition.left - newLeft;\r\n\r\n            return {top: topDifference, left: leftDifference};\r\n        })\r\n    );\r\n\r\n}\r\n\r\n/** Returns the viewport's width and height. */\r\nfunction getViewportSize(): { width: number, height: number } {\r\n    const _window = document.defaultView || window;\r\n    return {\r\n        width: _window.innerWidth,\r\n        height: _window.innerHeight\r\n    };\r\n\r\n}\r\n\r\n/** Gets a ClientRect for the viewport's bounds. */\r\nfunction getViewportRect(): KtdClientRect {\r\n    // Use the document element's bounding rect rather than the window scroll properties\r\n    // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\r\n    // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\r\n    // conceptual viewports. Under most circumstances these viewports are equivalent, but they\r\n    // can disagree when the page is pinch-zoomed (on devices that support touch).\r\n    // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\r\n    // We use the documentElement instead of the body because, by default (without a css reset)\r\n    // browsers typically give the document body an 8px margin, which is not included in\r\n    // getBoundingClientRect().\r\n    const scrollPosition = getViewportScrollPosition();\r\n    const {width, height} = getViewportSize();\r\n\r\n    return {\r\n        top: scrollPosition.top,\r\n        left: scrollPosition.left,\r\n        bottom: scrollPosition.top + height,\r\n        right: scrollPosition.left + width,\r\n        height,\r\n        width,\r\n    };\r\n}\r\n\r\n/** Gets the (top, left) scroll position of the viewport. */\r\nfunction getViewportScrollPosition(): { top: number, left: number } {\r\n\r\n    // The top-left-corner of the viewport is determined by the scroll position of the document\r\n    // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\r\n    // whether `document.body` or `document.documentElement` is the scrolled element, so reading\r\n    // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\r\n    // `document.documentElement` works consistently, where the `top` and `left` values will\r\n    // equal negative the scroll position.\r\n    const windowRef = document.defaultView || window;\r\n    const documentElement = document.documentElement!;\r\n    const documentRect = documentElement.getBoundingClientRect();\r\n\r\n    const top = -documentRect.top || document.body.scrollTop || windowRef.scrollY ||\r\n        documentElement.scrollTop || 0;\r\n\r\n    const left = -documentRect.left || document.body.scrollLeft || windowRef.scrollX ||\r\n        documentElement.scrollLeft || 0;\r\n\r\n    return {top, left};\r\n}\r\n\r\n/** Returns the document scroll width */\r\nfunction getDocumentScrollWidth() {\r\n    return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth);\r\n}\r\n\r\n"]}