Latest updates from IceHrmPro

web/node_modules/rc-picker/es/utils/dateUtil.d.ts

@@ -0,0 +1,17 @@
+import { GenerateConfig } from '../generate';
+import { NullableDateType, PickerMode } from '../interface';
+export declare const WEEK_DAY_COUNT = 7;
+export declare function isNullEqual<T>(value1: T, value2: T): boolean | undefined;
+export declare function isSameDecade<DateType>(generateConfig: GenerateConfig<DateType>, decade1: NullableDateType<DateType>, decade2: NullableDateType<DateType>): boolean;
+export declare function isSameYear<DateType>(generateConfig: GenerateConfig<DateType>, year1: NullableDateType<DateType>, year2: NullableDateType<DateType>): boolean;
+export declare function getQuarter<DateType>(generateConfig: GenerateConfig<DateType>, date: DateType): number;
+export declare function isSameQuarter<DateType>(generateConfig: GenerateConfig<DateType>, quarter1: NullableDateType<DateType>, quarter2: NullableDateType<DateType>): boolean;
+export declare function isSameMonth<DateType>(generateConfig: GenerateConfig<DateType>, month1: NullableDateType<DateType>, month2: NullableDateType<DateType>): boolean;
+export declare function isSameDate<DateType>(generateConfig: GenerateConfig<DateType>, date1: NullableDateType<DateType>, date2: NullableDateType<DateType>): boolean;
+export declare function isSameTime<DateType>(generateConfig: GenerateConfig<DateType>, time1: NullableDateType<DateType>, time2: NullableDateType<DateType>): boolean;
+export declare function isSameWeek<DateType>(generateConfig: GenerateConfig<DateType>, locale: string, date1: NullableDateType<DateType>, date2: NullableDateType<DateType>): boolean;
+export declare function isEqual<DateType>(generateConfig: GenerateConfig<DateType>, value1: NullableDateType<DateType>, value2: NullableDateType<DateType>): boolean;
+/** Between in date but not equal of date */
+export declare function isInRange<DateType>(generateConfig: GenerateConfig<DateType>, startDate: NullableDateType<DateType>, endDate: NullableDateType<DateType>, current: NullableDateType<DateType>): boolean;
+export declare function getWeekStartDate<DateType>(locale: string, generateConfig: GenerateConfig<DateType>, value: DateType): DateType;
+export declare function getClosingViewDate<DateType>(viewDate: DateType, picker: PickerMode, generateConfig: GenerateConfig<DateType>, offset?: number): DateType;

web/node_modules/rc-picker/es/utils/dateUtil.js

