@jetbrains/ring-ui-built 6.0.35 → 6.0.37

package/components/island/adaptive-island-hoc.js

@@ -1,7 +1,8 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createClass, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
 import 'core-js/modules/es.array.concat.js';
-import React, { createContext, Component } from 'react';
+import { createContext, Component } from 'react';
 import { interpolateLinear } from '../global/linear-function.js';
+import { jsx } from 'react/jsx-runtime';
 
 var TITLE_RESIZE_END = 20;
 var TITLE_RESIZE_THRESHOLD = 36;
@@ -38,11 +39,13 @@ function adaptiveIslandHOC(ComposedComponent) {
     return _createClass(AdaptiveIsland, [{
       key: "render",
       value: function render() {
-        return /*#__PURE__*/React.createElement(PhaseContext.Provider, {
-          value: this.state.phase
-        }, /*#__PURE__*/React.createElement(ScrollHandlerContext.Provider, {
-          value: this.onContentScroll
-        }, /*#__PURE__*/React.createElement(ComposedComponent, this.props)));
+        return /*#__PURE__*/jsx(PhaseContext.Provider, {
+          value: this.state.phase,
+          children: /*#__PURE__*/jsx(ScrollHandlerContext.Provider, {
+            value: this.onContentScroll,
+            children: /*#__PURE__*/jsx(ComposedComponent, _objectSpread2({}, this.props))
+          })
+        });
       }
     }]);
   }(Component), _defineProperty(_AdaptiveIsland, "propTypes", ComposedComponent.propTypes), _AdaptiveIsland;

package/components/island/content.d.ts

@@ -1,4 +1,4 @@
-import React, { Component, HTMLAttributes } from 'react';
+import { Component, HTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 import createResizeDetector from 'element-resize-detector';
 export interface IslandContentProps extends Omit<HTMLAttributes<HTMLElement>, 'onScroll'> {
@@ -37,7 +37,7 @@ declare class Content extends Component<IslandContentInnerProps> {
     calculateScrollPosition: () => void;
     scrollableNode?: HTMLElement | null;
     setScrollableNodeAndCalculatePosition: (node: HTMLElement | null) => void;
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
-declare const ContentWrapper: React.ForwardRefExoticComponent<IslandContentProps & React.RefAttributes<Content>>;
+declare const ContentWrapper: import("react").ForwardRefExoticComponent<IslandContentProps & import("react").RefAttributes<Content>>;
 export default ContentWrapper;

package/components/island/content.js

@@ -1,12 +1,13 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createClass, d as _objectSpread2, c as _objectWithoutProperties, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
 import 'core-js/modules/es.array.concat.js';
-import React, { Component, forwardRef } from 'react';
+import { forwardRef, Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import createResizeDetector from 'element-resize-detector';
 import scheduleRAF from '../global/schedule-raf.js';
 import { m as modules_e6a056e1 } from '../_helpers/island.js';
 import { ScrollHandlerContext } from './adaptive-island-hoc.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
 import '../global/linear-function.js';
 
 var _excluded = ["children", "className", "bottomBorder", "scrollableWrapperClassName", "onScroll", "onScrollToBottom", "fade"];
@@ -101,20 +102,23 @@ var Content = /*#__PURE__*/function (_Component) {
         [modules_e6a056e1.withBottomBorder]: bottomBorder && !scrolledToBottom
       });
       var scrollableWrapperClasses = classNames(modules_e6a056e1.scrollableWrapper, scrollableWrapperClassName);
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      return /*#__PURE__*/jsx("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
         "data-test": "ring-island-content",
-        className: classes
-      }), /*#__PURE__*/React.createElement("div", {
-        // it has to be focusable because it can be scrollable
-        // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
-        tabIndex: 0,
-        "data-scrollable-container": true,
-        className: scrollableWrapperClasses,
-        ref: this.setScrollableNodeAndCalculatePosition,
-        onScroll: fade ? this.calculateScrollPosition : noop
-      }, fade && /*#__PURE__*/React.createElement("div", {
-        ref: this.setWrapper
-      }, children), !fade && children));
+        className: classes,
+        children: /*#__PURE__*/jsxs("div", {
+          // it has to be focusable because it can be scrollable
+          // eslint-disable-next-line jsx-a11y/no-noninteractive-tabindex
+          tabIndex: 0,
+          "data-scrollable-container": true,
+          className: scrollableWrapperClasses,
+          ref: this.setScrollableNodeAndCalculatePosition,
+          onScroll: fade ? this.calculateScrollPosition : noop,
+          children: [fade && /*#__PURE__*/jsx("div", {
+            ref: this.setWrapper,
+            children: children
+          }), !fade && children]
+        })
+      }));
     }
   }]);
 }(Component);
