@jetbrains/ring-ui-built 6.0.1

package/components/island/header.js

@@ -0,0 +1,100 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { 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';
+
+var _excluded = ["children", "className", "wrapWithTitle", "border", "phase"];
+var Start = {
+  FONT_SIZE: 24,
+  LINE_HEIGHT: 28,
+  PADDING_TOP: 24,
+  PADDING_BOTTOM: 0,
+  X: 0,
+  Y: 0,
+  SPACING: 0
+};
+var End = {
+  FONT_SIZE: 13,
+  LINE_HEIGHT: 20,
+  PADDING_TOP: 16,
+  PADDING_BOTTOM: 8,
+  // Compensation
+  X: 0.4,
+  Y: 0.1,
+  SPACING: 1.09
+};
+var BORDER_APPEAR_PHASE = 0.5;
+var Header = /*#__PURE__*/function (_Component) {
+  _inherits(Header, _Component);
+  var _super = _createSuper(Header);
+  function Header() {
+    _classCallCheck(this, Header);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Header, [{
+    key: "style",
+    value: function style(name) {
+      var _this$props$phase;
+      return interpolateLinear(Start[name], End[name], (_this$props$phase = this.props.phase) !== null && _this$props$phase !== void 0 ? _this$props$phase : 0);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        wrapWithTitle = _this$props.wrapWithTitle,
+        border = _this$props.border,
+        phase = _this$props.phase,
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_e6a056e1.header, className, {
+        [modules_e6a056e1.withBottomBorder]: border || phase != null && phase >= BORDER_APPEAR_PHASE
+      });
+      var headerStyle = phase != null ? {
+        lineHeight: "".concat(this.style('LINE_HEIGHT'), "px"),
+        // need to append px because number is a valid line-height value
+        paddingTop: this.style('PADDING_TOP'),
+        paddingBottom: this.style('PADDING_BOTTOM')
+      } : undefined;
+      var scaleFont = phase != null && this.style('FONT_SIZE') / Start.FONT_SIZE;
+      var titleStyle = phase != null && phase < 1 ? {
+        fontSize: Start.FONT_SIZE,
+        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, {
+        "data-test": "ring-island-header",
+        className: classes,
+        style: headerStyle
+      }), wrapWithTitle && /*#__PURE__*/React.createElement("h2", {
+        className: modules_e6a056e1.title,
+        style: titleStyle
+      }, children), !wrapWithTitle && children);
+    }
+  }]);
+  return Header;
+}(Component);
+_defineProperty(Header, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  border: PropTypes.bool,
+  wrapWithTitle: PropTypes.bool,
+  phase: PropTypes.number
+});
+_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));
+  });
+};
+
+export { HeaderWrapper as default };

package/components/island/island.d.ts

@@ -0,0 +1,78 @@
+import React, { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface IslandProps extends HTMLAttributes<HTMLElement> {
+    narrow?: boolean | null | undefined;
+    withoutPaddings?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+}
+/**
+ * @name Island
+ */
+export default class Island extends Component<IslandProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        narrow: PropTypes.Requireable<boolean>;
+        withoutPaddings: PropTypes.Requireable<boolean>;
+        'data-test': PropTypes.Requireable<string>;
+    };
+    render(): React.JSX.Element;
+}
+export declare const AdaptiveIsland: {
+    new (props: IslandProps | Readonly<IslandProps>): {
+        state: {
+            phase: null;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<IslandProps>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<IslandProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: IslandProps, context: any): {
+        state: {
+            phase: null;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<IslandProps>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<IslandProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<IslandProps>, nextContext: any): void;
+        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;
+};
+export { default as Header } from './header';
+export { default as Content } from './content';

package/components/island/island.js

@@ -0,0 +1,60 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { 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';
+export { default as Header } from './header.js';
+export { default as Content } from './content.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
+import '../global/linear-function.js';
+import 'element-resize-detector';
+import '../global/schedule-raf.js';
+
+var _excluded = ["children", "className", "narrow", "withoutPaddings", "data-test"];
+/**
+ * @name Island
+ */
+var Island = /*#__PURE__*/function (_Component) {
+  _inherits(Island, _Component);
+  var _super = _createSuper(Island);
+  function Island() {
+    _classCallCheck(this, Island);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Island, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        narrow = _this$props.narrow,
+        withoutPaddings = _this$props.withoutPaddings,
+        dataTest = _this$props['data-test'],
+        restProps = _objectWithoutProperties(_this$props, _excluded);
+      var classes = classNames(modules_e6a056e1.island, className, {
+        [modules_e6a056e1.narrowIsland]: narrow,
+        [modules_e6a056e1.withoutPaddings]: withoutPaddings
+      });
+      return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
+        className: classes,
+        "data-test": joinDataTestAttributes('ring-island', dataTest)
+      }), children);
+    }
+  }]);
+  return Island;
+}(Component);
+_defineProperty(Island, "propTypes", {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  narrow: PropTypes.bool,
+  withoutPaddings: PropTypes.bool,
+  'data-test': PropTypes.string
+});
+var AdaptiveIsland = adaptiveIslandHOC(Island);
+
+export { AdaptiveIsland, Island as default };

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

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

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

@@ -0,0 +1,34 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+var _excluded = ["children", "className"];
+var Content = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Content, _PureComponent);
+  var _super = _createSuper(Content);
+  function Content() {
+    _classCallCheck(this, Content);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Content, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        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 Content;
+}(PureComponent);
+_defineProperty(Content, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Content as default };

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

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

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

