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

package/dist/es6/text-area/lib/TextArea.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;
-};
 import * as React from 'react';
 import { createComponent, ErrorType, errorRing, styled, } from '@workday/canvas-kit-react/common';
 import { borderRadius, inputColors, spaceNumbers, type } from '@workday/canvas-kit-react/tokens';
@@ -30,41 +8,50 @@ export var TextAreaResizeDirection;
     TextAreaResizeDirection["Horizontal"] = "horizontal";
     TextAreaResizeDirection["Vertical"] = "vertical";
 })(TextAreaResizeDirection || (TextAreaResizeDirection = {}));
-var StyledTextArea = styled('textarea')(function (_a) {
-    var theme = _a.theme, error = _a.error;
-    return (__assign(__assign(__assign({}, type.levels.subtext.large), { border: "1px solid " + inputColors.border, display: 'block', backgroundColor: inputColors.background, borderRadius: borderRadius.m, boxSizing: 'border-box', minHeight: 64, minWidth: 280, transition: '0.2s box-shadow, 0.2s border-color', padding: spaceNumbers.xxs, margin: 0, '&::webkit-resizer': {
-            display: 'none',
-        }, '&::placeholder': {
-            color: inputColors.placeholder,
-        }, '&:hover': {
-            borderColor: inputColors.hoverBorder,
-        }, '&:focus:not([disabled])': {
-            borderColor: theme.canvas.palette.common.focusOutline,
-            boxShadow: "inset 0 0 0 1px " + theme.canvas.palette.common.focusOutline,
-            outline: 'none',
-        }, '&:disabled': {
-            backgroundColor: inputColors.disabled.background,
-            borderColor: inputColors.disabled.border,
+const StyledTextArea = styled('textarea')(({ theme, error }) => ({
+    ...type.levels.subtext.large,
+    border: `1px solid ${inputColors.border}`,
+    display: 'block',
+    backgroundColor: inputColors.background,
+    borderRadius: borderRadius.m,
+    boxSizing: 'border-box',
+    minHeight: 64,
+    minWidth: 280,
+    transition: '0.2s box-shadow, 0.2s border-color',
+    padding: spaceNumbers.xxs,
+    margin: 0,
+    '&::webkit-resizer': {
+        display: 'none',
+    },
+    '&::placeholder': {
+        color: inputColors.placeholder,
+    },
+    '&:hover': {
+        borderColor: inputColors.hoverBorder,
+    },
+    '&:focus:not([disabled])': {
+        borderColor: theme.canvas.palette.common.focusOutline,
+        boxShadow: `inset 0 0 0 1px ${theme.canvas.palette.common.focusOutline}`,
+        outline: 'none',
+    },
+    '&:disabled': {
+        backgroundColor: inputColors.disabled.background,
+        borderColor: inputColors.disabled.border,
+        color: inputColors.disabled.text,
+        '&::placeholder': {
             color: inputColors.disabled.text,
-            '&::placeholder': {
-                color: inputColors.disabled.text,
-            },
-        } }), errorRing(error, theme)));
-}, function (_a) {
-    var resize = _a.resize, grow = _a.grow;
-    return ({
-        width: grow ? '100%' : undefined,
-        resize: grow ? TextAreaResizeDirection.Vertical : resize,
-    });
-});
-export var TextArea = createComponent('textarea')({
-    displayName: 'TextArea',
-    Component: function (_a, ref, Element) {
-        var _b = _a.resize, resize = _b === void 0 ? TextAreaResizeDirection.Both : _b, grow = _a.grow, elemProps = __rest(_a, ["resize", "grow"]);
-        return React.createElement(StyledTextArea, __assign({ ref: ref, as: Element, grow: grow, resize: resize }, elemProps));
+        },
     },
+    ...errorRing(error, theme),
+}), ({ resize, grow }) => ({
+    width: grow ? '100%' : undefined,
+    resize: grow ? TextAreaResizeDirection.Vertical : resize,
+}));
+export const TextArea = createComponent('textarea')({
+    displayName: 'TextArea',
+    Component: ({ resize = TextAreaResizeDirection.Both, grow, ...elemProps }, ref, Element) => React.createElement(StyledTextArea, Object.assign({ ref: ref, as: Element, grow: grow, resize: resize }, elemProps)),
     subComponents: {
-        ErrorType: ErrorType,
+        ErrorType,
         ResizeDirection: TextAreaResizeDirection,
     },
 });

package/dist/es6/text-input/lib/InputIconContainer.js

@@ -1,21 +1,15 @@
 import * as React from 'react';
 import styled from '@emotion/styled';
 import { space } from '@workday/canvas-kit-react/tokens';
-var Container = styled('div')(function (_a) {
-    var grow = _a.grow;
-    return ({
-        display: grow ? 'block' : 'inline-block',
-        position: 'relative',
-    });
-});
-var IconContainer = styled('div')({
+const Container = styled('div')(({ grow }) => ({
+    display: grow ? 'block' : 'inline-block',
+    position: 'relative',
+}));
+const IconContainer = styled('div')({
     position: 'absolute',
     top: space.xxs,
     right: space.xxs,
 });
-export var InputIconContainer = function (_a) {
-    var grow = _a.grow, children = _a.children, icon = _a.icon;
-    return (React.createElement(Container, { grow: grow },
-        children,
-        icon && React.createElement(IconContainer, null, icon)));
-};
+export const InputIconContainer = ({ grow, children, icon }) => (React.createElement(Container, { grow: grow },
+    children,
+    icon && React.createElement(IconContainer, null, icon)));

package/dist/es6/text-input/lib/TextInput.js

@@ -1,71 +1,58 @@
-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 { createComponent, ErrorType, errorRing, styled, } from '@workday/canvas-kit-react/common';
 import { borderRadius, inputColors, spaceNumbers, type } from '@workday/canvas-kit-react/tokens';
-var StyledTextInput = styled('input')(__assign(__assign({}, type.levels.subtext.large), { border: "1px solid " + inputColors.border, display: 'block', backgroundColor: inputColors.background, borderRadius: borderRadius.m, boxSizing: 'border-box', height: 40, transition: '0.2s box-shadow, 0.2s border-color', padding: spaceNumbers.xxs, margin: 0, '&::placeholder': {
+const StyledTextInput = styled('input')({
+    ...type.levels.subtext.large,
+    border: `1px solid ${inputColors.border}`,
+    display: 'block',
+    backgroundColor: inputColors.background,
+    borderRadius: borderRadius.m,
+    boxSizing: 'border-box',
+    height: 40,
+    transition: '0.2s box-shadow, 0.2s border-color',
+    padding: spaceNumbers.xxs,
+    margin: 0,
+    '&::placeholder': {
         color: inputColors.placeholder,
-    }, '&:hover': {
+    },
+    '&:hover': {
         borderColor: inputColors.hoverBorder,
-    }, '&:focus:not([disabled])': {
+    },
+    '&:focus:not([disabled])': {
         borderColor: inputColors.focusBorder,
-        boxShadow: "inset 0 0 0 1px " + inputColors.focusBorder,
+        boxShadow: `inset 0 0 0 1px ${inputColors.focusBorder}`,
         outline: 'none',
-    }, '&:disabled': {
+    },
+    '&:disabled': {
         backgroundColor: inputColors.disabled.background,
         borderColor: inputColors.disabled.border,
         color: inputColors.disabled.text,
         '&::placeholder': {
             color: inputColors.disabled.text,
         },
-    }, '::-ms-clear': {
+    },
+    '::-ms-clear': {
         display: 'none',
-    } }), function (_a) {
-    var width = _a.width;
-    return ({
-        minWidth: width || 280,
-        width: width,
-    });
-}, function (_a) {
-    var grow = _a.grow;
-    return grow && {
-        width: '100%',
-    };
-}, function (_a) {
-    var theme = _a.theme, error = _a.error;
-    return __assign({ '&:focus:not([disabled])': {
+    },
+}, ({ width }) => ({
+    minWidth: width || 280,
+    width,
+}), ({ grow }) => grow && {
+    width: '100%',
+}, ({ theme, error }) => {
+    return {
+        '&:focus:not([disabled])': {
             borderColor: theme.canvas.palette.common.focusOutline,
-            boxShadow: "inset 0 0 0 1px " + theme.canvas.palette.common.focusOutline,
+            boxShadow: `inset 0 0 0 1px ${theme.canvas.palette.common.focusOutline}`,
             outline: 'none',
-        } }, errorRing(error, theme));
+        },
+        ...errorRing(error, theme),
+    };
 });
-export var TextInput = createComponent('input')({
+export const TextInput = createComponent('input')({
     displayName: 'TextInput',
-    Component: function (_a, ref, Element) {
-        var grow = _a.grow, error = _a.error, width = _a.width, elemProps = __rest(_a, ["grow", "error", "width"]);
-        return (React.createElement(StyledTextInput, __assign({ type: "text", ref: ref, as: Element, grow: grow, error: error, width: width }, elemProps)));
-    },
+    Component: ({ grow, error, width, ...elemProps }, ref, Element) => (React.createElement(StyledTextInput, Object.assign({ type: "text", ref: ref, as: Element, grow: grow, error: error, width: width }, elemProps))),
     subComponents: {
-        ErrorType: ErrorType,
+        ErrorType,
     },
 });

package/dist/es6/toast/lib/Toast.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;
-};
 import React from 'react';
 import { createContainer } from '@workday/canvas-kit-react/common';
 import { Flex } from '@workday/canvas-kit-react/layout';
@@ -35,7 +13,7 @@ import { useToastModel } from './hooks/useToastModel';
  * @param mode Defines what aria attributes will be added to the main container
  * @param id Used to tie the Toast to Toast.Message for screen readers
  */
-var getAriaAttributes = function (mode, id) {
+const getAriaAttributes = (mode, id) => {
     switch (mode) {
         case 'dialog':
             return {
@@ -79,7 +57,7 @@ var getAriaAttributes = function (mode, id) {
  * );
  *```
  */
-export var Toast = createContainer('div')({
+export const Toast = createContainer('div')({
     displayName: 'Toast',
     modelHook: useToastModel,
     subComponents: {
@@ -112,7 +90,6 @@ export var Toast = createContainer('div')({
          */
         Link: ToastLink,
     },
-})(function (_a, _, model) {
-    var children = _a.children, elemProps = __rest(_a, ["children"]);
-    return (React.createElement(Popup.Card, __assign({ as: Flex, width: 360, padding: "0" }, getAriaAttributes(model.state.mode, model.state.id), { flexDirection: "row", gap: "xxxs" }, elemProps), children));
+})(({ children, ...elemProps }, _, model) => {
+    return (React.createElement(Popup.Card, Object.assign({ as: Flex, width: 360, padding: "0" }, getAriaAttributes(model.state.mode, model.state.id), { flexDirection: "row", gap: "xxxs" }, elemProps), children));
 });

package/dist/es6/toast/lib/ToastBody.js

@@ -1,32 +1,9 @@
-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 React from 'react';
 import { createComponent } from '@workday/canvas-kit-react/common';
 import { Flex } from '@workday/canvas-kit-react/layout';
-export var ToastBody = createComponent('div')({
+export const ToastBody = createComponent('div')({
     displayName: 'Toast.Body',
-    Component: function (_a, ref, Element) {
-        var children = _a.children, elemProps = __rest(_a, ["children"]);
-        return (React.createElement(Flex, __assign({ alignItems: "flex-start", flexDirection: "column", justifyContent: "center", paddingY: "s", ref: ref, as: Element, flexGrow: 1, gap: "xxxs" }, elemProps), children));
+    Component: ({ children, ...elemProps }, ref, Element) => {
+        return (React.createElement(Flex, Object.assign({ alignItems: "flex-start", flexDirection: "column", justifyContent: "center", paddingY: "s", ref: ref, as: Element, flexGrow: 1, gap: "xxxs" }, elemProps), children));
     },
 });

package/dist/es6/toast/lib/ToastCloseIcon.js

@@ -1,20 +1,9 @@
-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 { createComponent } from '@workday/canvas-kit-react/common';
 import { Popup } from '@workday/canvas-kit-react/popup';
-export var ToastCloseIcon = createComponent('button')({
+export const ToastCloseIcon = createComponent('button')({
     displayName: 'Toast.CloseIcon',
-    Component: function (elemProps, ref, Element) {
-        return (React.createElement(Popup.CloseIcon, __assign({ as: Element, ref: ref, size: "small", position: "relative" }, elemProps)));
+    Component: (elemProps, ref, Element) => {
+        return (React.createElement(Popup.CloseIcon, Object.assign({ as: Element, ref: ref, size: "small", position: "relative" }, elemProps)));
     },
 });

package/dist/es6/toast/lib/ToastIcon.js

@@ -1,20 +1,9 @@
-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 { createComponent } from '@workday/canvas-kit-react/common';
 import { SystemIcon } from '@workday/canvas-kit-react/icon';
-export var ToastIcon = createComponent('div')({
+export const ToastIcon = createComponent('div')({
     displayName: 'Toast.Icon',
-    Component: function (elemProps, ref, Element) {
-        return (React.createElement(SystemIcon, __assign({ colorHover: elemProps.color, marginY: "s", marginX: "xs", alignSelf: "start", ref: ref, as: Element }, elemProps)));
+    Component: (elemProps, ref, Element) => {
+        return (React.createElement(SystemIcon, Object.assign({ colorHover: elemProps.color, marginY: "s", marginX: "xs", alignSelf: "start", ref: ref, as: Element }, elemProps)));
     },
 });

package/dist/es6/toast/lib/ToastLink.js

@@ -1,32 +1,9 @@
-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 React from 'react';
 import { createComponent } from '@workday/canvas-kit-react/common';
 import { Hyperlink } from '@workday/canvas-kit-react/button';
-export var ToastLink = createComponent('a')({
+export const ToastLink = createComponent('a')({
     displayName: 'Toast.Link',
-    Component: function (_a, ref, Element) {
-        var children = _a.children, href = _a.href, elemProps = __rest(_a, ["children", "href"]);
-        return (React.createElement(Hyperlink, __assign({ ref: ref, href: href, as: Element }, elemProps), children));
+    Component: ({ children, href, ...elemProps }, ref, Element) => {
+        return (React.createElement(Hyperlink, Object.assign({ ref: ref, href: href, as: Element }, elemProps), children));
     },
 });

package/dist/es6/toast/lib/ToastMessage.js

@@ -1,32 +1,9 @@
-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 React from 'react';
 import { createSubcomponent } from '@workday/canvas-kit-react/common';
 import { useToastModel } from './hooks/useToastModel';
 import { Subtext } from '@workday/canvas-kit-react/text';
-export var ToastMessage = createSubcomponent('p')({
+export const ToastMessage = createSubcomponent('p')({
     modelHook: useToastModel,
-})(function (_a, Element, model) {
-    var children = _a.children, elemProps = __rest(_a, ["children"]);
-    return (React.createElement(Subtext, __assign({ size: "large", wordBreak: "break-word", marginY: "zero", id: model.state.id, as: Element }, elemProps), children));
+})(({ children, ...elemProps }, Element, model) => {
+    return (React.createElement(Subtext, Object.assign({ size: "large", wordBreak: "break-word", marginY: "zero", id: model.state.id, as: Element }, elemProps), children));
 });

package/dist/es6/toast/lib/hooks/useToastModel.js

@@ -1,16 +1,5 @@
-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 { createModelHook, useUniqueId } from '@workday/canvas-kit-react/common';
-export var useToastModel = createModelHook({
+export const useToastModel = createModelHook({
     defaultConfig: {
         /**
          * Sets the correct aria attributes for the Toast.
@@ -27,8 +16,11 @@ export var useToastModel = createModelHook({
          */
         id: '',
     },
-})(function (config) {
-    var id = useUniqueId(config.id);
-    var state = __assign(__assign({}, config), { id: id });
-    return { state: state, events: {} };
+})(config => {
+    const id = useUniqueId(config.id);
+    const state = {
+        ...config,
+        id,
+    };
+    return { state, events: {} };
 });

package/dist/es6/tokens/index.d.ts

@@ -410,6 +410,6 @@ export declare const canvas: {
     };
 };
 export * from '@workday/canvas-colors-web';
-export { borderRadius, colors, gradients, depth, space, spaceNumbers, type, fontFamily, monoFontFamily, BrandingColor, CanvasDepth, CanvasDepthValues, CSSProperties, };
-export type { CanvasBorderRadius, CanvasBorderRadiusKeys, CanvasBorderRadiusValues, CanvasColor, CanvasSpace, CanvasSpaceKeys, CanvasSpaceValues, CanvasSpaceNumberValues, CanvasSpaceNumbers, CanvasType, CanvasTypeProperties, CanvasTypeVariants, CanvasTypeHierarchy, };
+export { borderRadius, colors, gradients, depth, space, spaceNumbers, type, fontFamily, monoFontFamily, BrandingColor, };
+export type { CanvasBorderRadius, CanvasBorderRadiusKeys, CanvasBorderRadiusValues, CanvasColor, CanvasDepth, CanvasDepthValues, CanvasSpace, CanvasSpaceKeys, CanvasSpaceValues, CanvasSpaceNumberValues, CanvasSpaceNumbers, CanvasType, CanvasTypeProperties, CanvasTypeVariants, CanvasTypeHierarchy, CSSProperties, };
 //# sourceMappingURL=index.d.ts.map

package/dist/es6/tokens/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,MAAM,EAEN,SAAS,EAKV,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAC,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,wBAAwB,EAAC,MAAM,cAAc,CAAC;AAChH,OAAO,EAAC,aAAa,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAC,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,KAAK,EACL,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAC,IAAI,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE1C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBlB,CAAC;AAEF,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EACL,YAAY,EACZ,MAAM,EACN,SAAS,EACT,KAAK,EACL,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,cAAc,EACd,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,aAAa,GACd,CAAC;AAEF,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,WAAW,EACX,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,GACpB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,MAAM,EAEN,SAAS,EAKV,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAC,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,wBAAwB,EAAC,MAAM,cAAc,CAAC;AAChH,OAAO,EAAC,aAAa,EAAE,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAC,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,KAAK,EACL,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAC,IAAI,EACV,UAAU,EACV,cAAc,EACd,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE1C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBlB,CAAC;AAEF,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EACL,YAAY,EACZ,MAAM,EACN,SAAS,EACT,KAAK,EACL,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,cAAc,EACd,aAAa,GACd,CAAC;AAEF,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,GACd,CAAA"}

package/dist/es6/tokens/index.js

@@ -4,22 +4,22 @@ import { BrandingColor } from './lib/colors.types';
 import { depth } from './lib/depth';
 import { space, spaceNumbers, } from './lib/space';
 import { type, fontFamily, monoFontFamily, } from './lib/type';
-export var canvas = {
-    buttonColors: buttonColors,
-    chartingColorOffsets: chartingColorOffsets,
-    chartingColors: chartingColors,
-    colors: colors,
-    commonColors: commonColors,
-    depth: depth,
-    fontFamily: fontFamily,
-    gradients: gradients,
-    iconColors: iconColors,
-    inputColors: inputColors,
-    monoFontFamily: monoFontFamily,
-    space: space,
-    statusColors: statusColors,
-    type: type,
-    typeColors: typeColors,
+export const canvas = {
+    buttonColors,
+    chartingColorOffsets,
+    chartingColors,
+    colors,
+    commonColors,
+    depth,
+    fontFamily,
+    gradients,
+    iconColors,
+    inputColors,
+    monoFontFamily,
+    space,
+    statusColors,
+    type,
+    typeColors,
 };
 export * from '@workday/canvas-colors-web';
 export { borderRadius, colors, gradients, depth, space, spaceNumbers, type, fontFamily, monoFontFamily, BrandingColor, };

package/dist/es6/tokens/lib/depth.js

@@ -20,7 +20,7 @@
  * ```
  *
  */
-export var depth = {
+export const depth = {
     none: {
         boxShadow: 'none',
     },

package/dist/es6/tokens/lib/radius.js

@@ -1,5 +1,5 @@
 /** An object of border-radius keys and px values (strings and numbers) */
-export var borderRadius = {
+export const borderRadius = {
     zero: '0px',
     s: '2px',
     m: '4px',

package/dist/es6/tokens/lib/space.js

@@ -1,5 +1,5 @@
 /** An object of space keys and px values (strings) */
-export var space = {
+export const space = {
     zero: '0px',
     xxxs: '4px',
     xxs: '8px',
@@ -18,7 +18,7 @@ export var space = {
  * @example
  * const buttonPaddingLeft = spaceNumbers.s + iconSize;
  */
-export var spaceNumbers = {
+export const spaceNumbers = {
     zero: 0,
     xxxs: 4,
     xxs: 8,

package/dist/es6/tokens/lib/type/fontFamilies.js

@@ -1,12 +1,12 @@
 // prettier-ignore
 //@ts-ignore
-var canvasObject = typeof window !== 'undefined' && window.workday && window.workday.canvas && window.workday.canvas;
-var inheritFont = typeof canvasObject !== 'undefined' && canvasObject.inheritFontFamily;
-var inheritMonoFont = typeof canvasObject !== 'undefined' && canvasObject.inheritMonoFontFamily;
-export var fontFamily = inheritFont
+const canvasObject = typeof window !== 'undefined' && window.workday && window.workday.canvas && window.workday.canvas;
+const inheritFont = typeof canvasObject !== 'undefined' && canvasObject.inheritFontFamily;
+const inheritMonoFont = typeof canvasObject !== 'undefined' && canvasObject.inheritMonoFontFamily;
+export const fontFamily = inheritFont
     ? 'inherit'
     : '"Roboto", "Helvetica Neue", "Helvetica", Arial, sans-serif';
-export var monoFontFamily = inheritMonoFont === true
+export const monoFontFamily = inheritMonoFont === true
     ? 'inherit'
     : inheritMonoFont || '"Roboto Mono", "Courier New", Courier, monospace';
 /** ### Font Family Tokens
@@ -30,7 +30,7 @@ export var monoFontFamily = inheritMonoFont === true
  * );
  * ```
  */
-export var fontFamilies = {
+export const fontFamilies = {
     default: fontFamily,
     monospace: monoFontFamily,
 };

package/dist/es6/tokens/lib/type/fontSizes.js

@@ -20,7 +20,7 @@
  * );
  * ```
  */
-export var fontSizes = {
+export const fontSizes = {
     10: '0.625rem',
     12: '0.75rem',
     14: '0.875rem',

package/dist/es6/tokens/lib/type/fontWeights.js

@@ -18,7 +18,7 @@
  * );
  * ```
  */
-export var fontWeights = {
+export const fontWeights = {
     regular: 400,
     medium: 500,
     bold: 700,