@rio-cloud/rio-uikit 0.16.3 → 0.16.4-beta.2

package/hooks/useClipboard.js

@@ -1,51 +1,30 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 // Inspired from https://github.com/mantinedev/mantine/blob/master/src/mantine-hooks/src/use-clipboard/use-clipboard.ts
-
 import { useState } from 'react';
 import isNil from 'lodash/fp/isNil';
-export default function useClipboard() {
-  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-    _ref$timeout = _ref.timeout,
-    timeout = _ref$timeout === void 0 ? 2000 : _ref$timeout;
-  var _useState = useState(null),
-    _useState2 = _slicedToArray(_useState, 2),
-    error = _useState2[0],
-    setError = _useState2[1];
-  var _useState3 = useState(false),
-    _useState4 = _slicedToArray(_useState3, 2),
-    copied = _useState4[0],
-    setCopied = _useState4[1];
-  var _useState5 = useState(null),
-    _useState6 = _slicedToArray(_useState5, 2),
-    copyTimeout = _useState6[0],
-    setCopyTimeout = _useState6[1];
-  var handleCopyResult = function handleCopyResult(value) {
-    clearTimeout(copyTimeout);
-    setCopyTimeout(setTimeout(function () {
-      return setCopied(false);
-    }, timeout));
-    setCopied(value);
-  };
-  var copy = function copy(valueToCopy) {
-    if (!isNil(navigator.clipboard)) {
-      navigator.clipboard.writeText(valueToCopy).then(function () {
-        return handleCopyResult(true);
-      })["catch"](function (error) {
-        return setError(error);
-      });
-    } else {
-      setError(new Error('useClipboard: navigator.clipboard is not supported'));
-    }
-  };
-  var reset = function reset() {
-    setCopied(false);
-    setError(null);
-    clearTimeout(copyTimeout);
-  };
-  return {
-    copy: copy,
-    reset: reset,
-    error: error,
-    copied: copied
-  };
-}
+export default function useClipboard({ timeout = 2000 } = {}) {
+    const [error, setError] = useState(null);
+    const [copied, setCopied] = useState(false);
+    const [copyTimeout, setCopyTimeout] = useState(null);
+    const handleCopyResult = value => {
+        clearTimeout(copyTimeout);
+        setCopyTimeout(setTimeout(() => setCopied(false), timeout));
+        setCopied(value);
+    };
+    const copy = valueToCopy => {
+        if (!isNil(navigator.clipboard)) {
+            navigator.clipboard
+                .writeText(valueToCopy)
+                .then(() => handleCopyResult(true))
+                .catch(error => setError(error));
+        }
+        else {
+            setError(new Error('useClipboard: navigator.clipboard is not supported'));
+        }
+    };
+    const reset = () => {
+        setCopied(false);
+        setError(null);
+        clearTimeout(copyTimeout);
+    };
+    return { copy, reset, error, copied };
+}

package/hooks/useDarkMode.d.ts

@@ -0,0 +1,2 @@
+export default useDarkMode;
+declare function useDarkMode(): boolean;

package/hooks/useDarkMode.js

@@ -1,30 +1,25 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { useCallback, useEffect, useState } from 'react';
 import { THEME_DARK, THEME_DATA_ATTRIBUTE } from './../utils/colorScheme';
 import useMutationObserver from './useMutationObserver';
