@workday/canvas-kit-react 8.0.0-alpha.253-next.22 → 8.0.0-alpha.428-next.2

package/dist/commonjs/combobox/lib/useComboboxModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComboboxModel.d.ts","sourceRoot":"","sources":["../../../../combobox/lib/useComboboxModel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;oBAIN,MAAM,WAAW,CAAC,gBAAgB,CAAC;;sBAAnC,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;;;;oBAAnC,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;sBAAnC,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;;EAYrD,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;oBA1BT,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgDnD;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;QASH;;WAEG;wBACa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA/DN,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;oBAAnC,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgDnD;;;OAGG;;;IASH;;OAEG;oBACa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAftB;;;WAGG;;;;QASH;;WAEG;wBACa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBA/DN,MAAM,WAAW,CAAC,gBAAgB,CAAC;;;;EAqErD,CAAC"}

package/dist/commonjs/combobox/lib/useComboboxModel.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useComboboxModel = exports.useInputModel = void 0;
+const react_1 = __importDefault(require("react"));
+const common_1 = require("@workday/canvas-kit-react/common");
+const menu_1 = require("@workday/canvas-kit-react/menu");
+/**
+ * An input model can be used by compound components that need to work with form fields. Some form
+ * libraries use `onChange` and `value` to update a form object. Others use `onChange` and `ref` to
+ * avoid rerendering. Also autocomplete and test libraries may use the `value` `HTMLInputElement`
+ * property. We need to normalize these use cases so subcomponents can have correct data and all
+ * use-cases are supported.
+ */
+exports.useInputModel = common_1.createModelHook({
+    defaultConfig: {
+        value: undefined,
+        onChange(event) {
+            return;
+        },
+    },
+})(config => {
+    const inputRef = react_1.default.createRef();
+    return {
+        onChange: config.onChange,
+        state: { value: config.value, inputRef },
+        events: {},
+    };
+});
+/**
+ * `ComboboxModel` extends the {@link ListModel} and the {@link InputModel}. Selecting items from
+ * the menu will dispatch an
+ * [input](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event) event on the
+ * input which should work with form libraries, automation, and autofill.
+ *
+ * ```tsx
+ * const model = useComboboxModel()
+ *
+ * <Combobox model={model}>{Combobox child components}</Combobox>
+ * ```
+ */
+exports.useComboboxModel = common_1.createModelHook({
+    defaultConfig: {
+        ...exports.useInputModel.defaultConfig,
+        ...menu_1.useMenuModel.defaultConfig,
+    },
+    requiredConfig: {
+        ...exports.useInputModel.requiredConfig,
+        ...menu_1.useMenuModel.requiredConfig,
+    },
+})(config => {
+    const input = exports.useInputModel(config);
+    const menu = menu_1.useMenuModel(menu_1.useMenuModel.mergeConfig(config, {
+        shouldVirtualize: true,
+        onSelect({ id }) {
+            common_1.dispatchInputEvent(menu.state.targetRef.current, id);
+        },
+    }));
+    const [width, setWidth] = react_1.default.useState(0);
+    const state = {
+        /**
+         * The width of the combobox input. This is used to make sure the UI renders the menu the same
+         * width as the input.
+         */
+        width,
+        ...input.state,
+        ...menu.state,
+    };
+    const events = {
+        ...input.events,
+        ...menu.events,
+        /**
+         * Change the width of the menu. Usually this is set to the width of the input.
+         */
+        setWidth(width) {
+            setWidth(width);
+        },
+    };
+    return { ...menu, ...input, state, events };
+});

package/dist/commonjs/common/lib/CanvasProvider.js

@@ -1,28 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -42,39 +18,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CanvasProvider = void 0;
-var React = __importStar(require("react"));
-var react_1 = require("@emotion/react");
-var InputProvider_1 = require("./InputProvider");
-var theming_1 = require("./theming");
-var CanvasProvider = /** @class */ (function (_super) {
-    __extends(CanvasProvider, _super);
-    function CanvasProvider() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    CanvasProvider.prototype.render = function () {
-        var _a = this.props, children = _a.children, theme = _a.theme, elemProps = __rest(_a, ["children", "theme"]);
+const React = __importStar(require("react"));
+const react_1 = require("@emotion/react");
+const InputProvider_1 = require("./InputProvider");
+const theming_1 = require("./theming");
+class CanvasProvider extends React.Component {
+    render() {
+        const { children, theme, ...elemProps } = this.props;
         return (React.createElement(react_1.ThemeProvider, { theme: theme },
             React.createElement(InputProvider_1.InputProvider, null),
-            React.createElement("div", __assign({ dir: (theme.canvas && theme.canvas.direction) || theming_1.defaultCanvasTheme.direction }, elemProps), children)));
-    };
-    CanvasProvider.defaultProps = {
-        theme: {
-            canvas: theming_1.defaultCanvasTheme,
-        },
-    };
-    return CanvasProvider;
-}(React.Component));
+            React.createElement("div", Object.assign({ dir: (theme.canvas && theme.canvas.direction) || theming_1.defaultCanvasTheme.direction }, elemProps), children)));
+    }
+}
 exports.CanvasProvider = CanvasProvider;