@@ -0,0 +1,36 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+
+var _excluded = ["children", "className"];
+var Header = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Header, _PureComponent);
+  var _super = _createSuper(Header);
+  function Header() {
+    _classCallCheck(this, Header);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Header, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        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 Header;
+}(PureComponent);
+_defineProperty(Header, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Header as default };

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

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

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

@@ -0,0 +1,36 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+export { default as Header } from './header-legacy.js';
+export { default as Content } from './content-legacy.js';
+
+var _excluded = ["children", "className"];
+var Island = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Island, _PureComponent);
+  var _super = _createSuper(Island);
+  function Island() {
+    _classCallCheck(this, Island);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Island, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        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 Island;
+}(PureComponent);
+_defineProperty(Island, "propTypes", {
+  className: PropTypes.string,
+  children: PropTypes.node
+});
+
+export { Island as default };

package/components/link/clickableLink.d.ts

@@ -0,0 +1,20 @@
+import React, { PureComponent, AnchorHTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ClickableLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    onConditionalClick?: ((isPlainLeft: boolean, e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;
+    onPlainLeftClick?: ((e: React.MouseEvent<HTMLAnchorElement>) => void) | null | undefined;
+    activeClassName?: string | null | undefined;
+    disabled?: boolean | undefined;
+}
+export default class ClickableLink extends PureComponent<ClickableLinkProps> {
+    static propTypes: {
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onConditionalClick: PropTypes.Requireable<(...args: any[]) => any>;
+        activeClassName: PropTypes.Requireable<string>;
+        href: PropTypes.Validator<string>;
+        children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+    };
+    onClick: (e: React.MouseEvent<HTMLAnchorElement>) => void;
+    render(): React.JSX.Element;
+}

package/components/link/clickableLink.js

@@ -0,0 +1,69 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+
+var _excluded = ["onConditionalClick", "onPlainLeftClick", "activeClassName", "href", "children"];
+var LEFT_BUTTON = 0;
+// Cmd/Ctrl/Shift/Alt + Click should trigger default browser behaviour. Same applies to non-left clicks
+var isPlainLeftClick = function isPlainLeftClick(e) {
+  return e.button === LEFT_BUTTON && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey;
+};
+var ClickableLink = /*#__PURE__*/function (_PureComponent) {
+  _inherits(ClickableLink, _PureComponent);
+  var _super = _createSuper(ClickableLink);
+  function ClickableLink() {
+    var _this;
+    _classCallCheck(this, ClickableLink);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _defineProperty(_assertThisInitialized(_this), "onClick", function (e) {
+      var _this$props = _this.props,
+        onClick = _this$props.onClick,
+        onConditionalClick = _this$props.onConditionalClick,
+        onPlainLeftClick = _this$props.onPlainLeftClick;
+      var isPlainLeft = isPlainLeftClick(e);
+      if (onClick) {
+        onClick(e);
+      }
+      if (onConditionalClick) {
+        onConditionalClick(isPlainLeft, e);
+      }
+      if (onPlainLeftClick && isPlainLeft) {
+        e.preventDefault();
+        onPlainLeftClick(e);
+      }
+    });
+    return _this;
+  }
+  _createClass(ClickableLink, [{
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props;
+        _this$props2.onConditionalClick;
+        _this$props2.onPlainLeftClick;
+        _this$props2.activeClassName;
+        var href = _this$props2.href,
+        children = _this$props2.children,
+        restProps = _objectWithoutProperties(_this$props2, _excluded);
+      return /*#__PURE__*/React.createElement("a", _extends({
+        href: href
+      }, restProps, {
+        onClick: this.onClick
+      }), children);
+    }
+  }]);
+  return ClickableLink;
+}(PureComponent);
+_defineProperty(ClickableLink, "propTypes", {
+  onClick: PropTypes.func,
+  onPlainLeftClick: PropTypes.func,
+  onConditionalClick: PropTypes.func,
+  activeClassName: PropTypes.string,
+  href: PropTypes.string.isRequired,
+  children: PropTypes.node.isRequired
+});
+
+export { ClickableLink as default };

package/components/link/link.d.ts

@@ -0,0 +1,138 @@
+import React, { ReactNode, ComponentType } from 'react';
+import PropTypes from 'prop-types';
+import { ClickableLinkProps } from './clickableLink';
+/**
+ * @name Link
+ */
+export interface LinkBaseProps {
+    active?: boolean | null | undefined;
+    inherit?: boolean | null | undefined;
+    pseudo?: boolean | null | undefined;
+    hover?: boolean | null | undefined;
+    'data-test'?: string | null | undefined;
+    children: ReactNode;
+}
+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> | Readonly<LinkProps<P>>): {
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<P>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: LinkProps<P>, context: any): {
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<P>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<P>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<P>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<P>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike | ((...args: any[]) => any)>>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+declare const _default: {
+    new (props: LinkProps<ClickableLinkProps> | Readonly<LinkProps<ClickableLinkProps>>): {
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<ClickableLinkProps>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: LinkProps<ClickableLinkProps>, context: any): {
+        render(): 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;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<LinkProps<ClickableLinkProps>>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: 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;
+        componentDidUpdate?(prevProps: Readonly<LinkProps<ClickableLinkProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<LinkProps<ClickableLinkProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        className: PropTypes.Requireable<string>;
+        active: PropTypes.Requireable<boolean>;
+        inherit: PropTypes.Requireable<boolean>;
+        pseudo: PropTypes.Requireable<boolean>;
+        hover: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike | ((...args: any[]) => any)>>;
+        'data-test': PropTypes.Requireable<string>;
+        href: PropTypes.Requireable<string>;
+        onPlainLeftClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;