-var useDarkMode = function useDarkMode() {
-  var _useState = useState(false),
-    _useState2 = _slicedToArray(_useState, 2),
-    isDarkMode = _useState2[0],
-    setIsDarkMode = _useState2[1];
-  var handleMutation = useCallback(function (mutationList) {
-    mutationList.map(function (mutation) {
-      if (mutation.type === 'attributes' && mutation.attributeName === THEME_DATA_ATTRIBUTE) {
-        var _mutation$target$attr;
-        var scheme = (_mutation$target$attr = mutation.target.attributes[THEME_DATA_ATTRIBUTE]) === null || _mutation$target$attr === void 0 ? void 0 : _mutation$target$attr.value;
-        setIsDarkMode(scheme === THEME_DARK);
-      }
-
-      // if (mutation.type === 'classList') {
-      //     console.log({ classList: mutation });
-      // }
+const useDarkMode = () => {
+    const [isDarkMode, setIsDarkMode] = useState(false);
+    const handleMutation = useCallback(mutationList => {
+        mutationList.map(mutation => {
+            var _a;
+            if (mutation.type === 'attributes' && mutation.attributeName === THEME_DATA_ATTRIBUTE) {
+                const scheme = (_a = mutation.target.attributes[THEME_DATA_ATTRIBUTE]) === null || _a === void 0 ? void 0 : _a.value;
+                setIsDarkMode(scheme === THEME_DARK);
+            }
+            // if (mutation.type === 'classList') {
+            //     console.log({ classList: mutation });
+            // }
+        });
+    }, []);
+    useMutationObserver(document.documentElement, handleMutation, {
+        attributes: true,
+        childList: false,
+        subtree: false,
     });
-  }, []);
-  useMutationObserver(document.documentElement, handleMutation, {
-    attributes: true,
-    childList: false,
-    subtree: false
-  });
-  return isDarkMode;
+    return isDarkMode;
 };
-export default useDarkMode;
+export default useDarkMode;

package/hooks/useDebugInfo.d.ts

@@ -0,0 +1,6 @@
+export default function useDebugInfo(componentName: any, props: any): {
+    renderCount: number;
+    changedProps: {};
+    timeSinceLastRender: number;
+    lastRenderTimestamp: number;
+};

package/hooks/useDebugInfo.js

@@ -1,39 +1,36 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 // Inspired by https://github.com/WebDevSimplified/useful-custom-react-hooks/blob/main/src/28-useDebugInformation/useDebugInformation.js
 import { useEffect, useRef } from 'react';
 import useRenderCount from './useRenderCount';
-var logStyle = ['color: #4c5667', 'background-color: #e5ebf0', 'padding: 2px 4px', 'border-radius: 2px'].join(';');
+const logStyle = ['color: #4c5667', 'background-color: #e5ebf0', 'padding: 2px 4px', 'border-radius: 2px'].join(';');
 export default function useDebugInfo(componentName, props) {
-  var renderCount = useRenderCount();
-  var changedProps = useRef({});
-  var previousProps = useRef(props);
-  var lastRenderTimestamp = useRef(Date.now());
-  var propKeys = Object.keys(_objectSpread(_objectSpread({}, props), previousProps));
-  changedProps.current = propKeys.reduce(function (obj, key) {
-    if (props[key] === previousProps.current[key]) {
-      return obj;
-    }
-    return _objectSpread(_objectSpread({}, obj), {}, _defineProperty({}, key, {
-      previous: previousProps.current[key],
-      current: props[key]
-    }));
-  }, {});
-  var info = {
-    renderCount: renderCount,
-    changedProps: changedProps.current,
-    timeSinceLastRender: Date.now() - lastRenderTimestamp.current,
-    lastRenderTimestamp: lastRenderTimestamp.current
-  };
-  useEffect(function () {
-    previousProps.current = props;
-    lastRenderTimestamp.current = Date.now();
-    if (console) {
-      console.groupCollapsed("%c[debug-info] ".concat(componentName), logStyle);
-      console.log(info);
-      console.groupEnd();
-    }
-  });
-  return info;
-}
+    const renderCount = useRenderCount();
+    const changedProps = useRef({});
+    const previousProps = useRef(props);
+    const lastRenderTimestamp = useRef(Date.now());
+    const propKeys = Object.keys(Object.assign(Object.assign({}, props), previousProps));
+    changedProps.current = propKeys.reduce((obj, key) => {
+        if (props[key] === previousProps.current[key]) {
+            return obj;
+        }
+        return Object.assign(Object.assign({}, obj), { [key]: {
+                previous: previousProps.current[key],
+                current: props[key],
+            } });
+    }, {});
+    const info = {
+        renderCount,
+        changedProps: changedProps.current,
+        timeSinceLastRender: Date.now() - lastRenderTimestamp.current,
+        lastRenderTimestamp: lastRenderTimestamp.current,
+    };
+    useEffect(() => {
+        previousProps.current = props;
+        lastRenderTimestamp.current = Date.now();
+        if (console) {
+            console.groupCollapsed(`%c[debug-info] ${componentName}`, logStyle);
+            console.log(info);
+            console.groupEnd();
+        }
+    });
+    return info;
+}

package/hooks/useEffectOnce.d.ts

@@ -0,0 +1 @@
+export default function useEffectOnce(callback: any): void;

package/hooks/useEffectOnce.js

@@ -1,4 +1,4 @@
 import { useEffect } from 'react';
 export default function useEffectOnce(callback) {
-  useEffect(callback, []);
-}
+    useEffect(callback, []);
+}

package/hooks/useElementSize.d.ts

@@ -0,0 +1 @@
+export default function useElementSize(elementRef: any): undefined[];

package/hooks/useElementSize.js

@@ -1,39 +1,20 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-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 { useEffect, useState } from 'react';
 export default function useElementSize(elementRef) {
-  var _useState = useState(),
-    _useState2 = _slicedToArray(_useState, 2),
-    width = _useState2[0],
-    setWidth = _useState2[1];
-  var _useState3 = useState(),
-    _useState4 = _slicedToArray(_useState3, 2),
-    height = _useState4[0],
-    setHeight = _useState4[1];
-  useEffect(function () {
-    var resizeObserver = new ResizeObserver(function (entries) {
-      var _iterator = _createForOfIteratorHelper(entries),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var entry = _step.value;
-          if (entry.contentRect) {
-            setWidth(entry.contentRect.width);
-            setHeight(entry.contentRect.height);
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    });
-    resizeObserver.observe(elementRef.current);
-    return function () {
-      resizeObserver.disconnect();
-    };
-  }, [elementRef]);
-  return [width, height];
-}
+    const [width, setWidth] = useState();
+    const [height, setHeight] = useState();
+    useEffect(() => {
+        const resizeObserver = new ResizeObserver(entries => {
+            for (let entry of entries) {
+                if (entry.contentRect) {
+                    setWidth(entry.contentRect.width);
+                    setHeight(entry.contentRect.height);
+                }
+            }
+        });
+        resizeObserver.observe(elementRef.current);
+        return () => {
+            resizeObserver.disconnect();
+        };
+    }, [elementRef]);
+    return [width, height];
+}

package/hooks/useEsc.d.ts

@@ -0,0 +1 @@
+export default function useEsc(callback: any): void;

package/hooks/useEsc.js

@@ -1,6 +1,4 @@
 import useKey from './useKey';
 export default function useEsc(callback) {
-  useKey(function (event) {
-    return event.key === 'Escape' && callback(event);
-  });
-}
+    useKey(event => event.key === 'Escape' && callback(event));
+}

