@spaced-out/ui-design-system 0.4.12 → 0.4.13-beta.1

package/lib/components/Truncate/Truncate.js

@@ -22,7 +22,9 @@ const BaseTruncate = exports.BaseTruncate = /*#__PURE__*/React.forwardRef((_ref,
     style: {
       '--line-clamp': line,
       '--word-break': wordBreak
-    },
+    }
+    // @ts-ignore - TS2322 - Type 'React.ReactNode' is not assignable to type 'string | undefined'.
+    ,
     title: showFullTextOnHover ? children : '',
     ref: ref
   }, children);
@@ -39,11 +41,13 @@ const Truncate = exports.Truncate = /*#__PURE__*/React.forwardRef((_ref2, ref) =
   if (arrayChildren.length) {
     const child = arrayChildren[0];
     if (/*#__PURE__*/React.isValidElement(child)) {
+      // @ts-ignore - TS2339 - Property 'className' does not exist on type 'unknown'. | TS2339 - Property 'children' does not exist on type 'unknown'.
       const {
         className,
         children
       } = child.props;
       return /*#__PURE__*/React.cloneElement(child, {
+        // @ts-ignore - TS2769 - No overload matches this call.
         className: (0, _classify.classify)(_TruncateModule.default.truncateLineClamp, className, truncateClassName),
         style: {
           '--line-clamp': line,

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

@@ -0,0 +1,94 @@
+import * as React from 'react';
+import type { TruncateProps } from './';
+declare const _default: {
+    tags: string[];
+    title: string;
+    argTypes: {
+        line: {
+            description: string;
+            control: {
+                type: string;
+                min: number;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: number;
+                };
+            };
+        };
+        children: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        showFullTextOnHover: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        className: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        wordBreak: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _Truncate: {
+    ({ children, ...args }: TruncateProps): React.JSX.Element;
+    args: {
+        line: number;
+        showFullTextOnHover: boolean;
+        children: string;
+    };
+};
+//# sourceMappingURL=Truncate.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Truncate.stories.d.ts","sourceRoot":"","sources":["../../../src/components/Truncate/Truncate.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMtC,wBAwEE;AAEF,eAAO,MAAM,SAAS;4BAIjB,aAAa;;;;;;CAOX,CAAC"}

package/lib/components/Truncate/Truncate.stories.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports._Truncate = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _Text = require("../Text");
+var _ = require("./");
+var _TruncateStoriesModule = _interopRequireDefault(require("./Truncate.stories.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); }
+var _default = exports.default = {
+  tags: ['autodocs'],
+  title: 'Components/Truncate',
+  argTypes: {
+    line: {
+      description: 'Number of lines to show, and lines after that will be truncated',
+      control: {
+        type: 'number',
+        min: 1
+      },
+      table: {
+        type: {
+          summary: 'number'
+        },
+        defaultValue: {
+          summary: 1
+        }
+      }
+    },
+    children: {
+      description: 'Content to be displayed',
+      control: {
+        type: 'text'
+      },
+      table: {
+        type: {
+          summary: 'string'
+        }
+      }
+    },
+    showFullTextOnHover: {
+      description: 'If **true**, full text **would be displayed** as a browser tooltip on hover',
+      control: {
+        type: 'boolean'
+      },
+      table: {
+        type: {
+          summary: 'boolean'
+        },
+        defaultValue: {
+          summary: 'false'
+        }
+      }
+    },
+    className: {
+      description: 'External className to be applied on truncate wrapper',
+      control: {
+        type: 'text'
+      },
+      table: {
+        type: {
+          summary: 'string'
+        }
+      }
+    },
+    wordBreak: {
+      description: 'word-break style to be applied on truncate',
+      control: {
+        type: 'text'
+      },
+      table: {
+        type: {
+          summary: 'string'
+        },
+        defaultValue: {
+          summary: 'break-all'
+        }
+      }
+    }
+  },
+  parameters: {
+    docs: {
+      subtitle: 'Generates a Truncate component',
+      description: {
+        component: `
+\`\`\`js
+import { Truncate } from "@spaced-out/ui-design-system/lib/components/Truncate";
+\`\`\`
+Truncate Component is a wrapper for line clamping.
+        `
+      }
+    },
+    storySource: {
+      componentPath: '/src/components/Truncate/Truncate.jsx'
+    }
+  }
+};
+const _Truncate = _ref => {
+  let {
+    children,
+    ...args
+  } = _ref;
+  return /*#__PURE__*/React.createElement("div", {
+    className: _TruncateStoriesModule.default.storyContainer
+  }, /*#__PURE__*/React.createElement(_Text.BodyLarge, null, /*#__PURE__*/React.createElement(_.Truncate, args, "Toggle *showFullTextOnHover* to show/hide full text tooltip ", children)));
+};
+exports._Truncate = _Truncate;
+_Truncate.args = {
+  line: 2,
+  showFullTextOnHover: false,
+  children: `The quick brown fox jumps over the lazy dog" is an English-language pangram—a
+  sentence that contains all the letters of the alphabet.
+  The phrase is commonly used for touch-typing practice, testing
+  typewriters and computer keyboards, displaying examples of fonts, and other
+  applications involving text where the use of all letters in the alphabet is desired.`
+};

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

@@ -0,0 +1,3 @@
+export type { TruncateProps } from './Truncate';
+export { Truncate } from './Truncate';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Truncate/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC"}

package/lib/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import type { BaseTooltipProps } from '../Tooltip';
+type ClassNames = Readonly<{
+    wrapper?: string;
+}>;
+export type TruncatedTextWithTooltipProps = {
+    children?: React.ReactNode;
+    tooltip?: BaseTooltipProps;
+    classNames?: ClassNames;
+    line?: number;
+    wordBreak?: string;
+    wrapText?: boolean;
+};
+export declare const TruncatedTextWithTooltip: ({ classNames, children, tooltip, wrapText, line, wordBreak, ...props }: TruncatedTextWithTooltipProps) => React.JSX.Element;
+export {};
+//# sourceMappingURL=TruncatedTextWithTooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TruncatedTextWithTooltip.d.ts","sourceRoot":"","sources":["../../../src/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,YAAY,CAAC;AAMjD,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,6BAA6B,GAAG;IAC1C,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,wEASG,6BAA6B,sBAyEjC,CAAC"}

package/lib/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.js

@@ -22,12 +22,14 @@ const TruncatedTextWithTooltip = _ref => {
     wrapText = false,
     line = 1,
     wordBreak = 'break-all',
+    // @ts-ignore - TS6133 - 'props' is declared but its value is never read.
     ...props
   } = _ref;
   const {
     width
   } = (0, _useWindowSize.useWindowSize)();
   const [showMouseTip, setShowMouseTip] = React.useState(false);
+  // @ts-ignore - TS2554 - Expected 1 arguments, but got 0.
   const truncatedRef = React.useRef();
   const checkIfTextOverflowing = React.useMemo(() => (0, _debounce.default)(() => {
     if (!wrapText && truncatedRef && truncatedRef.current && truncatedRef.current.scrollHeight > truncatedRef.current.clientHeight) {
@@ -51,6 +53,7 @@ const TruncatedTextWithTooltip = _ref => {
       const child = React.Children.only(children);
 
       //Vivek: This children in tooltip body is modified to remove line clamp style
+      // @ts-ignore - TS2769 - No overload matches this call.
       const modifiedChild = /*#__PURE__*/React.cloneElement(child, {
         style: {
           '--line-clamp': tooltip?.bodyMaxLines || line,
@@ -66,7 +69,9 @@ const TruncatedTextWithTooltip = _ref => {
     }
   }, /*#__PURE__*/React.createElement("span", {
     className: (0, _classify.default)(_TruncatedTextWithTooltipModule.default.truncateLineClamp, classNames?.wrapper),
-    style: styles,
+    style: styles
+    // @ts-ignore - TS2322 - Type 'RefObject<HTMLSpanElement | null | undefined>' is not assignable to type 'Ref<HTMLSpanElement> | undefined'.
+    ,
     ref: truncatedRef
   }, children));
 };

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

@@ -0,0 +1,110 @@
+import * as React from 'react';
+import type { TruncatedTextWithTooltipProps } from './';
+declare const _default: {
+    tags: string[];
+    title: string;
+    component: ({ classNames, children, tooltip, wrapText, line, wordBreak, ...props }: TruncatedTextWithTooltipProps) => React.JSX.Element;
+    argTypes: {
+        children: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        tooltip: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        classNames: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+            };
+        };
+        wrapText: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+        line: {
+            description: string;
+            control: {
+                type: string;
+                min: number;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: number;
+                };
+            };
+        };
+        wordBreak: {
+            description: string;
+            control: {
+                type: string;
+            };
+            table: {
+                type: {
+                    summary: string;
+                };
+                defaultValue: {
+                    summary: string;
+                };
+            };
+        };
+    };
+    parameters: {
+        docs: {
+            subtitle: string;
+            description: {
+                component: string;
+            };
+        };
+        storySource: {
+            componentPath: string;
+        };
+    };
+};
+export default _default;
+export declare const _TruncatedTextWithTooltip: {
+    (args: TruncatedTextWithTooltipProps): React.JSX.Element;
+    args: {
+        classNames: {
+            wrapper: string;
+        };
+        children: string;
+        tooltip: {
+            bodyMaxLines: number;
+        };
+    };
+};
+//# sourceMappingURL=TruncatedTextWithTooltip.stories.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TruncatedTextWithTooltip.stories.d.ts","sourceRoot":"","sources":["../../../src/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,KAAK,EAAC,6BAA6B,EAAC,MAAM,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMtD,wBA+GE;AAEF,eAAO,MAAM,yBAAyB;WAAU,6BAA6B;;;;;;;;;;CAgBzE,CAAC"}

package/lib/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.stories.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports._TruncatedTextWithTooltip = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _Text = require("../Text");
+var _TruncatedTextWithTooltip2 = require("./TruncatedTextWithTooltip");
+var _TruncatedTextWithTooltipStoriesModule = _interopRequireDefault(require("./TruncatedTextWithTooltip.stories.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); }
+var _default = exports.default = {
+  tags: ['autodocs'],
+  title: 'Components/Truncated Text With Tooltip',
+  component: _TruncatedTextWithTooltip2.TruncatedTextWithTooltip,
+  argTypes: {
+    children: {
+      description: 'The content to be displayed inside the component.',
+      control: {
+        type: 'text'
+      },
+      table: {
+        type: {
+          summary: 'React.ReactNode'
+        }
+      }
+    },
+    tooltip: {
+      description: 'Props for customizing the tooltip.',
+      control: {
+        type: 'object'
+      },
+      table: {
+        type: {
+          summary: 'BaseTooltipProps'
+        }
+      }
+    },
+    classNames: {
+      description: 'Provide an optional className to be applied to the wrapper.',
+      control: {
+        type: 'object'
+      },
+      table: {
+        type: {
+          summary: '{ wrapper?: string }'
+        }
+      }
+    },
+    wrapText: {
+      description: 'If **true**, allows the text to wrap instead of truncating.',
+      control: {
+        type: 'boolean'
+      },
+      table: {
+        type: {
+          summary: 'boolean'
+        },
+        defaultValue: {
+          summary: 'false'
+        }
+      }
+    },
+    line: {
+      description: 'Number of lines to show, and lines after that will be truncated \n note: this is only applicable if wrapText is false',
+      control: {
+        type: 'number',
+        min: 1
+      },
+      table: {
+        type: {
+          summary: 'number'
+        },
+        defaultValue: {
+          summary: 1
+        }
+      }
+    },
+    wordBreak: {
+      description: 'word-break style to be applied on truncate',
+      control: {
+        type: 'text'
+      },
+      table: {
+        type: {
+          summary: 'string'
+        },
+        defaultValue: {
+          summary: 'break-all'
+        }
+      }
+    }
+  },
+  parameters: {
+    docs: {
+      subtitle: 'Generates a TruncatedTextWithTooltip component.',
+      description: {
+        component: `
+\`\`\`js
+import { TruncatedTextWithTooltip } from "@spaced-out/ui-design-system/lib/components/TruncatedTextWithTooltip";
+\`\`\`
+
+**TruncatedTextWithTooltip** component is designed to handle text truncation and display tooltips when the text is truncated.
+It provides a clean way to present long text content while allowing users to view the full content through tooltips when necessary.
+The component would automatically detect if the text is truncated and display a tooltip when the text is truncated. The tooltip content
+would be the same as the text content(children) by default, but you can also assign custom tooltip content.
+
+### Usage
+\`\`\`jsx
+<BodyLarge>
+  <TruncatedTextWithTooltip>
+    Tooltip would appear only when the text is truncated. Change the width of the container to see it in action.
+  </TruncatedTextWithTooltip>
+</BodyLarge>
+
+<BodyLarge>
+  <TruncatedTextWithTooltip
+    tooltip={{ body: 'Custom tooltip text' }}
+  >
+    You can also assign custom tooltip text when the text is truncated.
+  </TruncatedTextWithTooltip>
+</BodyLarge>
+\`\`\`
+
+**Note:**
+- \`<TruncatedTextWithTooltip>\` should always be wrapped inside a **Typography** component.
+- Adjust the component's props and styles as needed to fit your specific use cases.
+        `
+      }
+    },
+    storySource: {
+      componentPath: '/src/components/TruncatedTextWithTooltip/TruncatedTextWithTooltip.jsx'
+    }
+  }
+};
+const _TruncatedTextWithTooltip = args => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
+  className: _TruncatedTextWithTooltipStoriesModule.default.container
+}, /*#__PURE__*/React.createElement(_Text.BodyLarge, {
+  color: "secondary"
+}, /*#__PURE__*/React.createElement(_TruncatedTextWithTooltip2.TruncatedTextWithTooltip, args))), /*#__PURE__*/React.createElement("div", {
+  className: _TruncatedTextWithTooltipStoriesModule.default.container
+}, /*#__PURE__*/React.createElement(_Text.BodyLarge, {
+  color: "secondary"
+}, /*#__PURE__*/React.createElement(_TruncatedTextWithTooltip2.TruncatedTextWithTooltip, _extends({}, args, {
+  tooltip: {
+    body: 'Custom tooltip text'
+  }
+}), "You can also assign a custom tip text when the text is truncated."))));
+exports._TruncatedTextWithTooltip = _TruncatedTextWithTooltip;
+_TruncatedTextWithTooltip.args = {
+  classNames: {
+    wrapper: ''
+  },
+  children: `Tooltip would appear only when the text is truncated. Change width of
+  the container to see it in action.`,
+  tooltip: {
+    bodyMaxLines: 3
+  }
+};

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

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

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

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

package/lib/components/Typeahead/SimpleTypeahead.d.ts

@@ -0,0 +1,41 @@
+import { Flow } from 'flow-to-typescript-codemod';
+import * as React from 'react';
+import type { MenuClassNames, MenuLabelTooltip } from '../../types/menu';
+import type { ClickAwayRefType } from '../../utils/click-away';
+import type { InputProps } from '../Input';
+import type { MenuOption, Virtualization } from '../Menu';
+import type { ElevationType } from '../Tooltip';
+type ClassNames = Readonly<{
+    wrapper?: string;
+    box?: string;
+}>;
+export type SimpleTypeaheadRef = {
+    selectedKeys?: Array<string>;
+};
+export type SimpleTypeaheadProps = (// Input props
+(InputProps) & {
+    isLoading?: boolean;
+    menuOpenOffset?: number;
+    classNames?: ClassNames;
+    options?: Array<MenuOption>;
+    selectedKeys?: Array<string>;
+    menuVirtualization?: Virtualization;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    menuClassNames?: MenuClassNames;
+    showLabelTooltip?: MenuLabelTooltip;
+    allowWrap?: boolean;
+    elevation?: ElevationType;
+    onSelect?: (option: MenuOption, arg2?: React.SyntheticEvent<HTMLElement> | null | undefined) => unknown;
+    onSearch?: (evt: React.ChangeEvent<HTMLInputElement>) => unknown;
+    onMenuOpen?: () => unknown;
+    onMenuClose?: () => unknown;
+    onClear?: () => void;
+    resolveLabel?: (option: MenuOption) => string | React.ReactNode;
+    resolveSecondaryLabel?: (option: MenuOption) => string | React.ReactNode;
+    clickAwayRef?: ClickAwayRefType;
+    allowInternalFilter?: boolean;
+});
+export declare const SimpleTypeahead: Flow.AbstractComponent<SimpleTypeaheadProps, SimpleTypeaheadRef>;
+export {};
+//# sourceMappingURL=SimpleTypeahead.d.ts.map

package/lib/components/Typeahead/SimpleTypeahead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleTypeahead.d.ts","sourceRoot":"","sources":["../../../src/components/Typeahead/SimpleTypeahead.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,4BAA4B,CAAC;AAEhD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAC,cAAc,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,SAAS,CAAC;AACxD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AAK9C,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CACnC,AADoC,cAAc;AAClD,CAAC,UAAU,CAAC,GAAG;IACb,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB,OAAO,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC5B,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,kBAAkB,CAAC,EAAE,cAAc,CAAC;IACpC,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,aAAa,CAAC;IAE1B,QAAQ,CAAC,EAAE,CACT,MAAM,EAAE,UAAU,EAClB,IAAI,CAAC,EAAE,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,SAAS,KACxD,OAAO,CAAC;IACb,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,WAAW,CAAC,gBAAgB,CAAC,KAAK,OAAO,CAAC;IACjE,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAErB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC;IAChE,qBAAqB,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC;IACzE,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC,CAAC;AA0GH,eAAO,MAAM,eAAe,EAAE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,EAAE,kBAAkB,CAAmF,CAAC"}

package/lib/components/Typeahead/SimpleTypeahead.js

@@ -51,6 +51,8 @@ const SimpleTypeaheadBase = (props, ref) => {
       onSelect?.(selectedOption, e);
     });
   };
+
+  // @ts-ignore - TS2345 - Argument of type '{ current: SimpleTypeaheadRef | null; } | ((arg1: SimpleTypeaheadRef | null) => unknown)' is not assignable to parameter of type 'Ref<SimpleTypeaheadRef> | undefined'.
   React.useImperativeHandle(ref, () => ({
     selectedKeys: typeaheadSelectedKeys
   }));
@@ -89,4 +91,6 @@ const SimpleTypeaheadBase = (props, ref) => {
     elevation: elevation
   }));
 };
+
+// @ts-ignore - TS2345 - Argument of type '(props: SimpleTypeaheadProps & Omit<Omit<Flow.ComponentProps<typeof Typeahead>, 'allowInternalFilter' | 'classNames' | 'size' | 'placeholder' | 'onSelect' | 'onMenuOpen' | 'onMenuClose' | 'typeaheadInputText' | 'onSearch' | 'onClear' | 'menu' | 'clickAwayRef' | 'elevation'>, keyof SimpleTypeaheadProps>, ref: { curre...' is not assignable to parameter of type 'ForwardRefRenderFunction<SimpleTypeaheadProps, SimpleTypeaheadRef>'.
 const SimpleTypeahead = exports.SimpleTypeahead = /*#__PURE__*/React.forwardRef(SimpleTypeaheadBase);