+CanvasProvider.defaultProps = {
+    theme: {
+        canvas: theming_1.defaultCanvasTheme,
+    },
+};

package/dist/commonjs/common/lib/EllipsisText.d.ts

@@ -1,5 +1,4 @@
 import { CSSObject } from '@emotion/styled';
-import { ElementComponent } from '..';
 export declare const ellipsisStyles: CSSObject;
-export declare const EllipsisText: ElementComponent<"span", {}>;
+export declare const EllipsisText: import("./utils").ElementComponent<"span", unknown>;
 //# sourceMappingURL=EllipsisText.d.ts.map

package/dist/commonjs/common/lib/EllipsisText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EllipsisText.d.ts","sourceRoot":"","sources":["../../../../common/lib/EllipsisText.tsx"],"names":[],"mappings":"AAAA,OAAe,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAC,gBAAgB,EAAC,MAAM,IAAI,CAAC;AAEpC,eAAO,MAAM,cAAc,EAAE,SAI5B,CAAC;AAGF,eAAO,MAAM,YAAY,8BAA0E,CAAC"}
+{"version":3,"file":"EllipsisText.d.ts","sourceRoot":"","sources":["../../../../common/lib/EllipsisText.tsx"],"names":[],"mappings":"AACA,OAAe,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAIlD,eAAO,MAAM,cAAc,EAAE,SAI5B,CAAC;AAIF,eAAO,MAAM,YAAY,qDAKvB,CAAC"}

package/dist/commonjs/common/lib/EllipsisText.js

@@ -4,11 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EllipsisText = exports.ellipsisStyles = void 0;
-var styled_1 = __importDefault(require("@emotion/styled"));
+const react_1 = __importDefault(require("react"));
+const styled_1 = __importDefault(require("@emotion/styled"));
+const utils_1 = require("./utils");
 exports.ellipsisStyles = {
     whiteSpace: 'nowrap',
     textOverflow: 'ellipsis',
     overflow: 'hidden',
 };
-// Recast as an `ElementComponent` due to better type support for `as` and `ref`
-exports.EllipsisText = styled_1.default('span')(exports.ellipsisStyles);
+const StyledEllipsisComponent = styled_1.default('span')(exports.ellipsisStyles);
+exports.EllipsisText = utils_1.createComponent('span')({
+    displayName: 'EllipsisText',
+    Component(elemProps = {}, ref, Element) {
+        return react_1.default.createElement(StyledEllipsisComponent, Object.assign({ as: Element, ref: ref }, elemProps));
+    },
+});

package/dist/commonjs/common/lib/InputProvider.d.ts

@@ -57,7 +57,7 @@ export declare class InputProvider extends React.Component<React.PropsWithChildr
     setIntent(event: InputEvent): void;
     eventBuffer(event: Event): void;
     detectScrolling(event: React.MouseEvent): void;
-    render(): number | true | React.ReactElement<any, string | ((props: any) => React.ReactElement<any, any> | null) | (new (props: any) => React.Component<any, any, any>)> | React.ReactFragment | null;
+    render(): string | number | true | React.ReactElement<any, string | React.JSXElementConstructor<any>> | React.ReactFragment | null;
 }
 export default InputProvider;
 //# sourceMappingURL=InputProvider.d.ts.map

package/dist/commonjs/common/lib/InputProvider.js

@@ -1,17 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -31,10 +18,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InputProvider = exports.inputEventMap = exports.InputEventType = exports.InputType = void 0;
-var React = __importStar(require("react"));
+const React = __importStar(require("react"));
 var InputType;
 (function (InputType) {
     InputType["Initial"] = "initial";
@@ -56,29 +42,29 @@ var InputEventType;
     InputEventType["TouchStart"] = "touchstart";
 })(InputEventType = exports.InputEventType || (exports.InputEventType = {}));
 // form input types
-var formInputs = ['input', 'select', 'textarea'];
+const formInputs = ['input', 'select', 'textarea'];
 // list of modifier keys commonly used with the mouse and
 // can be safely ignored to prevent false keyboard detection
