Latest updates from IceHrmPro

web/node_modules/rc-align/es/Align.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Removed props:
+ *  - childrenProps
+ */
+import React from 'react';
+import { AlignType, AlignResult, TargetType } from './interface';
+declare type OnAlign = (source: HTMLElement, result: AlignResult) => void;
+export interface AlignProps {
+    align: AlignType;
+    target: TargetType;
+    onAlign?: OnAlign;
+    monitorBufferTime?: number;
+    monitorWindowResize?: boolean;
+    disabled?: boolean;
+    children: React.ReactElement;
+}
+export interface RefAlign {
+    forceAlign: () => void;
+}
+declare const RefAlign: React.ForwardRefExoticComponent<AlignProps & React.RefAttributes<RefAlign>>;
+export default RefAlign;

web/node_modules/rc-align/es/Align.js

@@ -0,0 +1,168 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/**
+ * Removed props:
+ *  - childrenProps
+ */
+import React from 'react';
+import { composeRef } from "rc-util/es/ref";
+import { alignElement, alignPoint } from 'dom-align';
+import addEventListener from "rc-util/es/Dom/addEventListener";
+import { isSamePoint, restoreFocus, monitorResize } from './util';
+import useBuffer from './hooks/useBuffer';
+
+function getElement(func) {
+  if (typeof func !== 'function') return null;
+  return func();
+}
+
+function getPoint(point) {
+  if (_typeof(point) !== 'object' || !point) return null;
+  return point;
+}
+
+var Align = function Align(_ref, ref) {
+  var children = _ref.children,
+      disabled = _ref.disabled,
+      target = _ref.target,
+      align = _ref.align,
+      onAlign = _ref.onAlign,
+      monitorWindowResize = _ref.monitorWindowResize,
+      _ref$monitorBufferTim = _ref.monitorBufferTime,
+      monitorBufferTime = _ref$monitorBufferTim === void 0 ? 0 : _ref$monitorBufferTim;
+  var cacheRef = React.useRef({});
+  var nodeRef = React.useRef();
+  var childNode = React.Children.only(children); // ===================== Align ======================
+  // We save the props here to avoid closure makes props ood
+
+  var forceAlignPropsRef = React.useRef({});
+  forceAlignPropsRef.current.disabled = disabled;
+  forceAlignPropsRef.current.target = target;
+  forceAlignPropsRef.current.onAlign = onAlign;
+
+  var _useBuffer = useBuffer(function () {
+    var _forceAlignPropsRef$c = forceAlignPropsRef.current,
+        latestDisabled = _forceAlignPropsRef$c.disabled,
+        latestTarget = _forceAlignPropsRef$c.target;
+
+    if (!latestDisabled && latestTarget) {
+      var source = nodeRef.current;
+      var result;
+      var element = getElement(latestTarget);
+      var point = getPoint(latestTarget);
+      cacheRef.current.element = element;
+      cacheRef.current.point = point; // IE lose focus after element realign
+      // We should record activeElement and restore later
+
+      var _document = document,
+          activeElement = _document.activeElement;
+
+      if (element) {
+        result = alignElement(source, element, align);
+      } else if (point) {
+        result = alignPoint(source, point, align);
+      }
+
+      restoreFocus(activeElement, source);
+
+      if (onAlign) {
+        onAlign(source, result);
+      }
+
+      return true;
+    }
+
+    return false;
+  }, monitorBufferTime),
+      _useBuffer2 = _slicedToArray(_useBuffer, 2),
+      _forceAlign = _useBuffer2[0],
+      cancelForceAlign = _useBuffer2[1]; // ===================== Effect =====================
+  // Listen for target updated
+
+
+  var resizeMonitor = React.useRef({
+    cancel: function cancel() {}
+  }); // Listen for source updated
+
+  var sourceResizeMonitor = React.useRef({
+    cancel: function cancel() {}
+  });
+  React.useEffect(function () {
+    var element = getElement(target);
+    var point = getPoint(target);
+
+    if (nodeRef.current !== sourceResizeMonitor.current.element) {
+      sourceResizeMonitor.current.cancel();
+      sourceResizeMonitor.current.element = nodeRef.current;
+      sourceResizeMonitor.current.cancel = monitorResize(nodeRef.current, _forceAlign);
+    }
+
+    if (cacheRef.current.element !== element || !isSamePoint(cacheRef.current.point, point)) {
+      _forceAlign(); // Add resize observer
+
+
+      if (resizeMonitor.current.element !== element) {
+        resizeMonitor.current.cancel();
+        resizeMonitor.current.element = element;
+        resizeMonitor.current.cancel = monitorResize(element, _forceAlign);
+      }
+    }
+  }); // Listen for disabled change
+
+  React.useEffect(function () {
+    if (!disabled) {
+      _forceAlign();
+    } else {
+      cancelForceAlign();
+    }
+  }, [disabled]); // Listen for window resize
+
+  var winResizeRef = React.useRef(null);
+  React.useEffect(function () {
+    if (monitorWindowResize) {
+      if (!winResizeRef.current) {
+        winResizeRef.current = addEventListener(window, 'resize', _forceAlign);
+      }
+    } else if (winResizeRef.current) {
+      winResizeRef.current.remove();
+      winResizeRef.current = null;
+    }
+  }, [monitorWindowResize]); // Clear all if unmount
+
+  React.useEffect(function () {
+    return function () {
+      resizeMonitor.current.cancel();
+      sourceResizeMonitor.current.cancel();
+      if (winResizeRef.current) winResizeRef.current.remove();
+      cancelForceAlign();
+    };
+  }, []); // ====================== Ref =======================
+
+  React.useImperativeHandle(ref, function () {
+    return {
+      forceAlign: function forceAlign() {
+        return _forceAlign(true);
+      }
+    };
+  }); // ===================== Render =====================
+
+  if (React.isValidElement(childNode)) {
+    childNode = React.cloneElement(childNode, {
+      ref: composeRef(childNode.ref, nodeRef)
+    });
+  }
+
+  return childNode;
+};
+
+var RefAlign = React.forwardRef(Align);
+RefAlign.displayName = 'Align';
+export default RefAlign;