package/hooks/useEvent.d.ts

@@ -0,0 +1 @@
+export default function useEvent(eventType: any, callback: any, options?: boolean, target?: Document): void;

package/hooks/useEvent.js

@@ -1,11 +1,7 @@
 import { useEffect } from 'react';
-export default function useEvent(eventType, callback) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : document;
-  useEffect(function () {
-    target.addEventListener(eventType, callback, options);
-    return function () {
-      return target.removeEventListener(eventType, callback, options);
-    };
-  }, [callback]);
-}
+export default function useEvent(eventType, callback, options = false, target = document) {
+    useEffect(() => {
+        target.addEventListener(eventType, callback, options);
+        return () => target.removeEventListener(eventType, callback, options);
+    }, [callback]);
+}

package/hooks/useFullscreen.d.ts

@@ -0,0 +1,8 @@
+export default useFullscreen;
+declare function useFullscreen(options?: {}): {
+    requestFullscreen: import("lodash/fp").LodashNoop;
+    exitFullscreen: import("lodash/fp").LodashNoop;
+    toggleFullscreen: import("lodash/fp").LodashNoop;
+    isFullscreen: boolean;
+    isEnabled: boolean;
+};

package/hooks/useFullscreen.js

@@ -1,12 +1,8 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 // inspired by https://github.com/imbhargav5/rooks/blob/main/src/hooks/useFullscreen.ts
-
+import { __awaiter } from "tslib";
 import { useState, useCallback } from 'react';
 import noop from 'lodash/fp/noop';
 import useEvent from './useEvent';