-var ignoreKeys = ['Shift', 'Control', 'Alt', 'Meta', 'OS'];
+const ignoreKeys = ['Shift', 'Control', 'Alt', 'Meta', 'OS'];
 // mapping of events to input types
-exports.inputEventMap = (_a = {},
-    _a[InputEventType.KeyDown] = InputType.Keyboard,
-    _a[InputEventType.KeyUp] = InputType.Keyboard,
-    _a[InputEventType.MouseDown] = InputType.Mouse,
-    _a[InputEventType.MouseMove] = InputType.Mouse,
-    _a[InputEventType.Wheel] = InputType.Mouse,
-    _a[InputEventType.MouseWheel] = InputType.Mouse,
-    _a[InputEventType.PointerDown] = InputType.Pointer,
-    _a[InputEventType.PointerMove] = InputType.Pointer,
-    _a[InputEventType.TouchStart] = InputType.Touch,
-    _a);
+exports.inputEventMap = {
+    [InputEventType.KeyDown]: InputType.Keyboard,
+    [InputEventType.KeyUp]: InputType.Keyboard,
+    [InputEventType.MouseDown]: InputType.Mouse,
+    [InputEventType.MouseMove]: InputType.Mouse,
+    [InputEventType.Wheel]: InputType.Mouse,
+    [InputEventType.MouseWheel]: InputType.Mouse,
+    [InputEventType.PointerDown]: InputType.Pointer,
+    [InputEventType.PointerMove]: InputType.Pointer,
+    [InputEventType.TouchStart]: InputType.Touch,
+};
 // map of IE 10 pointer events
