@workday/canvas-kit-react 9.0.0-alpha.368-next.6 → 9.0.0-alpha.384-next.3

package/dist/commonjs/common/lib/utils/makeMq.js

@@ -7,10 +7,10 @@ exports.makeMq = void 0;
  * the breakpoint size and the value is the min-width of that breakpoint
  * @returns {Object} A set of CSS media queries for each breakpoint size
  */
-var makeMq = function (breakpoints) {
-    var mq = {};
-    Object.keys(breakpoints).forEach(function (key) {
-        mq[key] = "@media (min-width: " + breakpoints[key] + "px)";
+const makeMq = (breakpoints) => {
+    const mq = {};
+    Object.keys(breakpoints).forEach(key => {
+        mq[key] = `@media (min-width: ${breakpoints[key]}px)`;
     });
     return mq;
 };

package/dist/commonjs/common/lib/utils/memoize.d.ts

@@ -2,5 +2,5 @@
  * Simple memoize function. It takes a function and a resolver function to generate a
  * cache key
  */
-export declare function memoize<T extends (...args: any) => any>(func: T, resolver: (...args: Parameters<T>) => string): T;
+export declare function memoize<T extends (...args: any[]) => any>(func: T, resolver: (...args: Parameters<T>) => string): T;
 //# sourceMappingURL=memoize.d.ts.map

package/dist/commonjs/common/lib/utils/memoize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../common/lib/utils/memoize.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EACrD,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,GAC3C,CAAC,CAeH"}
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../common/lib/utils/memoize.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACvD,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,GAC3C,CAAC,CAeH"}

package/dist/commonjs/common/lib/utils/memoize.js

@@ -6,17 +6,13 @@ exports.memoize = void 0;
  * cache key
  */
 function memoize(func, resolver) {
-    var cache = new Map();
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var key = resolver.apply(void 0, args);
+    const cache = new Map();
+    return function (...args) {
+        const key = resolver(...args);
         if (cache.has(key)) {
             return cache.get(key);
         }
-        var result = func.apply(void 0, args);
+        const result = func(...args);
         cache.set(key, result);
         return result;
     };

package/dist/commonjs/common/lib/utils/mergeCallback.js

@@ -16,11 +16,7 @@ exports.mergeCallback = void 0;
  */
 function mergeCallback(callback1, callback2) {
     if (callback2) {
-        return (function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
+        return ((...args) => {
             callback1.apply(null, args);
             callback2.apply(null, args);
         });

package/dist/commonjs/common/lib/utils/mergeProps.js

@@ -1,18 +1,7 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeProps = void 0;
-var mergeCallback_1 = require("./mergeCallback");
+const mergeCallback_1 = require("./mergeCallback");
 // This file suppresses TS errors that come from merging interfaces of elements that aren't
 // determined within components. Element interfaces are determined only when used, so TS errors
 // aren't even useful here. Things get complicated when merging interfaces of callbacks.
@@ -25,19 +14,19 @@ var mergeCallback_1 = require("./mergeCallback");
  * passing of props from merged hooks to another without passing out to the final element props.
  */
 function mergeProps(targetProps, sourceProps) {
-    var returnProps = __assign({}, targetProps);
-    for (var key in sourceProps) {
+    const returnProps = { ...targetProps };
+    for (const key in sourceProps) {
         if (sourceProps.hasOwnProperty(key)) {
             if (key === 'css' && targetProps.hasOwnProperty('css')) {
                 // @ts-ignore
-                var css = [].concat(targetProps[key], sourceProps[key]);
+                const css = [].concat(targetProps[key], sourceProps[key]);
                 // @ts-ignore
                 returnProps[key] = css;
             }
             else if (key === 'style' && targetProps.hasOwnProperty('style')) {
                 // merge style objects
                 // @ts-ignore TS complains that key might not be on targetProps, but typeof returns
-                returnProps[key] = __assign(__assign({}, targetProps[key]), sourceProps[key]);
+                returnProps[key] = { ...targetProps[key], ...sourceProps[key] };
             }
             else if (typeof sourceProps[key] === 'function' &&
                 // @ts-ignore TS complains that key might not be on targetProps, but typeof returns

package/dist/commonjs/common/lib/utils/models.js

@@ -1,33 +1,11 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createModelHook = exports.createEvents = exports.useEventMap = exports.createEventMap = void 0;
 /* eslint-disable react-hooks/rules-of-hooks */
-var react_1 = __importDefault(require("react"));
+const react_1 = __importDefault(require("react"));
 /**
  * Convenience factory function that extracts type information and encodes it for use with model
  * config and `useEventMap`. Under the hood, it returns the config that was passed in. The real
@@ -54,13 +32,13 @@ var react_1 = __importDefault(require("react"));
  *
  * @deprecated `createModelHook` uses Template Literal Types to create event map types
  */
-var createEventMap = function () { return function (config) {
+const createEventMap = () => (config) => {
     // Instruct Typescript that all valid guards and callbacks exist
     return config;
-}; };
+};
 exports.createEventMap = createEventMap;
 // small wrapper to get `keyof T` instead of `string | number | symbol`
-var keys = function (input) { return Object.keys(input); };
+const keys = (input) => Object.keys(input);
 /**
  * This hook creates a stable reference events object to be used in a model. The reference is stable
  * by the use of `React.Memo` and uses React Refs to make sure there are no stale closure values. It
@@ -82,30 +60,30 @@ var keys = function (input) { return Object.keys(input); };
  * })
  * @deprecated Use `createModelHook` instead
  */
-var useEventMap = function (eventMap, state, config, events) {
+const useEventMap = (eventMap, state, config, events) => {
     // use refs so we can memoize the returned `events` object
-    var eventMapRef = react_1.default.useRef(eventMap);
-    var stateRef = react_1.default.useRef(state);
-    var configRef = react_1.default.useRef(config);
-    var eventsRef = react_1.default.useRef(events);
+    const eventMapRef = react_1.default.useRef(eventMap);
+    const stateRef = react_1.default.useRef(state);
+    const configRef = react_1.default.useRef(config);
+    const eventsRef = react_1.default.useRef(events);
     // update all the refs with current values
     eventMapRef.current = eventMap;
     stateRef.current = state;
     configRef.current = config;
     eventsRef.current = events;
-    return react_1.default.useMemo(function () {
-        return keys(eventsRef.current).reduce(function (result, key) {
-            result[key] = (function (data) {
+    return react_1.default.useMemo(() => {
+        return keys(eventsRef.current).reduce((result, key) => {
+            result[key] = (data => {
                 var _a, _b;
                 // Invoke the configured guard if there is one
                 if (!eventsRef.current[key]._wrapped) {
-                    var guardFn = keys(eventMapRef.current.guards || {}).find(function (k) {
+                    const guardFn = keys(eventMapRef.current.guards || {}).find(k => {
                         return (eventMapRef.current.guards || {})[k] === key;
                     });
                     if (guardFn &&
                         ((_a = configRef.current) === null || _a === void 0 ? void 0 : _a[guardFn]) &&
                         //@ts-ignore Typescript doesn't like that the call signatures are different
-                        !configRef.current[guardFn]({ data: data, state: stateRef.current })) {
+                        !configRef.current[guardFn]({ data, state: stateRef.current })) {
                         return;
                     }
                 }
@@ -113,12 +91,12 @@ var useEventMap = function (eventMap, state, config, events) {
                 eventsRef.current[key](data);
                 if (!eventsRef.current[key]._wrapped) {
                     // Invoke the configured callback if there is one
-                    var callbackFn = keys(eventMapRef.current.callbacks || {}).find(function (k) {
+                    const callbackFn = keys(eventMapRef.current.callbacks || {}).find(k => {
                         return (eventMapRef.current.callbacks || {})[k] === key;
                     });
                     if (callbackFn && ((_b = configRef.current) === null || _b === void 0 ? void 0 : _b[callbackFn])) {
                         //@ts-ignore Typescript doesn't like that the call signatures are different
-                        configRef.current[callbackFn]({ data: data, prevState: stateRef.current });
+                        configRef.current[callbackFn]({ data, prevState: stateRef.current });
                     }
                 }
             }); // this cast keeps Typescript happy
@@ -130,30 +108,30 @@ var useEventMap = function (eventMap, state, config, events) {
 };
 exports.useEventMap = useEventMap;
 // use this?
-var createEvents = function (events) { return function (config) {
-    return { events: events, eventMap: config };
-}; };
+const createEvents = (events) => (config) => {
+    return { events, eventMap: config };
+};
 exports.createEvents = createEvents;
 function capitalize(string) {
     return string[0].toUpperCase() + string.substring(1);
 }
 function getGuardName(eventName) {
-    return "should" + capitalize(eventName);
+    return `should${capitalize(eventName)}`;
 }
 function getCallbackName(eventName) {
-    return "on" + capitalize(eventName);
+    return `on${capitalize(eventName)}`;
 }
 // Merges config together in a way that is type safe and works at runtime with correct rules and order applied
 // to guards and callbacks.
 function mergeConfig(sourceConfig, newConfig) {
-    var result = __assign({}, sourceConfig);
-    var _loop_1 = function (key) {
+    const result = { ...sourceConfig };
+    for (const key in newConfig) {
         if (typeof newConfig[key] === "function" &&
             /(on)[A-Z]/.test(key) &&
             typeof sourceConfig[key] === "function") {
             // merge callbacks and ignore Typescript's errors. We've already tested call signatures
             //  @ts-ignore
-            result[key] = function (data, state) {
+            result[key] = (data, state) => {
                 // @ts-ignore
                 sourceConfig[key](data, state);
                 // @ts-ignore
@@ -165,7 +143,7 @@ function mergeConfig(sourceConfig, newConfig) {
             sourceConfig[key]) {
             // merge guards and ignore Typescript's errors. We've already tested call signatures
             // @ts-ignore
-            result[key] = function (data, state) {
+            result[key] = (data, state) => {
                 // @ts-ignore
                 return sourceConfig[key](data, state) && newConfig[key](data, state);
             };
@@ -174,9 +152,6 @@ function mergeConfig(sourceConfig, newConfig) {
             // @ts-ignore
             result[key] = newConfig[key];
         }
-    };
-    for (var key in newConfig) {
-        _loop_1(key);
     }
     return result;
 }
@@ -203,21 +178,21 @@ function mergeConfig(sourceConfig, newConfig) {
  *   // config is pre-typed for you based on `defaultConfig`
  * })
  */
-var createModelHook = function (options) {
-    var _a = options.defaultConfig, defaultConfig = _a === void 0 ? {} : _a, _b = options.requiredConfig, requiredConfig = _b === void 0 ? {} : _b, defaultContext = options.defaultContext, contextOverride = options.contextOverride;
+const createModelHook = (options) => {
+    const { defaultConfig = {}, requiredConfig = {}, defaultContext, contextOverride } = options;
     // create a bunch of refs so we can define the `wrappedModel` function once.
-    var fnRef = { current: null };
-    var callbacksRef = { current: [] };
-    var guardsRef = { current: [] };
-    var Context = contextOverride || react_1.default.createContext(defaultContext || { state: {}, events: {} });
-    var getElemProps = function (props) {
+    const fnRef = { current: null };
+    const callbacksRef = { current: [] };
+    const guardsRef = { current: [] };
+    const Context = contextOverride || react_1.default.createContext(defaultContext || { state: {}, events: {} });
+    const getElemProps = (props) => {
         // if (eventsRef.current === null) {
         //   throw Error(
         //     `useModel.getElemProps() must be called after useModel(). getElemProps needs to determine the events returned by the model to function correctly.\nExample:\nconst model = useModel();\nconst elemProps = useModel.getElemProps(props);`
         //   );
         // }
-        var elemProps = {};
-        for (var key in props) {
+        const elemProps = {};
+        for (const key in props) {
             if (!defaultConfig.hasOwnProperty(key) &&
                 !requiredConfig.hasOwnProperty(key) &&
                 !callbacksRef.current.includes(key) &&
@@ -231,10 +206,13 @@ var createModelHook = function (options) {
     // we use `any` here because we don't know what the type is here and it is internal. No use
     // slowing down Typescript to bother type checking
     function wrappedModelHook(config) {
-        var stateRef = react_1.default.useRef({});
-        var configRef = react_1.default.useRef({});
-        var eventsRef = react_1.default.useRef({});
-        var _a = fnRef.current(__assign(__assign({}, defaultConfig), config)), state = _a.state, events = _a.events, rest = __rest(_a, ["state", "events"]);
+        const stateRef = react_1.default.useRef({});
+        const configRef = react_1.default.useRef({});
+        const eventsRef = react_1.default.useRef({});
+        const { state, events, ...rest } = fnRef.current({
+            ...defaultConfig,
+            ...config,
+        });
         // update all the refs with current values
         stateRef.current = state;
         configRef.current = config || {};
@@ -245,12 +223,12 @@ var createModelHook = function (options) {
         if (!guardsRef.current.length) {
             guardsRef.current = keys(events).map(getGuardName);
         }
-        var wrappedEvents = react_1.default.useMemo(function () {
-            return keys(eventsRef.current).reduce(function (result, key) {
-                result[key] = function (data) {
+        const wrappedEvents = react_1.default.useMemo(() => {
+            return keys(eventsRef.current).reduce((result, key) => {
+                result[key] = (data) => {
                     // Invoke the configured guard if there is one
                     if (!eventsRef.current[key]._wrapped) {
-                        var guardFnName = getGuardName(key);
+                        const guardFnName = getGuardName(key);
                         if (configRef.current[guardFnName] &&
                             !configRef.current[guardFnName](data, stateRef.current)) {
                             return;
@@ -258,7 +236,7 @@ var createModelHook = function (options) {
                     }
                     // call the event (setter)
                     eventsRef.current[key](data);
-                    var callbackFnName = getCallbackName(key);
+                    const callbackFnName = getCallbackName(key);
                     if (!eventsRef.current[key]._wrapped) {
                         if (configRef.current[callbackFnName]) {
                             configRef.current[callbackFnName](data, stateRef.current);
@@ -270,14 +248,14 @@ var createModelHook = function (options) {
                 return result;
             }, {});
         }, []);
-        return __assign({ state: state, events: wrappedEvents }, rest);
+        return { state, events: wrappedEvents, ...rest };
     }
     wrappedModelHook.getElemProps = getElemProps;
     wrappedModelHook.defaultConfig = defaultConfig;
     wrappedModelHook.requiredConfig = requiredConfig;
     wrappedModelHook.mergeConfig = mergeConfig;
     wrappedModelHook.Context = Context;
-    return function (fn) {
+    return (fn) => {
         fnRef.current = fn;
         return wrappedModelHook; // Typescript complains about the `fn` not matching the signature. It's okay Typescript. It works at runtime
     };

package/dist/commonjs/common/lib/utils/useConstant.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useConstant = void 0;
-var react_1 = require("react");
+const react_1 = require("react");
 /**
  * Get a constant value in React, only running the callback function once.  `React.useMemo` does not
  * guarantee that a function will only be run once.
@@ -10,7 +10,7 @@ var react_1 = require("react");
  * const value = useConstant(generateUniqueId)
  */
 function useConstant(fn) {
-    var ref = react_1.useRef();
+    const ref = react_1.useRef();
     if (!ref.current) {
         ref.current = fn();
     }

package/dist/commonjs/common/lib/utils/useIsFullscreen.js

@@ -4,16 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useIsFullscreen = void 0;
-var react_1 = __importDefault(require("react"));
-var screenfull_1 = __importDefault(require("screenfull"));
-var useIsFullscreen = function () {
-    var _a = react_1.default.useState(false), isFullscreen = _a[0], setIsFullscreen = _a[1];
-    var handler = react_1.default.useCallback(function () {
+const react_1 = __importDefault(require("react"));
+const screenfull_1 = __importDefault(require("screenfull"));
+const useIsFullscreen = () => {
+    const [isFullscreen, setIsFullscreen] = react_1.default.useState(false);
+    const handler = react_1.default.useCallback(() => {
         setIsFullscreen(screenfull_1.default.isFullscreen);
     }, []);
-    react_1.default.useEffect(function () {
+    react_1.default.useEffect(() => {
         screenfull_1.default.on('change', handler);
-        return function () {
+        return () => {
             screenfull_1.default.off('change', handler);
         };
     }, [handler]);

package/dist/commonjs/common/lib/utils/useModalityType.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useModalityType = void 0;
-var react_1 = __importDefault(require("react"));
+const react_1 = __importDefault(require("react"));
 function safeLocalStorageGet(key) {
     try {
         return localStorage.get(key);
@@ -30,7 +30,7 @@ function safeLocalStorageSet(key, value) {
 //   a. if localStorage isn't primed, use clientWidth of the browsers
 //   b. if < 768, default to 'touch'
 //   c. else default to 'mouse'
-var localStorageValue = (safeLocalStorageGet('modality') ||
+let localStorageValue = (safeLocalStorageGet('modality') ||
     (typeof document !== 'undefined'
         ? document.documentElement.clientWidth < 768
             ? 'touch'
@@ -40,7 +40,7 @@ var localStorageValue = (safeLocalStorageGet('modality') ||
 // Update the `localStorageValue`, but conditionally update localStorage only if the value has
 // changed. This prevents too many calls to `localStorage` which can be costly on spinning disk
 // drives
-var updateLocalStorage = function (value) {
+const updateLocalStorage = (value) => {
     if (localStorageValue !== value) {
         safeLocalStorageSet('modality', value);
     }
@@ -59,16 +59,16 @@ var updateLocalStorage = function (value) {
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerType
  */
-var useModalityType = function () {
-    var _a = react_1.default.useState(localStorageValue), modality = _a[0], setModality = _a[1];
-    react_1.default.useEffect(function () {
-        var handlePointerDown = function (event) {
-            var value = event.pointerType;
+const useModalityType = () => {
+    const [modality, setModality] = react_1.default.useState(localStorageValue);
+    react_1.default.useEffect(() => {
+        const handlePointerDown = (event) => {
+            const value = event.pointerType;
             setModality(value);
             updateLocalStorage(value);
         };
         document.addEventListener('pointerdown', handlePointerDown);
-        return function () {
+        return () => {
             document.removeEventListener('pointerdown', handlePointerDown);
         };
     }, []);

package/dist/commonjs/common/lib/utils/useMount.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMountLayout = exports.useMount = void 0;
-var react_1 = __importDefault(require("react"));
+const react_1 = __importDefault(require("react"));
 /**
  * Alias to `useEffect` with the intention to only run on mount/unmount.
  * Avoids the React lint errors and encodes intent.
  */
-var useMount = function (callback) {
+const useMount = (callback) => {
     // we only want this to be called once
     // eslint-disable-next-line react-hooks/exhaustive-deps
     react_1.default.useEffect(callback, []);
@@ -19,7 +19,7 @@ exports.useMount = useMount;
  * Alias to `useLayoutEffect` with the intention to only run on mount/unmount
  * Avoids the React lint errors and encodes intent.
  */
-var useMountLayout = function (callback) {
+const useMountLayout = (callback) => {
     // we only want this to be called once
     // eslint-disable-next-line react-hooks/exhaustive-deps
     react_1.default.useLayoutEffect(callback, []);

package/dist/commonjs/common/lib/utils/useResizeObserver.js

@@ -1,35 +1,23 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useResizeObserver = void 0;
-var react_1 = __importDefault(require("react"));
-var use_resize_observer_1 = __importDefault(require("use-resize-observer"));
-var resize_observer_polyfill_1 = __importDefault(require("resize-observer-polyfill"));
+const react_1 = __importDefault(require("react"));
+const use_resize_observer_1 = __importDefault(require("use-resize-observer"));
+const resize_observer_polyfill_1 = __importDefault(require("resize-observer-polyfill"));
 if (typeof window !== 'undefined' && !window.ResizeObserver) {
     window.ResizeObserver = resize_observer_polyfill_1.default;
 }
 // `useResizeObserver` contains this fix in 8.0.0:
 // https://github.com/ZeeCoder/use-resize-observer/commit/bd0f3c8597bac0d853b88cf585256aac1bd4f554
 // v8.0.0 requires TS4.2. So we'll manually patch until we're ready for TS4.2+
-var useResizeObserver = function (params) {
-    if (params === void 0) { params = {}; }
-    var widthRef = react_1.default.useRef();
-    var heightRef = react_1.default.useRef();
-    var onResize = params.onResize
-        ? function (data) {
+const useResizeObserver = (params = {}) => {
+    const widthRef = react_1.default.useRef();
+    const heightRef = react_1.default.useRef();
+    const onResize = params.onResize
+        ? (data) => {
             if (widthRef.current !== data.width || heightRef.current !== data.height) {
                 widthRef.current = data.width;
                 heightRef.current = data.height;
@@ -37,7 +25,7 @@ var useResizeObserver = function (params) {
             }
         }
         : undefined;
-    return use_resize_observer_1.default(__assign(__assign({}, params), { onResize: onResize }));
+    return use_resize_observer_1.default({ ...params, onResize });
 };
 exports.useResizeObserver = useResizeObserver;
 // When the dependency is moved up to v8.0.0, remove the above function and export below instead

package/dist/commonjs/common/lib/utils/useUniqueId.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetUniqueIdCount = exports.setUniqueSeed = exports.uniqueId = exports.useUniqueId = exports.generateUniqueId = void 0;
-var useConstant_1 = require("./useConstant");
+const useConstant_1 = require("./useConstant");
 // Create a unique seed per import to prevent collisions from other versions of `useUniqueId`
-var seed = Math.random()
+let seed = Math.random()
     .toString(36)
     .slice(2)
     .replace(/[0-9]*/, '')
     .substr(0, 4);
-var c = 0;
+let c = 0;
 /**
  * Generates a unique and HTML5 compliant identifier every time it is called. Internally it uses a 4
  * character random seed starting with a letter. This seed is unique to each instance of this
@@ -18,15 +18,15 @@ var c = 0;
  * [resetUniqueIdCount](#resetuniqueidcount). [setUniqueSeed](#setuniqueseed) can also be used for
  * testing or server side rendering to get the same results during hydration.
  */
-var generateUniqueId = function () { return seed + (c++).toString(36); };
+const generateUniqueId = () => seed + (c++).toString(36);
 exports.generateUniqueId = generateUniqueId;
 /**
  * Generate a unique ID if one is not provided. The generated ID will be stable across renders
  * @param id Optional ID provided that will be used instead of a unique ID
  */
-var useUniqueId = function (id) {
+const useUniqueId = (id) => {
     // https://codesandbox.io/s/react-functional-component-ids-p2ndq
-    var generatedId = useConstant_1.useConstant(exports.generateUniqueId);
+    const generatedId = useConstant_1.useConstant(exports.generateUniqueId);
     return id || generatedId;
 };
 exports.useUniqueId = useUniqueId;
@@ -50,14 +50,14 @@ exports.uniqueId = exports.useUniqueId;
  *   setSeed('a')
  * })
  */
-var setUniqueSeed = function (s) {
+const setUniqueSeed = (s) => {
     seed = s;
 };
 exports.setUniqueSeed = setUniqueSeed;
 /**
  * This should only be called for tests in an `beforeEach`
  */
-var resetUniqueIdCount = function () {
+const resetUniqueIdCount = () => {
     c = 0;
 };
 exports.resetUniqueIdCount = resetUniqueIdCount;

package/dist/commonjs/common/lib/utils/useWindowSize.js

@@ -4,28 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useWindowSize = void 0;
-var react_1 = __importDefault(require("react"));
-var useMount_1 = require("./useMount");
-var getFromWindow = function (property, defaultValue) {
+const react_1 = __importDefault(require("react"));
+const useMount_1 = require("./useMount");
+const getFromWindow = (property, defaultValue) => {
     var _a;
     if (typeof window !== undefined) {
         return (_a = window[property]) !== null && _a !== void 0 ? _a : defaultValue;
     }
     return defaultValue;
 };
-var useWindowSize = function () {
-    var _a = react_1.default.useState(getFromWindow('innerWidth', 0)), width = _a[0], setWidth = _a[1];
-    var _b = react_1.default.useState(getFromWindow('innerHeight', 0)), height = _b[0], setHeight = _b[1];
-    var onResize = function () {
+const useWindowSize = () => {
+    const [width, setWidth] = react_1.default.useState(getFromWindow('innerWidth', 0));
+    const [height, setHeight] = react_1.default.useState(getFromWindow('innerHeight', 0));
+    const onResize = () => {
         setWidth(window.innerWidth);
         setHeight(window.innerHeight);
     };
-    useMount_1.useMount(function () {
+    useMount_1.useMount(() => {
         window.addEventListener('resize', onResize);
-        return function () {
+        return () => {
             window.removeEventListener('resize', onResize);
         };
     });
-    return { width: width, height: height };
+    return { width, height };
 };
 exports.useWindowSize = useWindowSize;