pdf-reader-web/helpers/utility.ts

/* eslint-disable no-underscore-dangle */
import { fromEvent } from 'rxjs';
import {
  auditTime,
  throttleTime,
} from 'rxjs/operators';

import { ScrollStateType } from '../constants/type';

export const objIsEmpty = (obj: Record<string, any>): boolean => !Object.keys(obj).length;

export const watchScroll = (
  viewAreaElement: HTMLElement | null, cb: (state: ScrollStateType) => void,
): ScrollStateType => {
  let rAF: number | null = null;
  const element = viewAreaElement as HTMLElement;
  const state = {
    right: true,
    down: true,
    lastX: element.scrollLeft,
    lastY: element.scrollTop,
  };

  const debounceScroll = (): void => {
    if (rAF) {
      return;
    }
    // schedule an invocation of scroll for next animation frame.
    rAF = window.requestAnimationFrame(() => {
      rAF = null;

      const currentX = element.scrollLeft;
      const { lastX } = state;
      if (currentX !== lastX) {
        state.right = currentX > lastX;
      }
      state.lastX = currentX;
      const currentY = element.scrollTop;
      const { lastY } = state;
      if (currentY !== lastY) {
        state.down = currentY > lastY;
      }
      state.lastY = currentY;
      cb(state);
    });
  };

  fromEvent(element, 'scroll').pipe(
    throttleTime(200),
    auditTime(300),
  ).subscribe(debounceScroll);

  return state;
};

export const scrollIntoView = (
  element: HTMLElement, spot?: {top: number}, skipOverflowHiddenElements = false,
): void => {
  let parent: HTMLElement = element.offsetParent as HTMLElement;
  let offsetY = element.offsetTop + element.clientTop;

  if (!parent) {
    return; // no need to scroll
  }
  while (
    (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent.scrollWidth)
    || (skipOverflowHiddenElements && getComputedStyle(parent).overflow === 'hidden')
  ) {
    if (parent.dataset._scaleY) {
      offsetY /= parseInt(parent.dataset._scaleY, 10);
    }
    offsetY += parent.offsetTop;
    parent = parent.offsetParent as HTMLElement;
    if (!parent) {
      return; // no need to scroll
    }
  }

  if (spot) {
    if (spot.top !== undefined) {
      offsetY += spot.top;
    }
  }

  parent.scrollTop = offsetY;
};

export const scaleCheck = (scale: number): number => {
  if (typeof scale === 'number' && scale >= 50 && scale <= 250) {
    return Math.round(scale * 100) / 10000;
  }
  if (scale < 50) {
    return 0.5;
  }
  return 2.5;
};

export const hexToRgb = (hex: string): any => {
  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
  return result ? {
    r: parseInt(result[1], 16),
    g: parseInt(result[2], 16),
    b: parseInt(result[3], 16),
  } : null;
};

export const chunk = (arr: any[], chunkSize: number): any[] => {
  const R = [];
  for (let i = 0, len = arr.length; i < len; i += chunkSize) {
    R.push(arr.slice(i, i + chunkSize));
  }
  return R;
};