@jetbrains/ring-ui 4.1.6 → 5.0.0-beta.3

package/dist/icon/icon__svg.d.ts

@@ -0,0 +1,15 @@
+import React, { SVGAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface IconSVGProps extends SVGAttributes<SVGSVGElement> {
+    src: string;
+}
+declare function IconSVG({ src, className, ...rest }: IconSVGProps): JSX.Element;
+declare namespace IconSVG {
+    var propTypes: {
+        className: PropTypes.Requireable<string>;
+        src: PropTypes.Validator<string>;
+        style: PropTypes.Requireable<object>;
+    };
+}
+declare const _default: React.MemoExoticComponent<typeof IconSVG>;
+export default _default;

package/dist/icon/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './icon';
+export * from './icon';

package/dist/icon/index.js

@@ -1,5 +1,5 @@
 export { default } from './icon.js';
-export { Size } from './icon__constants.js';
+export { Color, Size } from './icon__constants.js';
 import '../_helpers/_rollupPluginBabelHelpers.js';
 import 'react';
 import 'prop-types';

package/dist/input/input.d.ts

@@ -0,0 +1,73 @@
+import React, { PureComponent, Ref, ComponentType, InputHTMLAttributes, TextareaHTMLAttributes, ReactNode, ExoticComponent, PropsWithoutRef, RefAttributes, ComponentProps } from 'react';
+import Theme, { ThemeOuterProps, ThemeProps } from '../global/theme';
+declare function noop(): void;
+/**
+ * @name Input
+ */
+declare enum Size {
+    AUTO = "Auto",
+    S = "S",
+    M = "M",
+    L = "L",
+    FULL = "FULL"
+}
+export interface InputBaseProps extends ThemeProps {
+    size: Size;
+    enableShortcuts: boolean | string[];
+    renderUnderline: (underlineRef: Ref<HTMLDivElement>, errorText: ReactNode) => ReactNode;
+    children?: string | undefined;
+    inputClassName?: string | null | undefined;
+    label?: ReactNode;
+    active?: boolean | null | undefined;
+    compact?: boolean | null | undefined;
+    error?: string | null | undefined;
+    borderless?: boolean | null | undefined;
+    onClear?: ((e: React.MouseEvent<HTMLButtonElement>) => void) | null | undefined;
+    loading?: boolean | null | undefined;
+    icon?: string | ComponentType | null | undefined;
+}
+declare type Override<D, S> = Omit<D, keyof S> & S;
+export declare type InputSpecificProps = Override<InputHTMLAttributes<HTMLInputElement>, InputBaseProps> & {
+    multiline?: false | undefined;
+    inputRef: Ref<HTMLInputElement>;
+};
+declare type TextAreaSpecificProps = Override<TextareaHTMLAttributes<HTMLTextAreaElement>, InputBaseProps> & {
+    multiline: true;
+    inputRef: Ref<HTMLTextAreaElement>;
+};
+export declare type InputProps = InputSpecificProps | TextAreaSpecificProps;
+export declare class Input extends PureComponent<InputProps> {
+    static defaultProps: {
+        size: Size;
+        onChange: typeof noop;
+        inputRef: typeof noop;
+        enableShortcuts: string[];
+        renderUnderline: (underlineRef: Ref<HTMLDivElement>, errorText: ReactNode) => JSX.Element;
+    };
+    state: {
+        empty: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    input?: HTMLInputElement | HTMLTextAreaElement | null;
+    underlineNode?: HTMLElement | null;
+    id: string;
+    getId(): string;
+    checkValue(): void;
+    stretch(el: HTMLElement | null | undefined): void;
+    adapt(): void;
+    underlineRef: (el: HTMLDivElement | null) => void;
+    inputRef: (el: HTMLInputElement | HTMLTextAreaElement | null) => void;
+    clear: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    handleInputChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleTextareaChange: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+    render(): JSX.Element;
+}
+export declare type ContainerProps<P> = PropsWithoutRef<Omit<JSX.LibraryManagedAttributes<typeof Input, P>, keyof ThemeProps> & ThemeOuterProps> & RefAttributes<Input>;
+declare type Container = ExoticComponent<ContainerProps<InputSpecificProps> | ContainerProps<TextAreaSpecificProps>>;
+declare const ThemedInput: Container & {
+    type: Container;
+};
+export declare type InputAttrs = ComponentProps<typeof ThemedInput>;
+export default ThemedInput;
+export { Size, Theme };

package/dist/input/input.js

@@ -3,11 +3,13 @@ import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import closeIcon from '@jetbrains/icons/close';
-import { withTheme } from '../global/theme.js';
+import Theme, { withTheme } from '../global/theme.js';
 export { default as Theme } from '../global/theme.js';
-import Button from '../button/button.js';
+import { refObject } from '../global/prop-types.js';
+import ThemedButton from '../button/button.js';
 import getUID from '../global/get-uid.js';
 import Icon from '../icon/icon.js';
+import composeRefs from '../global/composeRefs.js';
 import { m as modules_88cfaf40 } from '../_helpers/input.js';
 import 'focus-visible';
 import '@jetbrains/icons/chevron-10px';
@@ -25,13 +27,16 @@ function noop() {}
  */
 
 
-const Size = {
-  AUTO: 'Auto',
-  S: 'S',
-  M: 'M',
-  L: 'L',
-  FULL: 'FULL'
-};
+var Size;
+
+(function (Size) {
+  Size["AUTO"] = "Auto";
+  Size["S"] = "S";
+  Size["M"] = "M";
+  Size["L"] = "L";
+  Size["FULL"] = "FULL";
+})(Size || (Size = {}));
+
 class Input extends PureComponent {
   constructor() {
     super(...arguments);
@@ -40,6 +45,10 @@ class Input extends PureComponent {
       empty: true
     });
 
+    _defineProperty(this, "input", void 0);
+
+    _defineProperty(this, "underlineNode", void 0);
+
     _defineProperty(this, "id", getUID('ring-input-'));
 
     _defineProperty(this, "underlineRef", el => {
@@ -47,25 +56,29 @@ class Input extends PureComponent {
     });
 
     _defineProperty(this, "inputRef", el => {
-      const {
-        inputRef
-      } = this.props;
       this.input = el;
-
-      if (typeof inputRef === 'function') {
-        inputRef(el);
-      } else {
-        inputRef.current = el;
-      }
     });
 
     _defineProperty(this, "clear", e => {
       this.props.onClear && this.props.onClear(e);
     });
 
-    _defineProperty(this, "handleChange", e => {
-      this.props.onChange(e);
-      this.checkValue(e.target);
+    _defineProperty(this, "handleInputChange", e => {
+      if (!this.props.multiline) {
+        var _this$props$onChange, _this$props;
+
+        (_this$props$onChange = (_this$props = this.props).onChange) === null || _this$props$onChange === void 0 ? void 0 : _this$props$onChange.call(_this$props, e);
+        this.checkValue();
+      }
+    });
+
+    _defineProperty(this, "handleTextareaChange", e => {
+      if (this.props.multiline) {
+        var _this$props$onChange2, _this$props2;
+
+        (_this$props$onChange2 = (_this$props2 = this.props).onChange) === null || _this$props$onChange2 === void 0 ? void 0 : _this$props$onChange2.call(_this$props2, e);
+        this.checkValue();
+      }
     });
   }
 
@@ -82,11 +95,13 @@ class Input extends PureComponent {
   }
 
   checkValue() {
+    var _this$input;
+
     this.setState({
-      empty: !this.input.value
+      empty: !((_this$input = this.input) !== null && _this$input !== void 0 && _this$input.value)
     });
 
-    if (this.props.multiline && this.input.scrollHeight > this.input.clientHeight) {
+    if (this.props.multiline && this.input != null && this.input.scrollHeight > this.input.clientHeight) {
       this.stretch(this.input);
     }
   }
@@ -136,7 +151,7 @@ class Input extends PureComponent {
       empty
     } = this.state;
     const clearable = !!onClear;
-    const classes = classNames(modules_88cfaf40.container, className, modules_88cfaf40[theme], [modules_88cfaf40[`size${size}`]], {
+    const classes = classNames(modules_88cfaf40.container, className, theme && modules_88cfaf40[theme], [modules_88cfaf40[`size${size}`]], {
       'ring-js-shortcuts': enableShortcuts === true,
       [modules_88cfaf40.active]: active,
       [modules_88cfaf40.error]: error != null,
@@ -147,26 +162,29 @@ class Input extends PureComponent {
       [modules_88cfaf40.compact]: minimizeMargins
     });
     const inputClasses = classNames(modules_88cfaf40.input, inputClassName);
-    const TagName = multiline ? 'textarea' : 'input';
     const text = value != null ? value : children;
+    const commonProps = {
+      ref: composeRefs(this.inputRef, inputRef),
+      className: inputClasses,
+      value: text,
+      disabled,
+      id: this.getId(),
+      placeholder,
+      'aria-label': typeof label === 'string' && label ? label : placeholder,
+      'data-enabled-shortcuts': Array.isArray(enableShortcuts) ? enableShortcuts.join(',') : null
+    };
     return /*#__PURE__*/React.createElement("div", {
       className: classes,
       "data-test": "ring-input"
     }, icon && /*#__PURE__*/React.createElement(Icon, {
       glyph: icon,
       className: modules_88cfaf40.icon
-    }), /*#__PURE__*/React.createElement(TagName, _extends({
-      ref: this.inputRef,
-      onChange: this.handleChange,
-      className: inputClasses,
-      value: text,
-      rows: multiline ? 1 : null,
-      disabled: disabled,
-      id: this.getId(),
-      placeholder: placeholder,
-      "aria-label": typeof label === 'string' && label ? label : placeholder,
-      "data-enabled-shortcuts": Array.isArray(enableShortcuts) ? enableShortcuts.join(',') : null
-    }, restProps)), clearable && !disabled && /*#__PURE__*/React.createElement(Button, {
+    }), multiline ? /*#__PURE__*/React.createElement("textarea", _extends({
+      onChange: this.handleTextareaChange,
+      rows: 1
+    }, commonProps, restProps)) : /*#__PURE__*/React.createElement("input", _extends({
+      onChange: this.handleInputChange
+    }, commonProps, restProps)), clearable && !disabled && /*#__PURE__*/React.createElement(ThemedButton, {
       title: "Clear input",
       "data-test": "ring-input-clear",
       className: modules_88cfaf40.clear,
@@ -186,13 +204,24 @@ class Input extends PureComponent {
 
 }
 
-_defineProperty(Input, "propTypes", {
+_defineProperty(Input, "defaultProps", {
+  size: Size.M,
+  onChange: noop,
+  inputRef: noop,
+  enableShortcuts: ['esc'],
+  renderUnderline: (underlineRef, errorText) => /*#__PURE__*/React.createElement("div", {
+    className: modules_88cfaf40.errorText,
+    ref: underlineRef
+  }, errorText)
+});
+
+Input.propTypes = {
   value: PropTypes.string,
-  theme: PropTypes.string,
+  theme: PropTypes.oneOf(Object.values(Theme)),
   className: PropTypes.string,
   inputClassName: PropTypes.string,
-  size: PropTypes.string,
-  label: PropTypes.oneOfType([PropTypes.string, PropTypes.object]),
+  size: PropTypes.oneOf(Object.values(Size)).isRequired,
+  label: PropTypes.node,
   active: PropTypes.bool,
   error: PropTypes.string,
   multiline: PropTypes.bool,
@@ -200,29 +229,15 @@ _defineProperty(Input, "propTypes", {
   compact: PropTypes.bool,
   onChange: PropTypes.func,
   onClear: PropTypes.func,
-  inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
-    current: PropTypes.instanceOf(HTMLInputElement)
-  })]),
+  inputRef: PropTypes.oneOfType([PropTypes.func, refObject(PropTypes.instanceOf(HTMLInputElement)), refObject(PropTypes.instanceOf(HTMLTextAreaElement))]),
   children: PropTypes.string,
-  enableShortcuts: PropTypes.oneOfType([PropTypes.bool, PropTypes.arrayOf(PropTypes.string)]),
+  enableShortcuts: PropTypes.oneOfType([PropTypes.bool, PropTypes.arrayOf(PropTypes.string.isRequired)]),
   disabled: PropTypes.bool,
   id: PropTypes.string,
   placeholder: PropTypes.string,
   icon: PropTypes.oneOfType([PropTypes.string, PropTypes.elementType]),
   renderUnderline: PropTypes.func
-});
-
-_defineProperty(Input, "defaultProps", {
-  size: Size.M,
-  onChange: noop,
-  inputRef: noop,
-  enableShortcuts: ['esc'],
-  renderUnderline: (underlineRef, errorText) => /*#__PURE__*/React.createElement("div", {
-    className: modules_88cfaf40.errorText,
-    ref: underlineRef
-  }, errorText)
-});
-
-var Input$1 = withTheme()(Input);
+};
+const ThemedInput = withTheme()(Input);
 
-export { Input, Size, Input$1 as default };
+export { Input, Size, ThemedInput as default };

package/dist/island/adaptive-island-hoc.d.ts

@@ -0,0 +1,65 @@
+import React, { ComponentType } from 'react';
+export declare const PhaseContext: React.Context<number | null>;
+declare type ScrollHandler = (element: Element) => void;
+export declare const ScrollHandlerContext: React.Context<ScrollHandler | null>;
+export default function adaptiveIslandHOC<P>(ComposedComponent: ComponentType<P>): {
+    new (props: P | Readonly<P>): {
+        state: {
+            phase: number;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: P, context: any): {
+        state: {
+            phase: number;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: React.WeakValidationMap<P> | undefined;
+    contextType?: React.Context<any> | undefined;
+};
+export {};

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

@@ -4,8 +4,8 @@ import { interpolateLinear } from '../global/linear-function.js';
 
 const TITLE_RESIZE_END = 20;
 const TITLE_RESIZE_THRESHOLD = 36;
-const PhaseContext = /*#__PURE__*/createContext();
-const ScrollHandlerContext = /*#__PURE__*/createContext();
+const PhaseContext = /*#__PURE__*/createContext(null);
+const ScrollHandlerContext = /*#__PURE__*/createContext(null);
 function adaptiveIslandHOC(ComposedComponent) {
   var _class, _temp;
 

package/dist/island/content.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from 'react';
+export interface IslandContentProps extends Omit<HTMLAttributes<HTMLElement>, 'onScroll'> {
+    fade?: boolean | null | undefined;
+    onScrollToBottom?: (() => void) | null | undefined;
+    scrollableWrapperClassName?: string | null | undefined;
+}
+export interface IslandContentInnerProps extends IslandContentProps {
+    onScroll: (node: HTMLElement) => void;
+    bottomBorder: boolean;
+}
+declare const ContentWrapper: (props: IslandContentProps) => JSX.Element;
+export default ContentWrapper;

package/dist/island/content.js

@@ -27,6 +27,8 @@ class Content extends Component {
       strategy: 'scroll'
     }));
 
+    _defineProperty(this, "wrapperNode", void 0);
+
     _defineProperty(this, "setWrapper", node => {
       if (!node) {
         return;
@@ -54,7 +56,9 @@ class Content extends Component {
       const scrolledToBottom = offsetHeight + scrollTop >= scrollHeight - END_DISTANCE;
 
       if (scrolledToBottom) {
-        this.props.onScrollToBottom();
+        var _this$props$onScrollT, _this$props;
+
+        (_this$props$onScrollT = (_this$props = this.props).onScrollToBottom) === null || _this$props$onScrollT === void 0 ? void 0 : _this$props$onScrollT.call(_this$props);
       }
 
       this.setState({
@@ -64,10 +68,15 @@ class Content extends Component {
     }));
 
     _defineProperty(this, "onScroll", () => {
-      this.props.onScroll(this.scrollableNode);
+      if (this.scrollableNode != null) {
+        this.props.onScroll(this.scrollableNode);
+      }
+
       this.calculateScrollPosition();
     });
 
+    _defineProperty(this, "scrollableNode", void 0);
+
     _defineProperty(this, "setScrollableNodeAndCalculatePosition", node => {
       if (!node) {
         return;

package/dist/island/header.d.ts

@@ -0,0 +1,8 @@
+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) => JSX.Element;
+export default HeaderWrapper;

package/dist/island/header.js

@@ -9,11 +9,15 @@ import { PhaseContext } from './adaptive-island-hoc.js';
 const Start = {
   FONT_SIZE: 24,
   LINE_HEIGHT: 28,
-  PADDING: 16
+  PADDING: 16,
+  X: 0,
+  Y: 0,
+  SPACING: 0
 };
 const End = {
   FONT_SIZE: 13,
   LINE_HEIGHT: 28,
+  PADDING: 0,
   // Compensation
   X: 0.4,
   Y: 0.1,
@@ -23,7 +27,9 @@ const BORDER_APPEAR_PHASE = 0.5;
 
 class Header extends Component {
   style(name) {
-    return interpolateLinear(Start[name] || 0, End[name] || 0, this.props.phase);
+    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);
   }
 
   render() {
@@ -36,19 +42,18 @@ class Header extends Component {
       ...restProps
     } = this.props;
     const classes = classNames(modules_e6a056e1.header, className, {
-      [modules_e6a056e1.withBottomBorder]: border || phase >= BORDER_APPEAR_PHASE
+      [modules_e6a056e1.withBottomBorder]: border || phase != null && phase >= BORDER_APPEAR_PHASE
     });
     const headerStyle = phase != null ? {
       lineHeight: `${this.style('LINE_HEIGHT')}px`,
-      // need to append px because number is a valid line-height value
       paddingTop: this.style('PADDING')
-    } : null;
+    } : undefined;
     const scaleFont = phase != null && this.style('FONT_SIZE') / Start.FONT_SIZE;
     const titleStyle = phase != null && phase < 1 ? {
       fontSize: Start.FONT_SIZE,
       transform: `translate(${this.style('X')}px, ${this.style('Y')}px) scale(${scaleFont})`,
       letterSpacing: this.style('SPACING')
-    } : null;
+    } : undefined;
     return /*#__PURE__*/React.createElement("div", _extends({}, restProps, {
       "data-test": "ring-island-header",
       className: classes,

package/dist/island/island.d.ts

@@ -0,0 +1,82 @@
+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(): JSX.Element;
+}
+export declare const AdaptiveIsland: {
+    new (props: IslandProps | Readonly<IslandProps>): {
+        state: {
+            phase: number;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): JSX.Element;
+        context: any;
+        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> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        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: number;
+        };
+        onContentScroll: ({ scrollTop, scrollHeight, clientHeight }: Element) => void;
+        render(): JSX.Element;
+        context: any;
+        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> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        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/dist/island-legacy/content-legacy.d.ts

@@ -0,0 +1,10 @@
+import { 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(): JSX.Element;
+}

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

@@ -0,0 +1,10 @@
+import { 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(): JSX.Element;
+}

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

@@ -0,0 +1,12 @@
+import { 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(): JSX.Element;
+}
+export { default as Header } from './header-legacy';
+export { default as Content } from './content-legacy';

package/dist/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<string | number | boolean | {} | PropTypes.ReactElementLike | PropTypes.ReactNodeArray>;
+    };
+    onClick: (e: React.MouseEvent<HTMLAnchorElement>) => void;
+    render(): JSX.Element;
+}