@@ -134,14 +138,16 @@ _defineProperty(Content, "defaultProps", {
   onScrollToBottom: noop
 });
 var ContentWrapper = /*#__PURE__*/forwardRef(function (props, ref) {
-  return /*#__PURE__*/React.createElement(ScrollHandlerContext.Consumer, null, function (onScroll) {
-    var addProps = onScroll != null ? {
-      onScroll,
-      bottomBorder: true
-    } : {};
-    return /*#__PURE__*/React.createElement(Content, _extends({}, props, addProps, {
-      ref: ref
-    }));
+  return /*#__PURE__*/jsx(ScrollHandlerContext.Consumer, {
+    children: function children(onScroll) {
+      var addProps = onScroll != null ? {
+        onScroll,
+        bottomBorder: true
+      } : {};
+      return /*#__PURE__*/jsx(Content, _objectSpread2(_objectSpread2(_objectSpread2({}, props), addProps), {}, {
+        ref: ref
+      }));
+    }
   });
 });
 ContentWrapper.displayName = 'ContentWrapper';

package/components/island/header.d.ts

@@ -1,8 +1,8 @@
-import React, { HTMLAttributes } from 'react';
+import { HTMLAttributes } from 'react';
 export interface IslandHeaderProps extends HTMLAttributes<HTMLElement> {
     wrapWithTitle?: boolean | undefined;
     border?: boolean | null | undefined;
     phase?: number | undefined;
 }
-declare const HeaderWrapper: (props: IslandHeaderProps) => React.JSX.Element;
+declare const HeaderWrapper: (props: IslandHeaderProps) => import("react").JSX.Element;
 export default HeaderWrapper;

package/components/island/header.js

@@ -1,11 +1,12 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createClass, d as _objectSpread2, c as _objectWithoutProperties, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
 import 'core-js/modules/es.array.concat.js';
-import React, { Component } from 'react';
+import { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import { interpolateLinear } from '../global/linear-function.js';
 import { m as modules_e6a056e1 } from '../_helpers/island.js';
 import { PhaseContext } from './adaptive-island-hoc.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
 var _excluded = ["children", "className", "wrapWithTitle", "border", "phase"];
 var Start = {
@@ -65,14 +66,16 @@ var Header = /*#__PURE__*/function (_Component) {
         transform: "translate(".concat(this.style('X'), "px, ").concat(this.style('Y'), "px) scale(").concat(scaleFont, ")"),
         letterSpacing: this.style('SPACING')
       } : undefined;
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      return /*#__PURE__*/jsxs("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
         "data-test": "ring-island-header",
         className: classes,
-        style: headerStyle
-      }), wrapWithTitle && /*#__PURE__*/React.createElement("h2", {
-        className: modules_e6a056e1.title,
-        style: titleStyle
-      }, children), !wrapWithTitle && children);
+        style: headerStyle,
+        children: [wrapWithTitle && /*#__PURE__*/jsx("h2", {
+          className: modules_e6a056e1.title,
+          style: titleStyle,
+          children: children
+        }), !wrapWithTitle && children]
+      }));
     }
   }]);
 }(Component);