-
 // Note old Internet Explorer 11 is skipped here as it is not supported anymore
 // New WebKit:
 //     'webkitRequestFullscreen',
@@ -23,14 +19,11 @@ import useEvent from './useEvent';
 //     'webkitCancelFullScreen',
 //     'webkitfullscreenchange',
 //     'webkitfullscreenerror',
-
 // type FullscreenApi = {
 //   isEnabled: boolean;
 //   toggle: NoopFunction | ((element?: HTMLElement) => Promise<unknown>); // toggle
-
 //   /** @deprecated Please use useFullScreen({onChange : function() {}}) instead. */
 //   onChange: NoopFunction | ((callback: OnChangeEventCallback) => void); // onchange
-
 //   /** @deprecated Please use useFullScreen({onError : function() {}}) instead. */
 //   onError: NoopFunction | ((callback: EventCallback) => void); // onerror
 //   request: NoopFunction | ((element?: HTMLElement) => Promise<unknown>); // request
@@ -38,170 +31,121 @@ import useEvent from './useEvent';
 //   isFullscreen: boolean; // isFullscreen
 //   element: HTMLElement | null | undefined;
 // };
-
-var defaultValue = {
-  requestFullscreen: noop,
-  exitFullscreen: noop,
-  toggleFullscreen: noop,
-  isFullscreen: false,
-  isEnabled: false
+const defaultValue = {
+    requestFullscreen: noop,
+    exitFullscreen: noop,
+    toggleFullscreen: noop,
+    isFullscreen: false,
+    isEnabled: false,
 };
-
 // type RequestFullscreenOptions = {
 //   // string will help to ease type casting
 //   navigationUI?: string | 'auto' | 'hide' | 'show';
 // };
-
 // type FullScreenOptions = {
 //   onChange?: OnChangeEventCallback;
 //   onError?: EventCallback;
 //   requestFullscreenOptions?: RequestFullscreenOptions;
 // };
-
-var requestFunctions = ['requestFullscreen', 'webkitRequestFullscreen', 'webkitRequestFullScreen', 'mozRequestFullScreen'];
-var exitFunctions = ['exitFullscreen', 'webkitExitFullscreen', 'webkitCancelFullScreen', 'mozCancelFullScreen'];
-var fullscreenElementFunctions = ['fullscreenElement', 'webkitFullscreenElement', 'webkitCurrentFullScreenElement', 'mozFullScreenElement'];
-var isFullscreenEnabledFunctions = ['fullscreenElement', 'webkitFullscreenEnabled', 'webkitCurrentFullScreenElement', 'mozFullScreenEnabled'];
-var getFnName = function getFnName(fnMap, targetElement) {
-  return fnMap.find(function (fnName) {
+const requestFunctions = [
+    'requestFullscreen',
+    'webkitRequestFullscreen',
+    'webkitRequestFullScreen',
+    'mozRequestFullScreen',
+];
+const exitFunctions = ['exitFullscreen', 'webkitExitFullscreen', 'webkitCancelFullScreen', 'mozCancelFullScreen'];
+const fullscreenElementFunctions = [
+    'fullscreenElement',
+    'webkitFullscreenElement',
+    'webkitCurrentFullScreenElement',
+    'mozFullScreenElement',
+];
+const isFullscreenEnabledFunctions = [
+    'fullscreenElement',
+    'webkitFullscreenEnabled',
+    'webkitCurrentFullScreenElement',
+    'mozFullScreenEnabled',
+];
+const getFnName = (fnMap, targetElement) => fnMap.find(fnName => {
     if (fnName in targetElement) {
-      return fnName;
+        return fnName;
     }
-  });
-};
-
+});
 // Element centered fullscreen functions
-var getRequestFunctionName = function getRequestFunctionName() {
-  var targetElement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
-  return getFnName(requestFunctions, targetElement);
-};
-
+const getRequestFunctionName = (targetElement = document) => getFnName(requestFunctions, targetElement);
 // Document fullscreen functions
-var getExitFunctionName = function getExitFunctionName() {
-  return getFnName(exitFunctions, document);
-};
-var getFullscreenElementFunctionName = function getFullscreenElementFunctionName() {
-  return getFnName(fullscreenElementFunctions, document);
-};
-var getIsFullscreenEnabledFunctionName = function getIsFullscreenEnabledFunctionName() {
-  return getFnName(isFullscreenEnabledFunctions, document);
-};
-var useFullscreen = function useFullscreen() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  if (typeof window === 'undefined') {
-    console.warn('useFullscreen: window is undefined.');
-    return defaultValue;
-  }
-  var element = options.element,
-    onChange = options.onChange,
-    onError = options.onError,
-    _options$requestFulls = options.requestFullscreenOptions,
-    requestFullscreenOptions = _options$requestFulls === void 0 ? {} : _options$requestFulls;
-
-  // use either a defined target or when document is set, use the html element as in Chrome the
-  // document does not have a request function. It needs to be an element.
-  var defaultFullscreenElement = !element || element === document ? document.querySelector('html') : element;
-  var initialFullscreenElement = document[getFullscreenElementFunctionName()];
-  var _useState = useState(Boolean(initialFullscreenElement)),
-    _useState2 = _slicedToArray(_useState, 2),
-    isFullscreen = _useState2[0],
-    setIsFullscreen = _useState2[1];
-  var _useState3 = useState(initialFullscreenElement),
-    _useState4 = _slicedToArray(_useState3, 2),
-    fullscreenElement = _useState4[0],
-    setFullscreenElement = _useState4[1];
-  var requestFullscreen = useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(newTargetElement) {
-      var isHtmlElement, target;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            // check whether the new target element is a real DOm node or just a function
-            isHtmlElement = newTargetElement instanceof HTMLElement;
-            _context.prev = 1;
-            target = newTargetElement && isHtmlElement ? newTargetElement : defaultFullscreenElement;
-            _context.next = 5;
-            return target[getRequestFunctionName(target)](requestFullscreenOptions);
-          case 5:
-            return _context.abrupt("return", _context.sent);
-          case 8:
-            _context.prev = 8;
-            _context.t0 = _context["catch"](1);
-            console.log(_context.t0);
-          case 11:
-          case "end":
-            return _context.stop();
+const getExitFunctionName = () => getFnName(exitFunctions, document);
+const getFullscreenElementFunctionName = () => getFnName(fullscreenElementFunctions, document);
+const getIsFullscreenEnabledFunctionName = () => getFnName(isFullscreenEnabledFunctions, document);
+const useFullscreen = (options = {}) => {
+    if (typeof window === 'undefined') {
+        console.warn('useFullscreen: window is undefined.');
+        return defaultValue;
+    }
+    const { element, onChange, onError, requestFullscreenOptions = {} } = options;
+    // use either a defined target or when document is set, use the html element as in Chrome the
+    // document does not have a request function. It needs to be an element.
+    const defaultFullscreenElement = !element || element === document ? document.querySelector('html') : element;
+    const initialFullscreenElement = document[getFullscreenElementFunctionName()];
+    const [isFullscreen, setIsFullscreen] = useState(Boolean(initialFullscreenElement));
+    const [fullscreenElement, setFullscreenElement] = useState(initialFullscreenElement);
+    const requestFullscreen = useCallback((newTargetElement) => __awaiter(void 0, void 0, void 0, function* () {
+        // check whether the new target element is a real DOm node or just a function
+        const isHtmlElement = newTargetElement instanceof HTMLElement;
+        try {
+            const target = newTargetElement && isHtmlElement ? newTargetElement : defaultFullscreenElement;
+            return yield target[getRequestFunctionName(target)](requestFullscreenOptions);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }), []);
+    const exitFullscreen = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            if (fullscreenElement) {
+                return yield document[getExitFunctionName()]();
+            }
         }
-      }, _callee, null, [[1, 8]]);
-    }));
-    return function (_x) {
-      return _ref.apply(this, arguments);
+        catch (error) {
+            console.warn(error);
+        }
+    }), [fullscreenElement]);
+    const toggleFullscreen = useCallback(newTargetElement => {
+        if (fullscreenElement) {
+            exitFullscreen();
+        }
+        else {
+            requestFullscreen(newTargetElement);
+        }
+    }, [fullscreenElement]);
+    const handleChangeEvent = () => {
+        const currentFullscreenElement = document[getFullscreenElementFunctionName()];
+        const isOpen = Boolean(currentFullscreenElement);
+        if (isOpen) {
+            // fullscreen was enabled
+            setIsFullscreen(true);
+            setFullscreenElement(currentFullscreenElement);
+        }
+        else {
+            // fullscreen was disabled
+            setIsFullscreen(false);
+            setFullscreenElement(null);
+        }
+        onChange === null || onChange === void 0 ? void 0 : onChange.call(document, event, isOpen);
     };