web/node_modules/rc-align/es/hooks/useBuffer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (callback: () => boolean, buffer: number) => ((force?: boolean) => void)[];
+export default _default;

web/node_modules/rc-align/es/hooks/useBuffer.js

@@ -0,0 +1,35 @@
+import React from 'react';
+export default (function (callback, buffer) {
+  var calledRef = React.useRef(false);
+  var timeoutRef = React.useRef(null);
+
+  function cancelTrigger() {
+    window.clearTimeout(timeoutRef.current);
+  }
+
+  function trigger(force) {
+    if (!calledRef.current || force === true) {
+      if (callback() === false) {
+        // Not delay since callback cancelled self
+        return;
+      }
+
+      calledRef.current = true;
+      cancelTrigger();
+      timeoutRef.current = window.setTimeout(function () {
+        calledRef.current = false;
+      }, buffer);
+    } else {
+      cancelTrigger();
+      timeoutRef.current = window.setTimeout(function () {
+        calledRef.current = false;
+        trigger();
+      }, buffer);
+    }
+  }
+
+  return [trigger, function () {
+    calledRef.current = false;
+    cancelTrigger();
+  }];
+});

web/node_modules/rc-align/es/index.d.ts

@@ -0,0 +1,2 @@
+import Align from './Align';
+export default Align;

web/node_modules/rc-align/es/index.js

@@ -0,0 +1,3 @@
+// export this package's api
+import Align from './Align';
+export default Align;

web/node_modules/rc-align/es/interface.d.ts