@@ -0,0 +1,119 @@
+export var WEEK_DAY_COUNT = 7;
+export function isNullEqual(value1, value2) {
+  if (!value1 && !value2) {
+    return true;
+  }
+
+  if (!value1 || !value2) {
+    return false;
+  }
+
+  return undefined;
+}
+export function isSameDecade(generateConfig, decade1, decade2) {
+  var equal = isNullEqual(decade1, decade2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  var num1 = Math.floor(generateConfig.getYear(decade1) / 10);
+  var num2 = Math.floor(generateConfig.getYear(decade2) / 10);
+  return num1 === num2;
+}
+export function isSameYear(generateConfig, year1, year2) {
+  var equal = isNullEqual(year1, year2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return generateConfig.getYear(year1) === generateConfig.getYear(year2);
+}
+export function getQuarter(generateConfig, date) {
+  var quota = Math.floor(generateConfig.getMonth(date) / 3);
+  return quota + 1;
+}
+export function isSameQuarter(generateConfig, quarter1, quarter2) {
+  var equal = isNullEqual(quarter1, quarter2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return isSameYear(generateConfig, quarter1, quarter2) && getQuarter(generateConfig, quarter1) === getQuarter(generateConfig, quarter2);
+}
+export function isSameMonth(generateConfig, month1, month2) {
+  var equal = isNullEqual(month1, month2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return isSameYear(generateConfig, month1, month2) && generateConfig.getMonth(month1) === generateConfig.getMonth(month2);
+}
+export function isSameDate(generateConfig, date1, date2) {
+  var equal = isNullEqual(date1, date2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return generateConfig.getYear(date1) === generateConfig.getYear(date2) && generateConfig.getMonth(date1) === generateConfig.getMonth(date2) && generateConfig.getDate(date1) === generateConfig.getDate(date2);
+}
+export function isSameTime(generateConfig, time1, time2) {
+  var equal = isNullEqual(time1, time2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return generateConfig.getHour(time1) === generateConfig.getHour(time2) && generateConfig.getMinute(time1) === generateConfig.getMinute(time2) && generateConfig.getSecond(time1) === generateConfig.getSecond(time2);
+}
+export function isSameWeek(generateConfig, locale, date1, date2) {
+  var equal = isNullEqual(date1, date2);
+
+  if (typeof equal === 'boolean') {
+    return equal;
+  }
+
+  return generateConfig.locale.getWeek(locale, date1) === generateConfig.locale.getWeek(locale, date2);
+}
+export function isEqual(generateConfig, value1, value2) {
+  return isSameDate(generateConfig, value1, value2) && isSameTime(generateConfig, value1, value2);
+}
+/** Between in date but not equal of date */
+
+export function isInRange(generateConfig, startDate, endDate, current) {
+  if (!startDate || !endDate || !current) {
+    return false;
+  }
+
+  return !isSameDate(generateConfig, startDate, current) && !isSameDate(generateConfig, endDate, current) && generateConfig.isAfter(current, startDate) && generateConfig.isAfter(endDate, current);
+}
+export function getWeekStartDate(locale, generateConfig, value) {
+  var weekFirstDay = generateConfig.locale.getWeekFirstDay(locale);
+  var monthStartDate = generateConfig.setDate(value, 1);
+  var startDateWeekDay = generateConfig.getWeekDay(monthStartDate);
+  var alignStartDate = generateConfig.addDate(monthStartDate, weekFirstDay - startDateWeekDay);
+
+  if (generateConfig.getMonth(alignStartDate) === generateConfig.getMonth(value) && generateConfig.getDate(alignStartDate) > 1) {
+    alignStartDate = generateConfig.addDate(alignStartDate, -7);
+  }
+
+  return alignStartDate;
+}
+export function getClosingViewDate(viewDate, picker, generateConfig) {
+  var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+
+  switch (picker) {
+    case 'year':
+      return generateConfig.addYear(viewDate, offset * 10);
+
+    case 'month':
+      return generateConfig.addYear(viewDate, offset);
+
+    default:
+      return generateConfig.addMonth(viewDate, offset);
+  }
+}

web/node_modules/rc-picker/es/utils/getExtraFooter.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { PanelMode } from '../interface';
+export default function getExtraFooter(prefixCls: string, mode: PanelMode, renderExtraFooter?: (mode: PanelMode) => React.ReactNode): JSX.Element;

web/node_modules/rc-picker/es/utils/getExtraFooter.js

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export default function getExtraFooter(prefixCls, mode, renderExtraFooter) {
+  if (!renderExtraFooter) {
+    return null;
+  }
+
+  return React.createElement("div", {
+    className: "".concat(prefixCls, "-footer-extra")
+  }, renderExtraFooter(mode));
+}

web/node_modules/rc-picker/es/utils/getRanges.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { Components, RangeList, Locale } from '../interface';
+export interface RangesProps {
+    prefixCls: string;
+    rangeList?: RangeList;
+    components?: Components;
+    needConfirmButton: boolean;
+    onNow?: null | (() => void) | false;
+    onOk?: null | (() => void) | false;
+    okDisabled?: boolean;
+    locale: Locale;
+}
+export default function getRanges({ prefixCls, rangeList, components, needConfirmButton, onNow, onOk, okDisabled, locale, }: RangesProps): JSX.Element;

web/node_modules/rc-picker/es/utils/getRanges.js

@@ -0,0 +1,61 @@
+import * as React from 'react';
+export default function getRanges(_ref) {
+  var prefixCls = _ref.prefixCls,
+      _ref$rangeList = _ref.rangeList,
+      rangeList = _ref$rangeList === void 0 ? [] : _ref$rangeList,
+      _ref$components = _ref.components,
+      components = _ref$components === void 0 ? {} : _ref$components,
+      needConfirmButton = _ref.needConfirmButton,
+      onNow = _ref.onNow,
+      onOk = _ref.onOk,
+      okDisabled = _ref.okDisabled,
+      locale = _ref.locale;
+  var presetNode;
+  var okNode;
+
+  if (rangeList.length) {
+    var Item = components.rangeItem || 'span';
+    presetNode = React.createElement(React.Fragment, null, rangeList.map(function (_ref2) {
+      var label = _ref2.label,
+          onClick = _ref2.onClick,
+          onMouseEnter = _ref2.onMouseEnter,
+          onMouseLeave = _ref2.onMouseLeave;
+      return React.createElement("li", {
+        key: label,
+        className: "".concat(prefixCls, "-preset")
+      }, React.createElement(Item, {
+        onClick: onClick,
+        onMouseEnter: onMouseEnter,
+        onMouseLeave: onMouseLeave
+      }, label));
+    }));
+  }
+
+  if (needConfirmButton) {
+    var Button = components.button || 'button';
+
+    if (onNow && !presetNode) {
+      presetNode = React.createElement("li", {
+        className: "".concat(prefixCls, "-now")
+      }, React.createElement("a", {
+        className: "".concat(prefixCls, "-now-btn"),
+        onClick: onNow
+      }, locale.now));
+    }
+
+    okNode = needConfirmButton && React.createElement("li", {
+      className: "".concat(prefixCls, "-ok")
+    }, React.createElement(Button, {
+      disabled: okDisabled,
+      onClick: onOk
+    }, locale.ok));
+  }
+
+  if (!presetNode && !okNode) {
+    return null;
+  }
+
+  return React.createElement("ul", {
+    className: "".concat(prefixCls, "-ranges")
+  }, presetNode, okNode);
+}

web/node_modules/rc-picker/es/utils/miscUtil.d.ts

@@ -0,0 +1,8 @@
+export declare function leftPad(str: string | number, length: number, fill?: string): string;
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare function toArray<T>(val: T | T[]): T[];
+export default function getDataOrAriaProps(props: any): any;
+export declare function getValue<T>(values: null | undefined | (T | null)[], index: number): T | null;
+declare type UpdateValue<T> = (prev: T) => T;
+export declare function updateValues<T, R = [T | null, T | null] | null>(values: [T | null, T | null] | null, value: T | UpdateValue<T>, index: number): R;
+export {};

web/node_modules/rc-picker/es/utils/miscUtil.js

@@ -0,0 +1,46 @@
+export function leftPad(str, length) {
+  var fill = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '0';
+  var current = String(str);
+
+  while (current.length < length) {
+    current = "".concat(fill).concat(str);
+  }
+
+  return current;
+}
+export var tuple = function tuple() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  return args;
+};
+export function toArray(val) {
+  if (val === null || val === undefined) {
+    return [];
+  }
+
+  return Array.isArray(val) ? val : [val];
+}
+export default function getDataOrAriaProps(props) {
+  var retProps = {};
+  Object.keys(props).forEach(function (key) {
+    if ((key.substr(0, 5) === 'data-' || key.substr(0, 5) === 'aria-' || key === 'role' || key === 'name') && key.substr(0, 7) !== 'data-__') {
+      retProps[key] = props[key];
+    }
+  });
+  return retProps;
+}
+export function getValue(values, index) {
+  return values ? values[index] : null;
+}
+export function updateValues(values, value, index) {
+  var newValues = [getValue(values, 0), getValue(values, 1)];
+  newValues[index] = typeof value === 'function' ? value(newValues[index]) : value;
+
+  if (!newValues[0] && !newValues[1]) {
+    return null;
+  }
+
+  return newValues;
+}

web/node_modules/rc-picker/es/utils/uiUtil.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { PanelMode, PickerMode } from '../interface';
+export declare function scrollTo(element: HTMLElement, to: number, duration: number): void;
+export interface KeyboardConfig {
+    onLeftRight?: ((diff: number) => void) | null;
+    onCtrlLeftRight?: ((diff: number) => void) | null;
+    onUpDown?: ((diff: number) => void) | null;
+    onPageUpDown?: ((diff: number) => void) | null;
+    onEnter?: (() => void) | null;
+}
+export declare function createKeyDownHandler(event: React.KeyboardEvent<HTMLElement>, { onLeftRight, onCtrlLeftRight, onUpDown, onPageUpDown, onEnter }: KeyboardConfig): boolean;
+export declare function getDefaultFormat(format: string | string[] | undefined, picker: PickerMode | undefined, showTime: boolean | object | undefined, use12Hours: boolean | undefined): string | string[];
+export declare function getInputSize(picker: PickerMode | undefined, format: string): number;
+declare type ClickEventHandler = (event: MouseEvent) => void;
+export declare function addGlobalMouseDownEvent(callback: ClickEventHandler): () => void;
+export declare const PickerModeMap: Record<PickerMode, ((next: PanelMode) => PanelMode) | null>;
+export declare function elementsContains(elements: (HTMLElement | undefined | null)[], target: HTMLElement): boolean;
+export {};

web/node_modules/rc-picker/es/utils/uiUtil.js

@@ -0,0 +1,240 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import KeyCode from "rc-util/es/KeyCode";
+var scrollIds = new Map();
+/* eslint-disable no-param-reassign */
+
+export function scrollTo(element, to, duration) {
+  if (scrollIds.get(element)) {
+    cancelAnimationFrame(scrollIds.get(element));
+  } // jump to target if duration zero
+
+
+  if (duration <= 0) {
+    scrollIds.set(element, requestAnimationFrame(function () {
+      element.scrollTop = to;
+    }));
+    return;
+  }
+
+  var difference = to - element.scrollTop;
+  var perTick = difference / duration * 10;
+  scrollIds.set(element, requestAnimationFrame(function () {
+    element.scrollTop += perTick;
+
+    if (element.scrollTop !== to) {
+      scrollTo(element, to, duration - 10);
+    }
+  }));
+}
+export function createKeyDownHandler(event, _ref) {
+  var onLeftRight = _ref.onLeftRight,
+      onCtrlLeftRight = _ref.onCtrlLeftRight,
+      onUpDown = _ref.onUpDown,
+      onPageUpDown = _ref.onPageUpDown,
+      onEnter = _ref.onEnter;
+  var which = event.which,
+      ctrlKey = event.ctrlKey,
+      metaKey = event.metaKey;
+
+  switch (which) {
+    case KeyCode.LEFT:
+      if (ctrlKey || metaKey) {
+        if (onCtrlLeftRight) {
+          onCtrlLeftRight(-1);
+          return true;
+        }
+      } else if (onLeftRight) {
+        onLeftRight(-1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.RIGHT:
+      if (ctrlKey || metaKey) {
+        if (onCtrlLeftRight) {
+          onCtrlLeftRight(1);
+          return true;
+        }
+      } else if (onLeftRight) {
+        onLeftRight(1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.UP:
+      if (onUpDown) {
+        onUpDown(-1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.DOWN:
+      if (onUpDown) {
+        onUpDown(1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.PAGE_UP:
+      if (onPageUpDown) {
+        onPageUpDown(-1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.PAGE_DOWN:
+      if (onPageUpDown) {
+        onPageUpDown(1);
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+
+    case KeyCode.ENTER:
+      if (onEnter) {
+        onEnter();
+        return true;
+      }
+      /* istanbul ignore next */
+
+
+      break;
+  }
+
+  return false;
+} // ===================== Format =====================
+
+export function getDefaultFormat(format, picker, showTime, use12Hours) {
+  var mergedFormat = format;
+
+  if (!mergedFormat) {
+    switch (picker) {
+      case 'time':
+        mergedFormat = use12Hours ? 'hh:mm:ss a' : 'HH:mm:ss';
+        break;
+
+      case 'week':
+        mergedFormat = 'gggg-wo';
+        break;
+
+      case 'month':
+        mergedFormat = 'YYYY-MM';
+        break;
+
+      case 'quarter':
+        mergedFormat = 'YYYY-[Q]Q';
+        break;
+
+      case 'year':
+        mergedFormat = 'YYYY';
+        break;
+
+      default:
+        mergedFormat = showTime ? 'YYYY-MM-DD HH:mm:ss' : 'YYYY-MM-DD';
+    }
+  }
+
+  return mergedFormat;
+}
+export function getInputSize(picker, format) {
+  var defaultSize = picker === 'time' ? 8 : 10;
+  return Math.max(defaultSize, format.length) + 2;
+}
+var globalClickFunc = null;
+var clickCallbacks = new Set();
+export function addGlobalMouseDownEvent(callback) {
+  if (!globalClickFunc && typeof window !== 'undefined' && window.addEventListener) {
+    globalClickFunc = function globalClickFunc(e) {
+      // Clone a new list to avoid repeat trigger events
+      _toConsumableArray(clickCallbacks).forEach(function (queueFunc) {
+        queueFunc(e);
+      });
+    };
+
+    window.addEventListener('mousedown', globalClickFunc);
+  }
+
+  clickCallbacks.add(callback);
+  return function () {
+    clickCallbacks.delete(callback);
+
+    if (clickCallbacks.size === 0) {
+      window.removeEventListener('mousedown', globalClickFunc);
+      globalClickFunc = null;
+    }
+  };
+} // ====================== Mode ======================
+
+var getYearNextMode = function getYearNextMode(next) {
+  if (next === 'month' || next === 'date') {
+    return 'year';
+  }
+
+  return next;
+};
+
+var getMonthNextMode = function getMonthNextMode(next) {
+  if (next === 'date') {
+    return 'month';
+  }
+
+  return next;
+};
+
+var getQuarterNextMode = function getQuarterNextMode(next) {
+  if (next === 'month' || next === 'date') {
+    return 'quarter';
+  }
+
+  return next;
+};
+
+var getWeekNextMode = function getWeekNextMode(next) {
+  if (next === 'date') {
+    return 'week';
+  }
+
+  return next;
+};
+
+export var PickerModeMap = {
+  year: getYearNextMode,
+  month: getMonthNextMode,
+  quarter: getQuarterNextMode,
+  week: getWeekNextMode,
+  time: null,
+  date: null
+};
+export function elementsContains(elements, target) {
+  return elements.some(function (ele) {
+    return ele && ele.contains(target);
+  });
+}