@workday/canvas-kit-react 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

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

@@ -3,17 +3,13 @@
  * cache key
  */
 export 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/es6/common/lib/utils/mergeCallback.js

@@ -13,11 +13,7 @@
  */
 export 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/es6/common/lib/utils/mergeProps.js

@@ -1,14 +1,3 @@
-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);
-};
 import { mergeCallback } from './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
@@ -22,19 +11,19 @@ import { mergeCallback } from './mergeCallback';
  * passing of props from merged hooks to another without passing out to the final element props.
  */
 export 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/es6/common/lib/utils/models.js

@@ -1,25 +1,3 @@
-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;
-};
 /* eslint-disable react-hooks/rules-of-hooks */
 import React from 'react';
 /**
@@ -48,12 +26,12 @@ import React from 'react';
  *
  * @deprecated `createModelHook` uses Template Literal Types to create event map types
  */
-export var createEventMap = function () { return function (config) {
+export const createEventMap = () => (config) => {
     // Instruct Typescript that all valid guards and callbacks exist
     return config;
-}; };
+};
 // 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
@@ -75,30 +53,30 @@ var keys = function (input) { return Object.keys(input); };
  * })
  * @deprecated Use `createModelHook` instead
  */
-export var useEventMap = function (eventMap, state, config, events) {
+export const useEventMap = (eventMap, state, config, events) => {
     // use refs so we can memoize the returned `events` object
-    var eventMapRef = React.useRef(eventMap);
-    var stateRef = React.useRef(state);
-    var configRef = React.useRef(config);
-    var eventsRef = React.useRef(events);
+    const eventMapRef = React.useRef(eventMap);
+    const stateRef = React.useRef(state);
+    const configRef = React.useRef(config);
+    const eventsRef = React.useRef(events);
     // update all the refs with current values
     eventMapRef.current = eventMap;
     stateRef.current = state;
     configRef.current = config;
     eventsRef.current = events;
-    return React.useMemo(function () {
-        return keys(eventsRef.current).reduce(function (result, key) {
-            result[key] = (function (data) {
+    return React.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;
                     }
                 }
@@ -106,12 +84,12 @@ export 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
@@ -122,29 +100,29 @@ export var useEventMap = function (eventMap, state, config, events) {
     }, []);
 };
 // use this?
-export var createEvents = function (events) { return function (config) {
-    return { events: events, eventMap: config };
-}; };
+export const createEvents = (events) => (config) => {
+    return { events, eventMap: config };
+};
 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
@@ -156,7 +134,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);
             };
@@ -165,9 +143,6 @@ function mergeConfig(sourceConfig, newConfig) {
             // @ts-ignore
             result[key] = newConfig[key];
         }
-    };
-    for (var key in newConfig) {
-        _loop_1(key);
     }
     return result;
 }
@@ -194,21 +169,21 @@ function mergeConfig(sourceConfig, newConfig) {
  *   // config is pre-typed for you based on `defaultConfig`
  * })
  */
-export 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;
+export 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.createContext(defaultContext || { state: {}, events: {} });
-    var getElemProps = function (props) {
+    const fnRef = { current: null };
+    const callbacksRef = { current: [] };
+    const guardsRef = { current: [] };
+    const Context = contextOverride || React.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) &&
@@ -222,10 +197,13 @@ export 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.useRef({});
-        var configRef = React.useRef({});
-        var eventsRef = React.useRef({});
-        var _a = fnRef.current(__assign(__assign({}, defaultConfig), config)), state = _a.state, events = _a.events, rest = __rest(_a, ["state", "events"]);
+        const stateRef = React.useRef({});
+        const configRef = React.useRef({});
+        const eventsRef = React.useRef({});
+        const { state, events, ...rest } = fnRef.current({
+            ...defaultConfig,
+            ...config,
+        });
         // update all the refs with current values
         stateRef.current = state;
         configRef.current = config || {};
