@alauda-fe/common
Version:
Alauda frontend team common codes.
209 lines • 30.1 kB
JavaScript
import { animationFrameScheduler, fromEvent, interval, NEVER, distinctUntilChanged, filter, map, switchMap, tap, } from 'rxjs';
import { getClientRectSnapshot } from './client-rect.utils';
/**
* 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 */;
}
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 */;
}
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);
}
}), filter(() => false));
}
/**
* 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.
*/
// eslint-disable-next-line sonarjs/cognitive-complexity
export function scrollIfNearElementClientRect$(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 = getClientRectSnapshot(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) => prev.verticalScrollDirection === actual.verticalScrollDirection &&
prev.horizontalScrollDirection === actual.horizontalScrollDirection), switchMap(({ verticalScrollDirection, horizontalScrollDirection }) => {
if (verticalScrollDirection || horizontalScrollDirection) {
return scrollToDirectionInterval$(scrollNode, verticalScrollDirection, horizontalScrollDirection, options?.scrollStep);
}
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 getScrollTotalRelativeDifference$(scrollableParent) {
const scrollInitialPosition = scrollableParent === document
? getViewportScrollPosition()
: {
top: scrollableParent.scrollTop,
left: scrollableParent.scrollLeft,
};
return fromEvent(scrollableParent, 'scroll', {
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 the (top, left) scroll position of the viewport. */
function getViewportScrollPosition() {
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.utils.js","sourceRoot":"","sources":["../../../../../../libs/common/src/grid-layout/utils/scroll.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  animationFrameScheduler,\n  fromEvent,\n  interval,\n  NEVER,\n  Observable,\n  distinctUntilChanged,\n  filter,\n  map,\n  switchMap,\n  tap,\n} from 'rxjs';\n\nimport { GridItemClientRect } from '../public-api';\n\nimport { getClientRectSnapshot } from './client-rect.utils';\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 {\n  NONE,\n  UP,\n  DOWN,\n}\n\n/** Horizontal direction in which we can auto-scroll. */\nconst enum AutoScrollHorizontalDirection {\n  NONE,\n  LEFT,\n  RIGHT,\n}\n\nexport interface KtdScrollPosition {\n  top: number;\n  left: number;\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.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.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 * 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(\n  clientRect: GridItemClientRect,\n  pointerY: number,\n) {\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  }\n  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(\n  clientRect: GridItemClientRect,\n  pointerX: number,\n) {\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  }\n  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$(\n  scrollNode: HTMLElement | Window,\n  verticalScrollDirection: AutoScrollVerticalDirection,\n  horizontalScrollDirection: AutoScrollHorizontalDirection,\n  scrollStep = 2,\n) {\n  return interval(0, animationFrameScheduler).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 (\n        horizontalScrollDirection === AutoScrollHorizontalDirection.RIGHT\n      ) {\n        incrementHorizontalScroll(scrollNode, scrollStep);\n      }\n    }),\n    filter(() => false),\n  );\n}\n\nexport interface ScrollIfNearElementOptions {\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 */\n// eslint-disable-next-line sonarjs/cognitive-complexity\nexport function scrollIfNearElementClientRect$(\n  scrollableParent: Element | Document,\n  options?: ScrollIfNearElementOptions,\n): (\n  source$: Observable<{ pointerX: number; pointerY: number }>,\n) => Observable<any> {\n  let scrollNode: Window | HTMLElement;\n  let scrollableParentClientRect: GridItemClientRect;\n  let scrollableParentScrollWidth: number;\n\n  if (scrollableParent === document) {\n    scrollNode = document.defaultView as Window;\n    const { width, height } = getViewportSize();\n    scrollableParentClientRect = {\n      width,\n      height,\n      top: 0,\n      right: width,\n      bottom: height,\n      left: 0,\n    };\n    scrollableParentScrollWidth = getDocumentScrollWidth();\n  } else {\n    scrollNode = scrollableParent as HTMLElement;\n    scrollableParentClientRect = getClientRectSnapshot(\n      scrollableParent as HTMLElement,\n    );\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 (\n    options.disableHorizontal == null &&\n    scrollableParentScrollWidth <= scrollableParentClientRect.width\n  ) {\n    options.disableHorizontal = true;\n  }\n\n  return source$ =>\n    source$.pipe(\n      map(({ pointerX, pointerY }) => {\n        let verticalScrollDirection = getVerticalScrollDirection(\n          scrollableParentClientRect,\n          pointerY,\n        );\n        let horizontalScrollDirection = getHorizontalScrollDirection(\n          scrollableParentClientRect,\n          pointerX,\n        );\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(\n        (prev, actual) =>\n          prev.verticalScrollDirection === actual.verticalScrollDirection &&\n          prev.horizontalScrollDirection === actual.horizontalScrollDirection,\n      ),\n      switchMap(({ verticalScrollDirection, horizontalScrollDirection }) => {\n        if (verticalScrollDirection || horizontalScrollDirection) {\n          return scrollToDirectionInterval$(\n            scrollNode,\n            verticalScrollDirection,\n            horizontalScrollDirection,\n            options?.scrollStep,\n          );\n        }\n        return NEVER;\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 getScrollTotalRelativeDifference$(\n  scrollableParent: Element | Document,\n): Observable<{ top: number; left: number }> {\n  const scrollInitialPosition =\n    scrollableParent === document\n      ? getViewportScrollPosition()\n      : {\n          top: (scrollableParent as HTMLElement).scrollTop,\n          left: (scrollableParent as HTMLElement).scrollLeft,\n        };\n  return fromEvent(scrollableParent, 'scroll', {\n    capture: true,\n  }).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/** 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/** Gets the (top, left) scroll position of the viewport. */\nfunction getViewportScrollPosition(): { top: number; left: number } {\n  const windowRef = document.defaultView || window;\n  const documentElement = document.documentElement;\n  const documentRect = documentElement.getBoundingClientRect();\n\n  const top =\n    -documentRect.top ||\n    document.body.scrollTop ||\n    windowRef.scrollY ||\n    documentElement.scrollTop ||\n    0;\n\n  const left =\n    -documentRect.left ||\n    document.body.scrollLeft ||\n    windowRef.scrollX ||\n    documentElement.scrollLeft ||\n    0;\n\n  return { top, left };\n}\n\n/** Returns the document scroll width */\nfunction getDocumentScrollWidth() {\n  return Math.max(\n    document.body.scrollWidth,\n    document.documentElement.scrollWidth,\n  );\n}\n"]}