-var pointerMap = {
+const pointerMap = {
     2: InputType.Touch,
     3: InputType.Touch,
     4: InputType.Mouse,
 };
-var getPointerType = function (event) {
+const getPointerType = (event) => {
     if (typeof event.pointerType === 'number') {
         return pointerMap[event.pointerType];
     }
@@ -92,8 +78,8 @@ var getPointerType = function (event) {
 };
 // detect version of mouse wheel event to use
 // via https://developer.mozilla.org/en-US/docs/Web/Events/wheel
-var detectWheel = function () {
-    var wheelType;
+const detectWheel = () => {
+    let wheelType;
     // Modern browsers support "wheel"
     /* istanbul ignore else for coverage */
     if ('onwheel' in document.createElement('div')) {
@@ -105,17 +91,17 @@ var detectWheel = function () {
     }
     return wheelType;
 };
-var supportsPassive = function () {
-    var supportsPassive;
+const supportsPassive = () => {
+    let supportsPassive;
     try {
         /* istanbul ignore next function for coverage */
-        var opts = Object.defineProperty({}, 'passive', {
-            get: function () {
+        const opts = Object.defineProperty({}, 'passive', {
+            get: () => {
                 supportsPassive = true;
             },
         });
         /* istanbul ignore next function for coverage */
-        var stub = function () {
+        const stub = () => {
             return;
         };
         window.addEventListener('test', stub, opts);
@@ -130,20 +116,19 @@ var supportsPassive = function () {
 /**
  * This component takes heavy inspiration from what-input (https://github.com/ten1seven/what-input)
  */
-var InputProvider = /** @class */ (function (_super) {
-    __extends(InputProvider, _super);
-    function InputProvider(props) {
-        var _this = _super.call(this, props) || this;
-        _this.isBuffering = false;
-        _this.isScrolling = false; // Unused if props.provideIntent is not defined
-        _this.mousePosX = null; // Unused if props.provideIntent is not defined
-        _this.mousePosY = null; // Unused if props.provideIntent is not defined
-        _this.deferInputTracking = false; // True if there is another input provider
+class InputProvider extends React.Component {
+    constructor(props) {
+        super(props);
+        this.isBuffering = false;
+        this.isScrolling = false; // Unused if props.provideIntent is not defined
+        this.mousePosX = null; // Unused if props.provideIntent is not defined
+        this.mousePosY = null; // Unused if props.provideIntent is not defined
+        this.deferInputTracking = false; // True if there is another input provider
         // Need to remember how it component was mounted so we ensure listener removal
-        _this.provideIntent = _this.props.provideIntent;
+        this.provideIntent = this.props.provideIntent;
         // check for sessionStorage support
         // then check for session variables and use if available
-        var storedInput, storedIntent;
+        let storedInput, storedIntent;
         try {
             storedInput = window.sessionStorage.getItem('what-input');
             storedIntent = window.sessionStorage.getItem('what-intent');
@@ -152,14 +137,13 @@ var InputProvider = /** @class */ (function (_super) {
             /* istanbul ignore next line for coverage */
             console.warn('Failed to retrieve input status from session storage' + e);
         }
-        _this.currentInput = storedInput || InputType.Initial;
-        _this.currentIntent = storedIntent || InputType.Initial;
-        _this.setInput = _this.setInput.bind(_this);
-        _this.setIntent = _this.setIntent.bind(_this);
-        _this.eventBuffer = _this.eventBuffer.bind(_this);
-        return _this;
+        this.currentInput = storedInput || InputType.Initial;
+        this.currentIntent = storedIntent || InputType.Initial;
+        this.setInput = this.setInput.bind(this);
+        this.setIntent = this.setIntent.bind(this);
+        this.eventBuffer = this.eventBuffer.bind(this);
     }
-    InputProvider.prototype.getContainer = function (container) {
+    getContainer(container) {
         // Note: Not a default prop because using document when defining default props causes errors during SSR
         if (!container) {
             return document.body;
@@ -174,8 +158,8 @@ var InputProvider = /** @class */ (function (_super) {
             }
         }
         return container;
-    };
-    InputProvider.prototype.componentDidMount = function () {
+    }
+    componentDidMount() {
         // Check for passive event listener support
         this.supportsPassive = supportsPassive();
         if (this.getContainer(this.props.container).closest('[data-whatinput]')) {
@@ -184,9 +168,9 @@ var InputProvider = /** @class */ (function (_super) {
         }
         this.updateAttributes();
         this.enableListeners(true);
-    };
-    InputProvider.prototype.updateAttributes = function () {
-        var intent = this.provideIntent ? this.currentIntent : null;
+    }
+    updateAttributes() {
+        const intent = this.provideIntent ? this.currentIntent : null;
         this.getContainer(this.props.container).setAttribute('data-whatinput', this.currentInput);
         if (intent) {
             this.getContainer(this.props.container).setAttribute('data-whatintent', intent);
@@ -199,8 +183,8 @@ var InputProvider = /** @class */ (function (_super) {
             /* istanbul ignore next line for coverage */
             console.warn('Failed to set input status in session storage' + e);
         }
-    };
-    InputProvider.prototype.componentWillUnmount = function () {
+    }
+    componentWillUnmount() {
         if (this.deferInputTracking) {
             return;
         }
@@ -208,8 +192,8 @@ var InputProvider = /** @class */ (function (_super) {
         this.getContainer(this.props.container).removeAttribute('data-whatintent');
         window.clearTimeout(this.eventTimer);
         this.enableListeners(false);
-    };
-    InputProvider.prototype.enableListeners = function (enable) {
+    }
+    enableListeners(enable) {
         /* istanbul ignore if for coverage */
         if (typeof window === 'undefined') {
             return;
@@ -217,10 +201,10 @@ var InputProvider = /** @class */ (function (_super) {
         // `pointermove`, `MSPointerMove`, `mousemove` and mouse wheel event binding
         // can only demonstrate potential, but not actual, interaction
         // and are treated separately
-        var options = this.supportsPassive
+        const options = this.supportsPassive
             ? { passive: true } // fixes Type '{ passive: boolean; }' has no properties in common with type 'EventListenerOptions'.  TS2345
             : false;
-        var fn = enable ? window.addEventListener : window.removeEventListener;
+        const fn = enable ? window.addEventListener : window.removeEventListener;
         // pointer events (mouse, pen, touch)
         if (window.PointerEvent) {
             fn('pointerdown', this.setInput);
@@ -247,21 +231,21 @@ var InputProvider = /** @class */ (function (_super) {
         // keyboard events
         fn('keydown', this.eventBuffer);
         fn('keyup', this.eventBuffer);
-    };
-    InputProvider.prototype.setInput = function (event) {
+    }
+    setInput(event) {
         // only execute if the event buffer timer isn't running
         /* istanbul ignore if for coverage */
         if (this.isBuffering) {
             return;
         }
-        var eventKey = 'key' in event ? event.key : undefined;
-        var eventType = event.type;
-        var value = exports.inputEventMap[eventType];
+        const eventKey = 'key' in event ? event.key : undefined;
+        const eventType = event.type;
+        let value = exports.inputEventMap[eventType];
         if (value === InputType.Pointer) {
             value = getPointerType(event);
         }
-        var ignoreMatch = eventKey ? ignoreKeys.indexOf(eventKey) === -1 : undefined;
-        var shouldUpdate = (value === InputType.Keyboard && eventKey && ignoreMatch) ||
+        const ignoreMatch = eventKey ? ignoreKeys.indexOf(eventKey) === -1 : undefined;
+        const shouldUpdate = (value === InputType.Keyboard && eventKey && ignoreMatch) ||
             value === InputType.Mouse ||
             value === InputType.Touch;
         if (this.currentInput !== value && shouldUpdate) {
@@ -270,8 +254,8 @@ var InputProvider = /** @class */ (function (_super) {
         }
         if (this.currentIntent !== value && shouldUpdate && this.provideIntent) {
             // preserve intent for keyboard typing in form fields
-            var activeElem = document.activeElement;
-            var notFormInput = activeElem &&
+            const activeElem = document.activeElement;
+            const notFormInput = activeElem &&
                 activeElem.nodeName &&
                 formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1;
             /* istanbul ignore else for coverage */
@@ -280,37 +264,36 @@ var InputProvider = /** @class */ (function (_super) {
                 this.updateAttributes();
             }
         }
-    };
+    }
     // updates input intent for `mousemove` and `pointermove`
-    InputProvider.prototype.setIntent = function (event) {
+    setIntent(event) {
         // test to see if `mousemove` happened relative to the screen to detect scrolling versus mousemove
         this.detectScrolling(event);
         // only execute if the event buffer timer isn't running
         // or scrolling isn't happening
         /* istanbul ignore else for coverage */
         if (!this.isBuffering && !this.isScrolling) {
-            var eventType = event.type;
-            var value = exports.inputEventMap[eventType];
+            const eventType = event.type;
+            let value = exports.inputEventMap[eventType];
             if (value === InputType.Pointer) {
                 value = getPointerType(event);
             }
             this.currentIntent = value;
             this.updateAttributes();
         }
-    };
+    }
     // buffers events that frequently also fire mouse events
-    InputProvider.prototype.eventBuffer = function (event) {
-        var _this = this;
+    eventBuffer(event) {
         // set the current input
         this.setInput(event);
         window.clearTimeout(this.eventTimer);
         this.isBuffering = true;
         /* istanbul ignore next function for coverage */
-        this.eventTimer = window.setTimeout(function () {
-            _this.isBuffering = false;
+        this.eventTimer = window.setTimeout(() => {
+            this.isBuffering = false;
         }, 100);
-    };
-    InputProvider.prototype.detectScrolling = function (event) {
+    }
+    detectScrolling(event) {
         if (this.mousePosX !== event.screenX || this.mousePosY !== event.screenY) {
             this.isScrolling = false;
             this.mousePosX = event.screenX;
@@ -319,11 +302,10 @@ var InputProvider = /** @class */ (function (_super) {
         else {
             this.isScrolling = true;
         }
-    };
-    InputProvider.prototype.render = function () {
+    }
+    render() {
         return this.props.children || null;
-    };
-    return InputProvider;
-}(React.Component));
+    }
+}
 exports.InputProvider = InputProvider;
 exports.default = InputProvider;

package/dist/commonjs/common/lib/parts/_brand-assets.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.miniWdayLogoBlue = exports.wdayLogoWhite = exports.wdayLogoBlue = exports.dubLogoWhite = exports.dubLogoBlue = void 0;
-var CDN_URI = 'https://design.workday.com/images/';
-exports.dubLogoBlue = "<img src=\"" + CDN_URI + "ck-dub-logo-blue.svg\" alt=\"\">";
-exports.dubLogoWhite = "<img src=\"" + CDN_URI + "ck-dub-logo-white.svg\" alt=\"\">";
-exports.wdayLogoBlue = "<img src=\"" + CDN_URI + "ck-wday-logo-blue.svg\" alt=\"\">";
-exports.wdayLogoWhite = "<img src=\"" + CDN_URI + "ck-wday-logo-white.svg\" alt=\"\">";
-exports.miniWdayLogoBlue = "<img src=\"" + CDN_URI + "ck-mini-wday-logo-blue.svg\" alt=\"\">";
+const CDN_URI = 'https://design.workday.com/images/';
+exports.dubLogoBlue = `<img src="${CDN_URI}ck-dub-logo-blue.svg" alt="">`;
+exports.dubLogoWhite = `<img src="${CDN_URI}ck-dub-logo-white.svg" alt="">`;
+exports.wdayLogoBlue = `<img src="${CDN_URI}ck-wday-logo-blue.svg" alt="">`;
+exports.wdayLogoWhite = `<img src="${CDN_URI}ck-wday-logo-white.svg" alt="">`;
+exports.miniWdayLogoBlue = `<img src="${CDN_URI}ck-mini-wday-logo-blue.svg" alt="">`;