@@ -236,12 +214,12 @@ export var createModelHook = function (options) {
         if (!guardsRef.current.length) {
             guardsRef.current = keys(events).map(getGuardName);
         }
-        var wrappedEvents = React.useMemo(function () {
-            return keys(eventsRef.current).reduce(function (result, key) {
-                result[key] = function (data) {
+        const wrappedEvents = React.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;
@@ -249,7 +227,7 @@ export 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);
@@ -261,14 +239,14 @@ export 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/es6/common/lib/utils/useConstant.js

@@ -7,7 +7,7 @@ import { useRef } from 'react';
  * const value = useConstant(generateUniqueId)
  */
 export function useConstant(fn) {
-    var ref = useRef();
+    const ref = useRef();
     if (!ref.current) {
         ref.current = fn();
     }

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

@@ -1,13 +1,13 @@
 import React from 'react';
 import screenfull from 'screenfull';
-export var useIsFullscreen = function () {
-    var _a = React.useState(false), isFullscreen = _a[0], setIsFullscreen = _a[1];
-    var handler = React.useCallback(function () {
+export const useIsFullscreen = () => {
+    const [isFullscreen, setIsFullscreen] = React.useState(false);
+    const handler = React.useCallback(() => {
         setIsFullscreen(screenfull.isFullscreen);
     }, []);
-    React.useEffect(function () {
+    React.useEffect(() => {
         screenfull.on('change', handler);
-        return function () {
+        return () => {
             screenfull.off('change', handler);
         };
     }, [handler]);

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

@@ -24,7 +24,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'
@@ -34,7 +34,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);
     }
@@ -53,16 +53,16 @@ var updateLocalStorage = function (value) {
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/pointerType
  */
-export var useModalityType = function () {
-    var _a = React.useState(localStorageValue), modality = _a[0], setModality = _a[1];
-    React.useEffect(function () {
-        var handlePointerDown = function (event) {
-            var value = event.pointerType;
+export const useModalityType = () => {
+    const [modality, setModality] = React.useState(localStorageValue);
+    React.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/es6/common/lib/utils/useMount.js

@@ -3,7 +3,7 @@ import React from 'react';
  * Alias to `useEffect` with the intention to only run on mount/unmount.
  * Avoids the React lint errors and encodes intent.
  */
-export var useMount = function (callback) {
+export const useMount = (callback) => {
     // we only want this to be called once
     // eslint-disable-next-line react-hooks/exhaustive-deps
     React.useEffect(callback, []);
@@ -12,7 +12,7 @@ export var useMount = function (callback) {
  * Alias to `useLayoutEffect` with the intention to only run on mount/unmount
  * Avoids the React lint errors and encodes intent.
  */
-export var useMountLayout = function (callback) {
+export const useMountLayout = (callback) => {
     // we only want this to be called once
     // eslint-disable-next-line react-hooks/exhaustive-deps
     React.useLayoutEffect(callback, []);

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

@@ -1,14 +1,3 @@
-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);
-};
 import React from 'react';
 import useResizeObserverOriginal from 'use-resize-observer';
 import ResizeObserver from 'resize-observer-polyfill';
@@ -18,12 +7,11 @@ if (typeof window !== 'undefined' && !window.ResizeObserver) {
 // `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+
-export var useResizeObserver = function (params) {
-    if (params === void 0) { params = {}; }
-    var widthRef = React.useRef();
-    var heightRef = React.useRef();
-    var onResize = params.onResize
-        ? function (data) {
+export const useResizeObserver = (params = {}) => {
+    const widthRef = React.useRef();
+    const heightRef = React.useRef();
+    const onResize = params.onResize
+        ? (data) => {
             if (widthRef.current !== data.width || heightRef.current !== data.height) {
                 widthRef.current = data.width;
                 heightRef.current = data.height;
@@ -31,7 +19,7 @@ export var useResizeObserver = function (params) {
             }
         }
         : undefined;
-    return useResizeObserverOriginal(__assign(__assign({}, params), { onResize: onResize }));
+    return useResizeObserverOriginal({ ...params, onResize });
 };
 // When the dependency is moved up to v8.0.0, remove the above function and export below instead
 // export {useResizeObserver};

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

@@ -1,11 +1,11 @@
 import { useConstant } from './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
@@ -15,14 +15,14 @@ var c = 0;
  * [resetUniqueIdCount](#resetuniqueidcount). [setUniqueSeed](#setuniqueseed) can also be used for
  * testing or server side rendering to get the same results during hydration.
  */
-export var generateUniqueId = function () { return seed + (c++).toString(36); };
+export const generateUniqueId = () => seed + (c++).toString(36);
 /**
  * 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
  */
-export var useUniqueId = function (id) {
+export const useUniqueId = (id) => {
     // https://codesandbox.io/s/react-functional-component-ids-p2ndq
-    var generatedId = useConstant(generateUniqueId);
+    const generatedId = useConstant(generateUniqueId);
     return id || generatedId;
 };
 /**
@@ -30,7 +30,7 @@ export var useUniqueId = function (id) {
  * @deprecated
  * TODO: Remove in major release
  */
-export var uniqueId = useUniqueId;
+export const uniqueId = useUniqueId;
 /**
  * Update the seed used by the id generator. This is useful for snapshot tests to help stabilize ids
  * generated each run. This could also be used for server-side hydration - if you choose the same
@@ -45,12 +45,12 @@ export var uniqueId = useUniqueId;
  *   setSeed('a')
  * })
  */
-export var setUniqueSeed = function (s) {
+export const setUniqueSeed = (s) => {
     seed = s;
 };
 /**
  * This should only be called for tests in an `beforeEach`
  */
-export var resetUniqueIdCount = function () {
+export const resetUniqueIdCount = () => {
     c = 0;
 };

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

@@ -1,24 +1,24 @@
 import React from 'react';
 import { useMount } from './useMount';
-var getFromWindow = function (property, defaultValue) {
+const getFromWindow = (property, defaultValue) => {
     var _a;
     if (typeof window !== undefined) {
         return (_a = window[property]) !== null && _a !== void 0 ? _a : defaultValue;
     }
     return defaultValue;
 };
-export var useWindowSize = function () {
-    var _a = React.useState(getFromWindow('innerWidth', 0)), width = _a[0], setWidth = _a[1];
-    var _b = React.useState(getFromWindow('innerHeight', 0)), height = _b[0], setHeight = _b[1];
-    var onResize = function () {
+export const useWindowSize = () => {
+    const [width, setWidth] = React.useState(getFromWindow('innerWidth', 0));
+    const [height, setHeight] = React.useState(getFromWindow('innerHeight', 0));
+    const onResize = () => {
         setWidth(window.innerWidth);
         setHeight(window.innerHeight);
     };
-    useMount(function () {
+    useMount(() => {
         window.addEventListener('resize', onResize);
-        return function () {
+        return () => {
             window.removeEventListener('resize', onResize);
         };
     });
-    return { width: width, height: height };
+    return { width, height };
 };

package/dist/es6/dialog/lib/Dialog.js

@@ -4,7 +4,7 @@ import { Popup } from '@workday/canvas-kit-react/popup';
 import { DialogPopper } from './DialogPopper';
 import { DialogCard } from './DialogCard';
 import { useDialogModel } from './hooks';
-export var Dialog = createContainer()({
+export const Dialog = createContainer()({
     displayName: 'Dialog',
     modelHook: useDialogModel,
     subComponents: {
@@ -16,7 +16,6 @@ export var Dialog = createContainer()({
         Popper: DialogPopper,
         CloseButton: Popup.CloseButton,
     },
-})(function (_a) {
-    var children = _a.children;
+})(({ children }) => {
     return React.createElement(React.Fragment, null, children);
 });

package/dist/es6/dialog/lib/DialogCard.js

@@ -1,22 +1,11 @@
-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);
-};
 import * as React from 'react';
 import { createSubcomponent } from '@workday/canvas-kit-react/common';
 import { Popup } from '@workday/canvas-kit-react/popup';
 import { useDialogCard, useDialogModel } from './hooks';
-export var DialogCard = createSubcomponent('div')({
+export const DialogCard = createSubcomponent('div')({
     displayName: 'Dialog.Card',
     modelHook: useDialogModel,
     elemPropsHook: useDialogCard,
-})(function (elemProps, Element, model) {
-    return (React.createElement(Popup.Card, __assign({ as: Element, model: model }, elemProps), elemProps.children));
+})((elemProps, Element, model) => {
+    return (React.createElement(Popup.Card, Object.assign({ as: Element, model: model }, elemProps), elemProps.children));
 });

package/dist/es6/dialog/lib/DialogPopper.js

@@ -1,39 +1,16 @@
-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;
-};
 import * as React from 'react';
 import { createSubcomponent } from '@workday/canvas-kit-react/common';
 import { usePopupPopper, Popper } from '@workday/canvas-kit-react/popup';
 import { useDialogPopper, useDialogModel } from './hooks';
-export var DialogPopper = createSubcomponent('div')({
+export const DialogPopper = createSubcomponent('div')({
     displayName: 'Dialog.Popper',
     modelHook: useDialogModel,
-})(function (_a, Element, model) {
-    var children = _a.children, placement = _a.placement, popperOptions = _a.popperOptions, ref = _a.ref, props = __rest(_a, ["children", "placement", "popperOptions", "ref"]);
-    var popperProps = usePopupPopper(model, { placement: placement, popperOptions: popperOptions }, ref);
-    var elemProps = useDialogPopper(model, props);
+})(({ children, placement, popperOptions, ref, ...props }, Element, model) => {
+    const popperProps = usePopupPopper(model, { placement, popperOptions }, ref);
+    const elemProps = useDialogPopper(model, props);
     if (model.state.visibility === 'hidden') {
         return null;
     }
-    return (React.createElement(Element, __assign({}, elemProps),
-        React.createElement(Popper, __assign({}, popperProps), children)));
+    return (React.createElement(Element, Object.assign({}, elemProps),
+        React.createElement(Popper, Object.assign({}, popperProps), children)));
 });

package/dist/es6/dialog/lib/hooks/useDialogCard.js

@@ -1,8 +1,7 @@
 import { composeHooks, createElemPropsHook } from '@workday/canvas-kit-react/common';
 import { usePopupCard, usePopupModel } from '@workday/canvas-kit-react/popup';
-export var useDialogCard = composeHooks(usePopupCard, createElemPropsHook(usePopupModel)(function (_a) {
-    var state = _a.state;
+export const useDialogCard = composeHooks(usePopupCard, createElemPropsHook(usePopupModel)(({ state }) => {
     return {
-        id: "dialog-" + state.id,
+        id: `dialog-${state.id}`,
     };
 }));