@@ -0,0 +1,56 @@
+/** Two char of 't' 'b' 'c' 'l' 'r'. Example: 'lt' */
+export declare type AlignPoint = string;
+export interface AlignType {
+    /**
+     * move point of source node to align with point of target node.
+     * Such as ['tr','cc'], align top right point of source node with center point of target node.
+     * Point can be 't'(top), 'b'(bottom), 'c'(center), 'l'(left), 'r'(right) */
+    points?: AlignPoint[];
+    /**
+     * offset source node by offset[0] in x and offset[1] in y.
+     * If offset contains percentage string value, it is relative to sourceNode region.
+     */
+    offset?: number[];
+    /**
+     * offset target node by offset[0] in x and offset[1] in y.
+     * If targetOffset contains percentage string value, it is relative to targetNode region.
+     */
+    targetOffset?: number[];
+    /**
+     * If adjustX field is true, will adjust source node in x direction if source node is invisible.
+     * If adjustY field is true, will adjust source node in y direction if source node is invisible.
+     */
+    overflow?: {
+        adjustX?: boolean | number;
+        adjustY?: boolean | number;
+    };
+    /**
+     * Whether use css right instead of left to position
+     */
+    useCssRight?: boolean;
+    /**
+     * Whether use css bottom instead of top to position
+     */
+    useCssBottom?: boolean;
+    /**
+     * Whether use css transform instead of left/top/right/bottom to position if browser supports.
+     * Defaults to false.
+     */
+    useCssTransform?: boolean;
+}
+export interface AlignResult {
+    points: AlignPoint[];
+    offset: number[];
+    targetOffset: number[];
+    overflow: {
+        adjustX: boolean | number;
+        adjustY: boolean | number;
+    };
+}
+export interface TargetPoint {
+    clientX?: number;
+    clientY?: number;
+    pageX?: number;
+    pageY?: number;
+}
+export declare type TargetType = (() => HTMLElement) | TargetPoint;

web/node_modules/rc-align/es/util.d.ts

@@ -0,0 +1,4 @@
+import { TargetPoint } from './interface';
+export declare function isSamePoint(prev: TargetPoint, next: TargetPoint): boolean;
+export declare function restoreFocus(activeElement: any, container: any): void;
+export declare function monitorResize(element: HTMLElement, callback: Function): () => void;

web/node_modules/rc-align/es/util.js

@@ -0,0 +1,66 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import ResizeObserver from 'resize-observer-polyfill';
+import contains from "rc-util/es/Dom/contains";
+export function isSamePoint(prev, next) {
+  if (prev === next) return true;
+  if (!prev || !next) return false;
+
+  if ('pageX' in next && 'pageY' in next) {
+    return prev.pageX === next.pageX && prev.pageY === next.pageY;
+  }
+
+  if ('clientX' in next && 'clientY' in next) {
+    return prev.clientX === next.clientX && prev.clientY === next.clientY;
+  }
+
+  return false;
+}
+export function restoreFocus(activeElement, container) {
+  // Focus back if is in the container
+  if (activeElement !== document.activeElement && contains(container, activeElement)) {
+    activeElement.focus();
+  }
+}
+export function monitorResize(element, callback) {
+  var prevWidth = null;
+  var prevHeight = null;
+
+  function onResize(_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+        target = _ref2[0].target;
+
+    var _target$getBoundingCl = target.getBoundingClientRect(),
+        width = _target$getBoundingCl.width,
+        height = _target$getBoundingCl.height;
+
+    var fixedWidth = Math.floor(width);
+    var fixedHeight = Math.floor(height);
+
+    if (prevWidth !== fixedWidth || prevHeight !== fixedHeight) {
+      callback({
+        width: fixedWidth,
+        height: fixedHeight
+      });
+    }
+
+    prevWidth = fixedWidth;
+    prevHeight = fixedHeight;
+  }
+
+  var resizeObserver = new ResizeObserver(onResize);
+
+  if (element) {
+    resizeObserver.observe(element);
+  }
+
+  return function () {
+    resizeObserver.disconnect();
+  };
+}