-  }(), []);
-  var exitFullscreen = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          _context2.prev = 0;
-          if (!fullscreenElement) {
-            _context2.next = 5;
-            break;
-          }
-          _context2.next = 4;
-          return document[getExitFunctionName()]();
-        case 4:
-          return _context2.abrupt("return", _context2.sent);
-        case 5:
-          _context2.next = 10;
-          break;
-        case 7:
-          _context2.prev = 7;
-          _context2.t0 = _context2["catch"](0);
-          console.warn(_context2.t0);
-        case 10:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2, null, [[0, 7]]);
-  })), [fullscreenElement]);
-  var toggleFullscreen = useCallback(function (newTargetElement) {
-    if (fullscreenElement) {
-      exitFullscreen();
-    } else {
-      requestFullscreen(newTargetElement);
-    }
-  }, [fullscreenElement]);
-  var handleChangeEvent = function handleChangeEvent() {
-    var currentFullscreenElement = document[getFullscreenElementFunctionName()];
-    var isOpen = Boolean(currentFullscreenElement);
-    if (isOpen) {
-      // fullscreen was enabled
-      setIsFullscreen(true);
-      setFullscreenElement(currentFullscreenElement);
-    } else {
-      // fullscreen was disabled
-      setIsFullscreen(false);
-      setFullscreenElement(null);
-    }
-    onChange === null || onChange === void 0 ? void 0 : onChange.call(document, event, isOpen);
-  };
-  var handleErrorEvent = function handleErrorEvent() {
-    return function (event) {
-      return onError === null || onError === void 0 ? void 0 : onError.call(document, event);
+    const handleErrorEvent = () => event => onError === null || onError === void 0 ? void 0 : onError.call(document, event);
+    useEvent('fullscreenchange', handleChangeEvent);
+    useEvent('webkitfullscreenchange', handleChangeEvent);
+    useEvent('mozfullscreenchange', handleChangeEvent);
+    useEvent('fullscreenerror', handleErrorEvent);
+    useEvent('webkitfullscreenerror', handleErrorEvent);
+    useEvent('mozfullscreenerror', handleErrorEvent);
+    return {
+        requestFullscreen,
+        exitFullscreen,
+        toggleFullscreen,
+        isFullscreen,
+        isEnabled: Boolean(document[getIsFullscreenEnabledFunctionName(document)]),
     };
-  };
-  useEvent('fullscreenchange', handleChangeEvent);
-  useEvent('webkitfullscreenchange', handleChangeEvent);
-  useEvent('mozfullscreenchange', handleChangeEvent);
-  useEvent('fullscreenerror', handleErrorEvent);
-  useEvent('webkitfullscreenerror', handleErrorEvent);
-  useEvent('mozfullscreenerror', handleErrorEvent);
-  return {
-    requestFullscreen: requestFullscreen,
-    exitFullscreen: exitFullscreen,
-    toggleFullscreen: toggleFullscreen,
-    isFullscreen: isFullscreen,
-    isEnabled: Boolean(document[getIsFullscreenEnabledFunctionName(document)])
-  };
 };
-export default useFullscreen;
+export default useFullscreen;

package/hooks/useInterval.d.ts

@@ -0,0 +1 @@
+export default function useInterval(callback: any, delay: any): import("react").MutableRefObject<null>;