@@ -87,11 +90,13 @@ _defineProperty(Header, "defaultProps", {
   wrapWithTitle: true
 });
 var HeaderWrapper = function HeaderWrapper(props) {
-  return /*#__PURE__*/React.createElement(PhaseContext.Consumer, null, function (phase) {
-    var addProps = phase != null ? {
-      phase
-    } : {};
-    return /*#__PURE__*/React.createElement(Header, _extends({}, props, addProps));
+  return /*#__PURE__*/jsx(PhaseContext.Consumer, {
+    children: function children(phase) {
+      var addProps = phase != null ? {
+        phase
+      } : {};
+      return /*#__PURE__*/jsx(Header, _objectSpread2(_objectSpread2({}, props), addProps));
+    }
   });
 };
 

package/components/island/island.d.ts

@@ -1,4 +1,4 @@
-import React, { Component, HTMLAttributes } from 'react';
+import { Component, HTMLAttributes } from 'react';
 import PropTypes from 'prop-types';
 export interface IslandProps extends HTMLAttributes<HTMLElement> {
     narrow?: boolean | null | undefined;
@@ -16,7 +16,7 @@ export default class Island extends Component<IslandProps> {
         withoutPaddings: PropTypes.Requireable<boolean>;
         'data-test': PropTypes.Requireable<string>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export declare const AdaptiveIsland: {
     new (props: IslandProps): {
@@ -24,19 +24,19 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<IslandProps>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -50,19 +50,19 @@ export declare const AdaptiveIsland: {
             phase: null;
         };
         onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<IslandProps>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<IslandProps>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -71,8 +71,8 @@ export declare const AdaptiveIsland: {
         componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
         UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
     };
-    propTypes: React.WeakValidationMap<IslandProps> | undefined;
-    contextType?: React.Context<any> | undefined;
+    propTypes: import("react").WeakValidationMap<IslandProps> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 export { default as Header } from './header';
 export { default as Content } from './content';

package/components/island/island.js

@@ -1,10 +1,11 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
-import React, { Component } from 'react';
+import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { Component } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import joinDataTestAttributes from '../global/data-tests.js';
 import adaptiveIslandHOC from './adaptive-island-hoc.js';
 import { m as modules_e6a056e1 } from '../_helpers/island.js';
+import { jsx } from 'react/jsx-runtime';
 export { default as Header } from './header.js';
 export { default as Content } from './content.js';
 import 'core-js/modules/es.array.concat.js';
@@ -16,9 +17,6 @@ import 'element-resize-detector';
 import '../global/schedule-raf.js';
 
 var _excluded = ["children", "className", "narrow", "withoutPaddings", "data-test"];
-/**
- * @name Island
- */
 var Island = /*#__PURE__*/function (_Component) {
   function Island() {
     _classCallCheck(this, Island);
@@ -39,10 +37,11 @@ var Island = /*#__PURE__*/function (_Component) {
         [modules_e6a056e1.narrowIsland]: narrow,
         [modules_e6a056e1.withoutPaddings]: withoutPaddings
       });
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+      return /*#__PURE__*/jsx("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
         className: classes,
-        "data-test": joinDataTestAttributes('ring-island', dataTest)
-      }), children);
+        "data-test": joinDataTestAttributes('ring-island', dataTest),
+        children: children
+      }));
     }
   }]);
 }(Component);

package/components/island-legacy/content-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Content extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,5 +6,5 @@ export default class Content extends PureComponent<HTMLAttributes<HTMLElement>>
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/island-legacy/content-legacy.js

@@ -1,7 +1,8 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
-import React, { PureComponent } from 'react';
+import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
+import { jsx } from 'react/jsx-runtime';
 
 var _excluded = ["children", "className"];
 var Content = /*#__PURE__*/function (_PureComponent) {
@@ -18,9 +19,10 @@ var Content = /*#__PURE__*/function (_PureComponent) {
         className = _this$props.className,
         restProps = _objectWithoutProperties(_this$props, _excluded);
       var classes = classNames('ring-island__content', className);
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-        className: classes
-      }), children);
+      return /*#__PURE__*/jsx("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
+        className: classes,
+        children: children
+      }));
     }
   }]);
 }(PureComponent);

package/components/island-legacy/header-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Header extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,5 +6,5 @@ export default class Header extends PureComponent<HTMLAttributes<HTMLElement>> {
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }

package/components/island-legacy/header-legacy.js

@@ -1,7 +1,8 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
-import React, { PureComponent } from 'react';
+import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
+import { jsx } from 'react/jsx-runtime';
 
 var _excluded = ["children", "className"];
 var Header = /*#__PURE__*/function (_PureComponent) {
@@ -18,11 +19,13 @@ var Header = /*#__PURE__*/function (_PureComponent) {
         className = _this$props.className,
         restProps = _objectWithoutProperties(_this$props, _excluded);
       var classes = classNames('ring-island__header', className);
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-        className: classes
-      }), /*#__PURE__*/React.createElement("div", {
-        className: "ring-island__title"
-      }, children));
+      return /*#__PURE__*/jsx("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
+        className: classes,
+        children: /*#__PURE__*/jsx("div", {
+          className: "ring-island__title",
+          children: children
+        })
+      }));
     }
   }]);
 }(PureComponent);

package/components/island-legacy/island-legacy.d.ts

@@ -1,4 +1,4 @@
-import React, { HTMLAttributes, PureComponent } from 'react';
+import { HTMLAttributes, PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import './island-legacy.css';
 export default class Island extends PureComponent<HTMLAttributes<HTMLElement>> {
@@ -6,7 +6,7 @@ export default class Island extends PureComponent<HTMLAttributes<HTMLElement>> {
         className: PropTypes.Requireable<string>;
         children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
     };
-    render(): React.JSX.Element;
+    render(): import("react").JSX.Element;
 }
 export { default as Header } from './header-legacy';
 export { default as Content } from './content-legacy';

package/components/island-legacy/island-legacy.js

@@ -1,7 +1,8 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
-import React, { PureComponent } from 'react';
+import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
+import { jsx } from 'react/jsx-runtime';
 export { default as Header } from './header-legacy.js';
 export { default as Content } from './content-legacy.js';
 
@@ -20,9 +21,10 @@ var Island = /*#__PURE__*/function (_PureComponent) {
         className = _this$props.className,
         restProps = _objectWithoutProperties(_this$props, _excluded);
       var classes = classNames('ring-island', className);
-      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
-        className: classes
-      }), children);
+      return /*#__PURE__*/jsx("div", _objectSpread2(_objectSpread2({}, restProps), {}, {
+        className: classes,
+        children: children
+      }));
     }
   }]);
 }(PureComponent);

