@jetbrains/ring-ui-built 7.0.106 → 7.0.108

package/components/date-picker/use-scroll-behavior.js

@@ -0,0 +1,223 @@
+import { c } from 'react-compiler-runtime';
+import { useState, useRef, useEffect, useLayoutEffect } from 'react';
+import units, { isSafariOnIPhone, scrollerReRenderDelayIPhone } from './consts.js';
+import useEventCallback from '../global/use-event-callback.js';
+import 'date-fns/add';
+import '../global/sniffer.js';
+import 'sniffr';
+
+function useScrollBehavior(scrollDate, onContainerScroll, locale, selfScrollDateSource, arith, scheduleScroll) {
+  const $ = c(39);
+  if ($[0] !== "5ce72fbec5594f0e31b7b5703cf53349d817d9722b565bfa743aaa359a97033d") {
+    for (let $i = 0; $i < 39; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "5ce72fbec5594f0e31b7b5703cf53349d817d9722b565bfa743aaa359a97033d";
+  }
+  let t0;
+  if ($[1] !== arith || $[2] !== scrollDate.date) {
+    t0 = () => arith.getItems(scrollDate.date);
+    $[1] = arith;
+    $[2] = scrollDate.date;
+    $[3] = t0;
+  } else {
+    t0 = $[3];
+  }
+  const [items, setItems] = useState(t0);
+  let t1;
+  if ($[4] !== arith || $[5] !== items || $[6] !== locale || $[7] !== scrollDate.date) {
+    t1 = () => arith.getScrollTop(items, scrollDate.date, locale);
+    $[4] = arith;
+    $[5] = items;
+    $[6] = locale;
+    $[7] = scrollDate.date;
+    $[8] = t1;
+  } else {
+    t1 = $[8];
+  }
+  const [scrollTop, setScrollTop] = useState(t1);
+  const containerRef = useRef(null);
+  let t2;
+  if ($[9] !== arith || $[10] !== items || $[11] !== locale) {
+    t2 = newScrollDate => {
+      const newScrollTopOnExistingItems = arith.getScrollTop(items, newScrollDate, locale);
+      if (isNearEdge(newScrollTopOnExistingItems, containerRef.current)) {
+        const {
+          newItems,
+          newScrollTop
+        } = arith.getItemsAndScrollTop(newScrollDate, locale);
+        setItems(newItems);
+        setScrollTop(newScrollTop);
+      } else {
+        setScrollTop(newScrollTopOnExistingItems);
+      }
+    };
+    $[9] = arith;
+    $[10] = items;
+    $[11] = locale;
+    $[12] = t2;
+  } else {
+    t2 = $[12];
+  }
+  const syncSelfState = useEventCallback(t2);
+  const didMountRef = useRef(false);
+  let t3;
+  if ($[13] !== scrollDate.date || $[14] !== scrollDate.source || $[15] !== selfScrollDateSource || $[16] !== syncSelfState) {
+    t3 = function onExternalScrollDateChange() {
+      if (!didMountRef.current) {
+        didMountRef.current = true;
+        return;
+      }
+      const container = containerRef.current;
+      if (!container) {
+        return;
+      }
+      if (scrollDate.source === selfScrollDateSource) {
+        return;
+      }
+      syncSelfState(scrollDate.date);
+    };
+    $[13] = scrollDate.date;
+    $[14] = scrollDate.source;
+    $[15] = selfScrollDateSource;
+    $[16] = syncSelfState;
+    $[17] = t3;
+  } else {
+    t3 = $[17];
+  }
+  let t4;
+  if ($[18] !== scrollDate || $[19] !== selfScrollDateSource || $[20] !== syncSelfState) {
+    t4 = [scrollDate, selfScrollDateSource, syncSelfState];
+    $[18] = scrollDate;
+    $[19] = selfScrollDateSource;
+    $[20] = syncSelfState;
+    $[21] = t4;
+  } else {
+    t4 = $[21];
+  }
+  useEffect(t3, t4);
+  const ignoreNextScrollEventRef = useRef(true);
+  let t5;
+  if ($[22] !== scrollTop) {
+    t5 = function setContainerScrollFromState() {
+      const container_0 = containerRef.current;
+      if (!container_0) {
+        return;
+      }
+      ignoreNextScrollEventRef.current = true;
+      container_0.scrollTop = scrollTop;
+    };
+    $[22] = scrollTop;
+    $[23] = t5;
+  } else {
+    t5 = $[23];
+  }
+  let t6;
+  if ($[24] !== items || $[25] !== scrollTop) {
+    t6 = [items, scrollTop];
+    $[24] = items;
+    $[25] = scrollTop;
+    $[26] = t6;
+  } else {
+    t6 = $[26];
+  }
+  useLayoutEffect(t5, t6);
+  const updateStateTimerRef = useRef(null);
+  let t7;
+  if ($[27] !== arith || $[28] !== items || $[29] !== locale || $[30] !== onContainerScroll || $[31] !== scheduleScroll || $[32] !== selfScrollDateSource) {
+    t7 = () => {
+      scheduleScroll(() => {
+        if (updateStateTimerRef.current != null) {
+          window.clearTimeout(updateStateTimerRef.current);
+          updateStateTimerRef.current = null;
+        }
+        const container_1 = containerRef.current;
+        if (!container_1) {
+          return;
+        }
+        if (ignoreNextScrollEventRef.current) {
+          ignoreNextScrollEventRef.current = false;
+          return;
+        }
+        const currentScrollTop = container_1.scrollTop;
+        const newScrollDate_0 = arith.getScrollDate(items, currentScrollTop, locale);
+        onContainerScroll({
+          date: newScrollDate_0,
+          source: selfScrollDateSource
+        });
+        if (isNearEdge(currentScrollTop, container_1)) {
+          const updateState = function updateState() {
+            const {
+              newItems: newItems_0,
+              newScrollTop: newScrollTop_0
+            } = arith.getItemsAndScrollTop(newScrollDate_0, locale);
+            setItems(newItems_0);
+            setScrollTop(newScrollTop_0);
+            updateStateTimerRef.current = null;
+          };
+          if (isSafariOnIPhone) {
+            updateStateTimerRef.current = window.setTimeout(updateState, scrollerReRenderDelayIPhone);
+          } else {
+            updateState();
+          }
+        }
+      });
+    };
+    $[27] = arith;
+    $[28] = items;
+    $[29] = locale;
+    $[30] = onContainerScroll;
+    $[31] = scheduleScroll;
+    $[32] = selfScrollDateSource;
+    $[33] = t7;
+  } else {
+    t7 = $[33];
+  }
+  const handleScroll = useEventCallback(t7);
+  let t8;
+  let t9;
+  if ($[34] !== handleScroll) {
+    t8 = () => {
+      const container_2 = containerRef.current;
+      if (!container_2) {
+        return;
+      }
+      container_2.addEventListener("scroll", handleScroll);
+      return () => {
+        container_2.removeEventListener("scroll", handleScroll);
+        if (updateStateTimerRef.current != null) {
+          window.clearTimeout(updateStateTimerRef.current);
+          updateStateTimerRef.current = null;
+        }
+      };
+    };
+    t9 = [handleScroll];
+    $[34] = handleScroll;
+    $[35] = t8;
+    $[36] = t9;
+  } else {
+    t8 = $[35];
+    t9 = $[36];
+  }
+  useEffect(t8, t9);
+  let t10;
+  if ($[37] !== items) {
+    t10 = {
+      containerRef,
+      items
+    };
+    $[37] = items;
+    $[38] = t10;
+  } else {
+    t10 = $[38];
+  }
+  return t10;
+}
+function isNearEdge(scrollTop, container) {
+  const scrollHeight = container.scrollHeight;
+  // eslint-disable-next-line no-magic-numbers
+  const scrollDistanceNearEdge = isSafariOnIPhone ? 5 : units.calHeight * 2;
+  return scrollTop <= scrollDistanceNearEdge || scrollHeight - units.calHeight - scrollTop <= scrollDistanceNearEdge;
+}
+
+export { useScrollBehavior };

package/components/date-picker/weekdays.js

@@ -1,3 +1,4 @@
+import 'core-js/modules/es.array.includes.js';
 import { c } from 'react-compiler-runtime';
 import classNames from 'classnames';
 import { getDay } from 'date-fns/getDay';
@@ -8,6 +9,8 @@ import { shiftWeekArray, getWeekStartsOn, weekdays } from './consts.js';
 import { s as styles } from '../_helpers/date-picker.js';
 import { jsx } from 'react/jsx-runtime';
 import 'date-fns/add';
+import '../global/sniffer.js';
+import 'sniffr';
 
 function Weekdays(props) {
   const $ = c(9);

package/components/date-picker/years.d.ts

@@ -1,19 +1,2 @@
-import { PureComponent } from 'react';
 import { type CalendarProps } from './consts';
-interface YearsState {
-    scrollDate: Date | null;
-}
-export default class Years extends PureComponent<CalendarProps> {
-    state: {
-        scrollDate: null;
-    };
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: CalendarProps, prevState: YearsState): void;
-    componentWillUnmount(): void;
-    stoppedScrolling?: boolean;
-    setYear(date: number): void;
-    componentRef: import("react").RefObject<HTMLDivElement | null>;
-    handleWheel: (e: WheelEvent) => void;
-    render(): import("react").JSX.Element;
-}
-export {};
+export default function Years({ scrollDate, setScrollDate }: CalendarProps): import("react").JSX.Element;

package/components/date-picker/years.js

@@ -1,4 +1,5 @@
-import { PureComponent, createRef } from 'react';
+import { c } from 'react-compiler-runtime';
+import { useState, useRef, useEffect } from 'react';
 import classNames from 'classnames';
 import { addYears } from 'date-fns/addYears';
 import { getYear } from 'date-fns/getYear';
@@ -7,98 +8,278 @@ import { isSameYear } from 'date-fns/isSameYear';
 import { isThisYear } from 'date-fns/isThisYear';
 import { setYear } from 'date-fns/setYear';
 import { startOfYear } from 'date-fns/startOfYear';
-import { subYears } from 'date-fns/subYears';
-import linearFunction from '../global/linear-function.js';
-import units, { yearDuration, DOUBLE, HALF } from './consts.js';
+import units, { yearsAnimationDuration, calendarSyncOnYearScrollUpdateDelay } from './consts.js';
+import { ScrollArith } from './scroll-arith.js';
+import { useScrollBehavior } from './use-scroll-behavior.js';
+import { animateDate } from './animate-date.js';
+import scheduleRAF from '../global/schedule-raf.js';
+import { useIntersectionObserver, useVisibility } from './use-intersection-observer.js';
 import { s as styles } from '../_helpers/date-picker.js';
 import { jsx } from 'react/jsx-runtime';
 import 'date-fns/add';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../global/use-event-callback.js';
 
 const {
-  yearHeight,
-  calHeight
+  yearHeight
 } = units;
-let scrollTO;
-const YEARSBACK = 5;
-const scrollDelay = 100;
-class Years extends PureComponent {
-  state = {
-    scrollDate: null
-  };
-  componentDidMount() {
-    if (this.componentRef.current) {
-      this.componentRef.current.addEventListener('wheel', this.handleWheel);
+const scrollArith = new ScrollArith({
+  itemsAround: 100,
+  floorToItem: startOfYear,
+  shiftItems: addYears,
+  getItemHeight: () => yearHeight
+});
+const scheduleScroll = scheduleRAF();
+/**
+ * Reduces "empty" years during fast scrolling.
+ */
+const intersectionObserverScrollMargin = units.calHeight / 2;
+function Years(t0) {
+  const $ = c(24);
+  if ($[0] !== "aa5edf1b8146bb2f5048c50f376e591fc6fc5fcb5e70e35dc076528241c541c9") {
+    for (let $i = 0; $i < 24; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
     }
+    $[0] = "aa5edf1b8146bb2f5048c50f376e591fc6fc5fcb5e70e35dc076528241c541c9";
   }
-  componentDidUpdate(prevProps, prevState) {
-    this.stoppedScrolling = !!prevState.scrollDate && !this.state.scrollDate;
+  const {
+    scrollDate,
+    setScrollDate
+  } = t0;
+  const [localScrollDate, setLocalScrollDate] = useState(scrollDate);
+  const syncCleanupRef = useRef(null);
+  const animationCleanupRef = useRef(null);
+  let t1;
+  if ($[1] !== scrollDate.date || $[2] !== setScrollDate) {
+    t1 = newLocalScrollDate => {
+      syncCleanupRef.current?.();
+      animationCleanupRef.current?.();
+      let timerId = window.setTimeout(() => {
+        const newScrollDateWithPreservedMonthAndDay = setYear(scrollDate.date, getYear(newLocalScrollDate.date));
+        setScrollDate({
+          date: newScrollDateWithPreservedMonthAndDay,
+          source: "yearsScroll"
+        });
+        animationCleanupRef.current = animateDate(newLocalScrollDate.date, newScrollDateWithPreservedMonthAndDay, date => {
+          setLocalScrollDate({
+            date,
+            source: "other"
+          });
+        }, yearsAnimationDuration);
+      }, calendarSyncOnYearScrollUpdateDelay);
+      syncCleanupRef.current = () => {
+        if (timerId != null) {
+          window.clearTimeout(timerId);
+          timerId = null;
+        }
+      };
+    };
+    $[1] = scrollDate.date;
+    $[2] = setScrollDate;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
   }
-  componentWillUnmount() {
-    if (this.componentRef.current) {
-      this.componentRef.current.removeEventListener('wheel', this.handleWheel);
-    }
+  const syncCalendarScrollDate = t1;
+  let t2;
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = () => function cleanup() {
+      syncCleanupRef.current?.();
+      animationCleanupRef.current?.();
+    };
+    t3 = [];
+    $[4] = t2;
+    $[5] = t3;
+  } else {
+    t2 = $[4];
+    t3 = $[5];
   }
-  stoppedScrolling;
-  setYear(date) {
-    if (scrollTO) {
-      window.clearTimeout(scrollTO);
-      scrollTO = null;
-    }
-    this.setState({
-      scrollDate: null
-    });
-    this.props.onScroll(Number(setYear(this.props.scrollDate, getYear(date))));
+  useEffect(t2, t3);
+  let t4;
+  let t5;
+  if ($[6] !== scrollDate) {
+    t4 = function syncLocalScrollDate() {
+      if (scrollDate.source === "yearsScroll") {
+        return;
+      }
+      let timerId_0 = window.setTimeout(() => {
+        setLocalScrollDate(scrollDate);
+        timerId_0 = null;
+      });
+      return () => {
+        if (timerId_0 != null) {
+          window.clearTimeout(timerId_0);
+          timerId_0 = null;
+        }
+      };
+    };
+    t5 = [scrollDate, setLocalScrollDate];
+    $[6] = scrollDate;
+    $[7] = t4;
+    $[8] = t5;
+  } else {
+    t4 = $[7];
+    t5 = $[8];
   }
-  componentRef = /*#__PURE__*/createRef();
-  handleWheel = e => {
-    const {
-      scrollDate
-    } = this.props;
-    const date = this.state.scrollDate || scrollDate;
-    e.preventDefault();
-    const newScrollDate = linearFunction(0, Number(date), yearDuration / yearHeight).y(e.deltaY);
-    this.setState({
-      scrollDate: newScrollDate
-    });
-    if (scrollTO) {
-      window.clearTimeout(scrollTO);
-    }
-    scrollTO = window.setTimeout(() => this.setYear(newScrollDate), scrollDelay);
-  };
-  render() {
-    const {
-      onScrollChange,
-      scrollDate
-    } = this.props;
-    const date = this.state.scrollDate || scrollDate;
-    const yearStart = startOfYear(date);
-    let year = subYears(yearStart, YEARSBACK);
-    const years = [year];
-    for (let i = 0; i < YEARSBACK * DOUBLE; i++) {
-      year = addYears(year, 1);
-      years.push(year);
+  useEffect(t4, t5);
+  let t6;
+  if ($[9] !== localScrollDate.date || $[10] !== setScrollDate) {
+    t6 = year => {
+      const newScrollDate = setYear(localScrollDate.date, getYear(year));
+      setScrollDate({
+        date: newScrollDate,
+        source: "yearsScroll"
+      });
+      syncCleanupRef.current?.();
+      animationCleanupRef.current?.();
+      animationCleanupRef.current = animateDate(localScrollDate.date, newScrollDate, date_0 => {
+        setLocalScrollDate({
+          date: date_0,
+          source: "other"
+        });
+      }, yearsAnimationDuration);
+    };
+    $[9] = localScrollDate.date;
+    $[10] = setScrollDate;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  const handleYearClick = t6;
+  const {
+    containerRef,
+    items
+  } = useScrollBehavior(localScrollDate, syncCalendarScrollDate, undefined, "yearsScroll", scrollArith, scheduleScroll);
+  const intersectionObserverHandle = useIntersectionObserver(containerRef, intersectionObserverScrollMargin);
+  let t7;
+  if ($[12] !== handleYearClick || $[13] !== intersectionObserverHandle || $[14] !== items || $[15] !== localScrollDate.date) {
+    let t8;
+    if ($[17] !== handleYearClick || $[18] !== intersectionObserverHandle || $[19] !== localScrollDate.date) {
+      t8 = year_0 => /*#__PURE__*/jsx(Year, {
+        year: year_0,
+        scrollDate: localScrollDate.date,
+        handleYearClick: handleYearClick,
+        intersectionObserverHandle: intersectionObserverHandle
+      }, +year_0);
+      $[17] = handleYearClick;
+      $[18] = intersectionObserverHandle;
+      $[19] = localScrollDate.date;
+      $[20] = t8;
+    } else {
+      t8 = $[20];
     }
-    const pxToDate = linearFunction(0, Number(years[0]), yearDuration / yearHeight);
-    return /*#__PURE__*/jsx("div", {
+    t7 = items.map(t8);
+    $[12] = handleYearClick;
+    $[13] = intersectionObserverHandle;
+    $[14] = items;
+    $[15] = localScrollDate.date;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  let t8;
+  if ($[21] !== containerRef || $[22] !== t7) {
+    t8 = /*#__PURE__*/jsx("div", {
       className: styles.years,
-      ref: this.componentRef,
-      style: {
-        transition: this.stoppedScrolling ? 'top .2s ease-out 0s' : 'none',
-        top: Math.floor(calHeight * HALF - pxToDate.x(Number(date)))
-      },
-      children: years.map(item => /*#__PURE__*/jsx("button", {
-        type: "button",
-        className: classNames(styles.year, {
-          [styles.currentYear]: isSameYear(item, date),
-          [styles.today]: isThisYear(item)
-        }),
-        onClick: function handleClick() {
-          onScrollChange(Number(setYear(scrollDate, getYear(item))));
-        },
-        children: format(item, 'yyyy')
-      }, +item))
+      ref: containerRef,
+      "data-test": "ring-date-popup--years",
+      children: t7
     });
+    $[21] = containerRef;
+    $[22] = t7;
+    $[23] = t8;
+  } else {
+    t8 = $[23];
+  }
+  return t8;
+}
+function Year(t0) {
+  const $ = c(24);
+  if ($[0] !== "aa5edf1b8146bb2f5048c50f376e591fc6fc5fcb5e70e35dc076528241c541c9") {
+    for (let $i = 0; $i < 24; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "aa5edf1b8146bb2f5048c50f376e591fc6fc5fcb5e70e35dc076528241c541c9";
+  }
+  const {
+    year,
+    scrollDate,
+    handleYearClick,
+    intersectionObserverHandle
+  } = t0;
+  const buttonRef = useRef(null);
+  const visible = useVisibility(intersectionObserverHandle, buttonRef);
+  const t1 = +year;
+  const t2 = !visible;
+  let t3;
+  if ($[1] !== scrollDate || $[2] !== visible || $[3] !== year) {
+    t3 = visible && isSameYear(year, scrollDate) && styles.currentYear;
+    $[1] = scrollDate;
+    $[2] = visible;
+    $[3] = year;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== visible || $[6] !== year) {
+    t4 = visible && isThisYear(year) && styles.today;
+    $[5] = visible;
+    $[6] = year;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] !== t3 || $[9] !== t4) {
+    t5 = classNames(styles.year, t3, t4);
+    $[8] = t3;
+    $[9] = t4;
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  let t6;
+  if ($[11] !== handleYearClick || $[12] !== visible || $[13] !== year) {
+    t6 = visible ? () => handleYearClick(year) : undefined;
+    $[11] = handleYearClick;
+    $[12] = visible;
+    $[13] = year;
+    $[14] = t6;
+  } else {
+    t6 = $[14];
+  }
+  let t7;
+  if ($[15] !== visible || $[16] !== year) {
+    t7 = visible ? format(year, "yyyy") : "\xA0";
+    $[15] = visible;
+    $[16] = year;
+    $[17] = t7;
+  } else {
+    t7 = $[17];
+  }
+  let t8;
+  if ($[18] !== t1 || $[19] !== t2 || $[20] !== t5 || $[21] !== t6 || $[22] !== t7) {
+    t8 = /*#__PURE__*/jsx("button", {
+      type: "button",
+      ref: buttonRef,
+      disabled: t2,
+      className: t5,
+      onClick: t6,
+      children: t7
+    }, t1);
+    $[18] = t1;
+    $[19] = t2;
+    $[20] = t5;
+    $[21] = t6;
+    $[22] = t7;
+    $[23] = t8;
+  } else {
+    t8 = $[23];
   }
+  return t8;
 }
 
 export { Years as default };

package/components/dialog/dialog.js

@@ -21,6 +21,7 @@ import '../island/content.js';
 import 'element-resize-detector';
 import '../global/schedule-raf.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';

package/components/dropdown-menu/dropdown-menu.js

@@ -7,6 +7,7 @@ import getUID from '../global/get-uid.js';
 import { A as Anchor } from '../_helpers/anchor.js';
 import { isArray } from '../global/typescript-utils.js';
 import { jsx } from 'react/jsx-runtime';
+import 'core-js/modules/es.array.includes.js';
 import 'classnames';
 import 'react-virtualized/dist/es/List';
 import 'react-virtualized/dist/es/AutoSizer';

package/components/editable-heading/editable-heading.js

@@ -29,6 +29,7 @@ import 'memoize-one';
 import '../control-label/control-label.js';
 import '../control-help/control-help.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';

package/components/error-bubble/error-bubble.js

@@ -9,6 +9,7 @@ import '../global/schedule-raf.js';
 import '../global/dom.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';

package/components/footer/footer.d.ts

@@ -24,5 +24,5 @@ export interface FooterProps {
     center?: FooterItems | null | undefined;
     right?: FooterItems | null | undefined;
 }
-declare const Footer: import("react").NamedExoticComponent<FooterProps>;
+declare const Footer: import("react").MemoExoticComponent<({ floating, className, left, center, right }: FooterProps) => import("react").JSX.Element>;
 export default Footer;

package/components/global/dom.d.ts

@@ -3,7 +3,7 @@
  */
 import { type SyntheticEvent } from 'react';
 import type { PropertiesHyphen } from 'csstype';
-export declare const getStyles: ((elt: Element, pseudoElt?: string | null) => CSSStyleDeclaration) & typeof getComputedStyle;
+export declare const getStyles: typeof window.getComputedStyle;
 export declare function isMounted(node: Node | Range | null | undefined): boolean;
 export interface Rect {
     top: number;

package/components/global/dom.js

@@ -1,7 +1,7 @@
 /**
  * @name DOM
  */
-const getStyles = window.getComputedStyle.bind(window);
+const getStyles = (...args) => window.getComputedStyle(...args);
 function isMounted(node) {
   if (node === document) {
     return true;