@spaced-out/ui-design-system 0.4.15 → 0.5.1

package/lib/components/TokenListInput/TokenListInput.js

@@ -68,12 +68,17 @@ function TokenListInput(props) {
     context
   } = (0, _react2.useFloating)({
     open: true,
+    // @ts-ignore - TS2322 - Type 'string' is not assignable to type 'Strategy | undefined'.
     strategy: _ButtonDropdown.STRATEGY_TYPE.absolute,
+    // @ts-ignore - TS2322 - Type 'string' is not assignable to type 'Placement | undefined'.
     placement: _ButtonDropdown.ANCHOR_POSITION_TYPE.bottomStart,
     whileElementsMounted: _react2.autoUpdate,
     middleware: [(0, _react2.flip)(), (0, _react2.offset)(parseInt(_space.spaceXXSmall))]
   });
+
+  // @ts-ignore - TS2554 - Expected 1 arguments, but got 0.
   const inputRef = React.useRef();
+  // @ts-ignore - TS2345 - Argument of type '(ReferenceType & ReferenceType) | null' is not assignable to parameter of type 'HTMLElement | null | undefined'.
   const dropdownWidth = (0, _hooks.useReferenceElementWidth)(refs.reference?.current);
   const onOpenToggle = isOpen => {
     if (isOpen) {
@@ -90,11 +95,12 @@ function TokenListInput(props) {
     }
   }, [focusOnMount]);
   const addValue = value => {
+    // @ts-ignore - TS2339 - Property 'disabled' does not exist on type 'T'.
     if (locked || !value || value.disabled) {
       return; // Prevent adding values when disabled or locked
     }
     onInputChange?.('');
-    // $FlowFixMe[incompatible-use] - token has key property
+    // @ts-ignore - TS2339 - Property 'key' does not exist on type 'T'. | TS2339 - Property 'key' does not exist on type 'T'.
     const existingToken = values.find(token => token.key === value.key);
     if (!existingToken) {
       onChange([...values, value]);
@@ -121,14 +127,14 @@ function TokenListInput(props) {
         event.preventDefault();
         let firstOption = null;
         if (menu?.options && menu.options.length > 0) {
-          //$FlowFixMe
+          // @ts-ignore - TS2345 - Argument of type 'T[]' is not assignable to parameter of type 'V[]'.
           firstOption = (0, _tokenListInput.getFirstOption)(menu.options);
         } else if (menu?.groupTitleOptions && menu.groupTitleOptions.length > 0) {
-          //$FlowFixMe
+          // @ts-ignore - TS2345 - Argument of type 'TokenGroupTitleOption<T>[]' is not assignable to parameter of type 'Group<V>[]'.
           firstOption = (0, _tokenListInput.getFirstOptionFromGroup)(menu.groupTitleOptions);
         }
         if (firstOption) {
-          //$FlowFixMe
+          // @ts-ignore - TS2345 - Argument of type 'V' is not assignable to parameter of type 'T'.
           addValue(firstOption);
         }
       }
@@ -175,9 +181,11 @@ function TokenListInput(props) {
         if (!isOpen) {
           onOpen();
         }
+        // @ts-ignore - TS2345 - Argument of type 'FocusEvent<HTMLDivElement, Element>' is not assignable to parameter of type 'SyntheticEvent<HTMLInputElement, Event>'.
         onInputFocus?.(e);
       },
       onBlur: e => {
+        // @ts-ignore - TS2345 - Argument of type 'FocusEvent<HTMLDivElement, Element>' is not assignable to parameter of type 'SyntheticEvent<HTMLInputElement, Event>'.
         onInputBlur?.(e);
       },
       className: (0, _classify.default)(_TokenListInputModule.default.box, {
@@ -186,7 +194,9 @@ function TokenListInput(props) {
         [_TokenListInputModule.default.small]: size === 'small',
         [_TokenListInputModule.default.withError]: error,
         [_TokenListInputModule.default.inputLocked]: locked
-      }, classNames?.box),
+      }, classNames?.box)
+      // @ts-ignore - TS2322 - Type '((node: ReferenceType | null) => void) & ((node: ReferenceType | null) => void)' is not assignable to type '{ current: HTMLElement | null | undefined; }'.
+      ,
       ref: (0, _mergeRefs.mergeRefs)([refs.setReference, triggerRef])
     }, /*#__PURE__*/React.createElement(_TokenValueChips.TokenValueChips, {
       values: values,
@@ -194,7 +204,11 @@ function TokenListInput(props) {
       disabled: disabled,
       locked: locked,
       onDismiss: removeValue
-    }), !hideInput && /*#__PURE__*/React.createElement("input", _extends({}, inputProps, {
+    }), !hideInput &&
+    /*#__PURE__*/
+    // @ts-ignore - TS2345 - Argument of type 'InputProps' is not assignable to parameter of type 'InputProps'.
+    React.createElement("input", _extends({}, inputProps, {
+      // @ts-ignore - TS2322 - Type 'RefObject<HTMLInputElement | null | undefined>' is not assignable to type 'Ref<HTMLInputElement> | undefined'.
       ref: inputRef,
       type: "text",
       readOnly: locked,
@@ -232,10 +246,14 @@ function TokenListInput(props) {
     }, helperText) : helperText), !locked && isOpen && menu && /*#__PURE__*/React.createElement(_react2.FloatingPortal, null, /*#__PURE__*/React.createElement(_react2.FloatingFocusManager, {
       modal: false,
       context: context,
-      returnFocus: false,
+      returnFocus: false
+      // @ts-ignore - TS2322 - Type 'MutableRefObject<ReferenceType | null> & MutableRefObject<ReferenceType | null>' is not assignable to type 'number | MutableRefObject<HTMLElement | null> | undefined'.
+      ,
       initialFocus: refs.reference
     }, /*#__PURE__*/React.createElement("div", {
-      className: _TokenListInputModule.default.menuWrapper,
+      className: _TokenListInputModule.default.menuWrapper
+      // @ts-ignore - TS2322 - Type '((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void)' is not assignable to type '{ current: HTMLElement | null | undefined; }'.
+      ,
       ref: (0, _mergeRefs.mergeRefs)([refs.setFloating, boundaryRef]),
       style: {
         position: strategy,
@@ -256,8 +274,7 @@ function TokenListInput(props) {
         if (values.length >= limit) {
           return;
         }
-        // $FlowFixMe[incompatible-call] option from Menu is MenuOption but addValue expects T
-        // $FlowFixMe[prop-missing] MenuOption properties are missing in T
+        // @ts-ignore - TS2345 - Argument of type 'MenuOption' is not assignable to parameter of type 'T'.
         addValue(option);
         clickAway();
         inputRef.current?.focus();

package/lib/components/TokenListInput/TokenListInput.stories.d.ts

@@ -0,0 +1,379 @@
+import * as React from 'react';
+import type { MenuOption } from '../Menu';
+import type { Props } from './TokenListInput';
+import { TokenListInput } from './TokenListInput';
+declare const _default: {
+    tags: string[];
+    title: string;
+    component: typeof TokenListInput;
+    argTypes: {
+        classNames: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        clickAwayRef: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        disabled: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        elevation: {
+            description: string;
+            control: {
+                type: string;
+            };
+            options: unknown[];
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        error: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        errorText: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        focusOnMount: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        helperText: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        placeholder: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        inputValue: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        inputPlaceholder: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        limit: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        isLoading: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        locked: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onChange: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onInputBlur: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onInputChange: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onInputFocus: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        size: {
+            description: string;
+            options: string[];
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        tabIndex: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        values: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        menu: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onMenuOpen: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        onMenuClose: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        resolveTokenValue: {
+            description: string;
+            control: boolean;
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        inputProps: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+type TokenListOption = MenuOption & {
+    arbitrary?: boolean;
+};
+export declare const _TokenListInput: {
+    (args: Props<TokenListOption>): React.JSX.Element;
+    args: {
+        classNames: {
+            wrapper: string;
+        };
+    };
+};
+export declare const _TokenListInputWithError: (args: Props<TokenListOption>) => React.JSX.Element;
+export declare const _TokenListInputLocked: {
+    (args: Props<TokenListOption>): React.JSX.Element;
+    args: {
+        locked: boolean;
+    };
+};
+export declare const _TokenListInputDisabled: {
+    (args: Props<TokenListOption>): React.JSX.Element;
+    args: {
+        classNames: {
+            wrapper: string;
+        };
+        disabled: boolean;
+    };
+};
+export declare const _TokenListInputGroup: {
+    (args: Props<TokenListOption>): React.JSX.Element;
+    args: {
+        menu: {
+            groupTitleOptions: ({
+                groupTitle: () => React.JSX.Element;
+                options: {
+                    key: string;
+                    iconLeft: string;
+                    label: string;
+                }[];
+                showLineDivider?: undefined;
+            } | {
+                showLineDivider: boolean;
+                groupTitle: React.ReactNode;
+                options: {
+                    key: string;
+                    iconLeft: string;
+                    label: string;
+                }[];
+            })[];
+        };
+    };
+};
+export declare const _CustomOptionTokenListInput: (args: Props<TokenListOption>) => React.JSX.Element;
+export declare const _AllowArbitraryValues: {
+    (args: Props<TokenListOption>): React.JSX.Element;
+    args: {
+        menu: {
+            options: {
+                key: string;
+                label: string;
+            }[];
+        };
+        disabled: boolean;
+        locked: boolean;
+    };
+};
+//# sourceMappingURL=TokenListInput.stories.d.ts.map

package/lib/components/TokenListInput/TokenListInput.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenListInput.stories.d.ts","sourceRoot":"","sources":["../../../src/components/TokenListInput/TokenListInput.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,SAAS,CAAC;AAQxC,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOhD,wBAgQE;AAEF,KAAK,eAAe,GAAG,UAAU,GAAG;IAClC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,eAAe;WAAU,KAAK,CAAC,eAAe,CAAC;;;;;;CA0B3D,CAAC;AAMF,eAAO,MAAM,wBAAwB,GAAI,MAAM,KAAK,CAAC,eAAe,CAAC,sBAuCpE,CAAC;AAEF,eAAO,MAAM,qBAAqB;WAAU,KAAK,CAAC,eAAe,CAAC;;;;CAsBjE,CAAC;AAMF,eAAO,MAAM,uBAAuB;WAAU,KAAK,CAAC,eAAe,CAAC;;;;;;;CAsBnE,CAAC;AAmDF,eAAO,MAAM,oBAAoB;WAAU,KAAK,CAAC,eAAe,CAAC;;;;;;;;;;;;;4BA+CpD,KAAK,CAAC,SAAS;;;;;;;;;CA7C3B,CAAC;AAsIF,eAAO,MAAM,2BAA2B,GAAI,MAAM,KAAK,CAAC,eAAe,CAAC,sBAEvE,CAAC;AAEF,eAAO,MAAM,qBAAqB;WAAU,KAAK,CAAC,eAAe,CAAC;;;;;;;;;;;CA4EjE,CAAC"}

package/lib/components/TokenListInput/TokenValueChips.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+type Props<T> = {
+    values: Array<T>;
+    disabled?: boolean;
+    locked?: boolean;
+    onDismiss: (arg1: T) => unknown;
+    resolveTokenValue?: (arg1: ResolveTokenValueProps<T>) => React.ReactNode;
+};
+export type ResolveTokenValueProps<T> = {
+    token: T;
+    disabled?: boolean;
+    onDismiss?: (arg1: T) => unknown;
+    locked?: boolean;
+};
+export declare function TokenValueChips<T>(props: Props<T>): (string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined)[];
+export declare namespace TokenValueChips {
+    var displayName: string;
+}
+export {};
+//# sourceMappingURL=TokenValueChips.d.ts.map

package/lib/components/TokenListInput/TokenValueChips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenValueChips.d.ts","sourceRoot":"","sources":["../../../src/components/TokenListInput/TokenValueChips.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,KAAK,KAAK,CAAC,CAAC,IAAI;IACd,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC;CAC1E,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI;IACtC,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AA0BF,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,uSAkBjD;yBAlBe,eAAe"}

package/lib/components/TokenListInput/TokenValueChips.js

@@ -15,16 +15,14 @@ function defaultResolveTokenValue(_ref) {
     disabled,
     onDismiss
   } = _ref;
-  // $FlowFixMe[prop-missing] - assumes token has label and key
-
   return (
     /*#__PURE__*/
-    // $FlowFixMe - assumes token has label and key
+    // @ts-ignore - TS2339 - Property 'label' does not exist on type 'NonNullable<T>'.
     React.createElement(_Tooltip.Tooltip, {
       body: token?.label,
       elevation: _elevation.elevationMenu
     }, /*#__PURE__*/React.createElement(_Chip.Chip
-    // $FlowFixMe - assumes token has key
+    // @ts-ignore - TS2339 - Property 'key' does not exist on type 'NonNullable<T>'.
     , {
       key: token?.key,
       onDismiss: _ => onDismiss?.(token),

package/lib/components/TokenListInput/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TokenListInput';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/TokenListInput/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/TokenListInput/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}

package/lib/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+type ClassNames = Readonly<{
+    tooltip?: string;
+    title?: string;
+    body?: string;
+}>;
+export declare const DELAY_MOTION_DURATION_TYPES: Readonly<{
+    none: "none";
+    fast: "fast";
+    normal: "normal";
+    slow: "slow";
+    slower: "slower";
+    slowest: "slowest";
+}>;
+export type DelayMotionDurationType = (typeof DELAY_MOTION_DURATION_TYPES)[keyof typeof DELAY_MOTION_DURATION_TYPES];
+export declare const ELEVATION_TYPES: Readonly<{
+    none: "none";
+    card: "card";
+    tooltip: "tooltip";
+    menu: "menu";
+    backdrop: "backdrop";
+    modal: "modal";
+    toast: "toast";
+}>;
+export type ElevationType = (typeof ELEVATION_TYPES)[keyof typeof ELEVATION_TYPES];
+export type PlacementType = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
+export type BaseTooltipProps = {
+    classNames?: ClassNames;
+    title?: string | React.ReactNode;
+    body?: string | React.ReactNode;
+    placement?: PlacementType;
+    bodyMaxLines?: number;
+    titleMaxLines?: number;
+    delayMotionDuration?: DelayMotionDurationType;
+    hidden?: boolean;
+    elevation?: ElevationType;
+};
+export type TooltipProps = BaseTooltipProps & {
+    children: any;
+};
+export declare const getElevationValue: (elevation: string) => string;
+export declare const Tooltip: ({ classNames, children, title, body, placement, bodyMaxLines, titleMaxLines, delayMotionDuration, elevation, hidden, }: TooltipProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=Tooltip.d.ts.map

package/lib/components/Tooltip/Tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.d.ts","sourceRoot":"","sources":["../../../src/components/Tooltip/Tooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA0B/B,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;EAOtC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,OAAO,2BAA2B,CAAC,CAAC;AAEjF,eAAO,MAAM,eAAe;;;;;;;;EAQ1B,CAAC;AAEH,MAAM,MAAM,aAAa,GACvB,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAEzD,MAAM,MAAM,aAAa,GACrB,KAAK,GACL,WAAW,GACX,SAAS,GACT,QAAQ,GACR,cAAc,GACd,YAAY,GACZ,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC;IAChC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,uBAAuB,CAAC;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG;IAE5C,QAAQ,EAAE,GAAG,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,KAAG,MAIrD,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,wHAWrB,YAAY,sBA+Fd,CAAC"}

package/lib/components/Tooltip/Tooltip.js

@@ -16,8 +16,6 @@ var _TooltipModule = _interopRequireDefault(require("./Tooltip.module.css"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/* eslint-disable ft-flow/no-weak-types */
-
 const DELAY_MOTION_DURATION_TYPES = exports.DELAY_MOTION_DURATION_TYPES = Object.freeze({
   none: 'none',
   fast: 'fast',
@@ -37,6 +35,7 @@ const ELEVATION_TYPES = exports.ELEVATION_TYPES = Object.freeze({
 });
 const getElevationValue = elevation => {
   const elevationKey = 'elevation' + (0, _string.capitalize)(elevation);
+  // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'typeof import("/Users/diwaker/SpacedOut/ui-design-system/src/styles/variables/_elevation")'.
   return ELEVATION[elevationKey] || elevation;
 };
 exports.getElevationValue = getElevationValue;
@@ -70,7 +69,11 @@ const Tooltip = _ref => {
     }), (0, _react2.shift)()]
   });
   const motionDurationToken = 'motionDuration' + (0, _string.capitalize)(delayMotionDuration);
-  const hoverDelay = parseInt(MOTION[motionDurationToken]) === NaN ? 0 : parseInt(MOTION[motionDurationToken]);
+  const hoverDelay =
+  // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'typeof import("/Users/diwaker/SpacedOut/ui-design-system/src/styles/variables/_motion")'.
+  parseInt(MOTION[motionDurationToken]) === NaN ? 0 :
+  // @ts-ignore - TS7053 - Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'typeof import("/Users/diwaker/SpacedOut/ui-design-system/src/styles/variables/_motion")'.
+  parseInt(MOTION[motionDurationToken]);
   const {
     getReferenceProps,
     getFloatingProps