package/components/link/clickableLink.d.ts

@@ -1,4 +1,5 @@
-import React, { PureComponent, AnchorHTMLAttributes } from 'react';
+import { PureComponent, AnchorHTMLAttributes } from 'react';
+import * as React from 'react';
 import PropTypes from 'prop-types';
 export interface ClickableLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     onConditionalClick?: ((isPlainLeft: boolean, e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;

package/components/link/clickableLink.js

@@ -1,7 +1,8 @@
-import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, e as _extends, f as _classCallCheck, g as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { _ as _defineProperty, a as _inherits, b as _createClass, c as _objectWithoutProperties, d as _objectSpread2, e as _classCallCheck, f as _callSuper } from '../_helpers/_rollupPluginBabelHelpers.js';
 import 'core-js/modules/es.array.concat.js';
-import React, { PureComponent } from 'react';
+import { PureComponent } from 'react';
 import PropTypes from 'prop-types';
+import { jsx } from 'react/jsx-runtime';
 
 var _excluded = ["onConditionalClick", "onPlainLeftClick", "activeClassName", "href", "children"];
 var LEFT_BUTTON = 0;
@@ -47,11 +48,12 @@ var ClickableLink = /*#__PURE__*/function (_PureComponent) {
         var href = _this$props2.href,
         children = _this$props2.children,
         restProps = _objectWithoutProperties(_this$props2, _excluded);
-      return /*#__PURE__*/React.createElement("a", _extends({
+      return /*#__PURE__*/jsx("a", _objectSpread2(_objectSpread2({
         href: href
-      }, restProps, {
-        onClick: this.onClick
-      }), children);
+      }, restProps), {}, {
+        onClick: this.onClick,
+        children: children
+      }));
     }
   }]);
 }(PureComponent);

package/components/link/link.d.ts

@@ -1,4 +1,4 @@
-import React, { ReactNode, ComponentType } from 'react';
+import { ReactNode, ComponentType } from 'react';
 import PropTypes from 'prop-types';
 import { ClickableLinkProps } from './clickableLink';
 /**
@@ -15,20 +15,20 @@ export interface LinkBaseProps {
 export type LinkProps<P extends ClickableLinkProps = ClickableLinkProps> = Omit<P, keyof LinkBaseProps> & LinkBaseProps;
 export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent: ComponentType<P> | string): {
     new (props: LinkProps<P>): {
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<LinkProps<P>>;
         state: Readonly<{}>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -38,20 +38,20 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     new (props: LinkProps<P>, context: any): {
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<P>>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<LinkProps<P>>;
         state: Readonly<{}>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -72,24 +72,24 @@ export declare function linkHOC<P extends ClickableLinkProps>(ComposedComponent:
         onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
         onClick: PropTypes.Requireable<(...args: any[]) => any>;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 declare const _default: {
     new (props: LinkProps<ClickableLinkProps>): {
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<LinkProps<ClickableLinkProps>>;
         state: Readonly<{}>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -99,20 +99,20 @@ declare const _default: {
         UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
     };
     new (props: LinkProps<ClickableLinkProps>, context: any): {
-        render(): React.JSX.Element;
+        render(): import("react").JSX.Element;
         context: unknown;
-        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<LinkProps<ClickableLinkProps>>) => Pick<{}, K> | {} | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
         readonly props: Readonly<LinkProps<ClickableLinkProps>>;
         state: Readonly<{}>;
         refs: {
-            [key: string]: React.ReactInstance;
+            [key: string]: import("react").ReactInstance;
         };
         componentDidMount?(): void;
         shouldComponentUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
         componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>): any | null;
         componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
         componentWillMount?(): void;
         UNSAFE_componentWillMount?(): void;
@@ -133,6 +133,6 @@ declare const _default: {
         onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
         onClick: PropTypes.Requireable<(...args: any[]) => any>;
     };
-    contextType?: React.Context<any> | undefined;
+    contextType?: import("react").Context<any> | undefined;
 };
 export default _default;