@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/dist/button-toolbar/button-toolbar.d.ts

@@ -0,0 +1,12 @@
+import { PureComponent, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name Button Toolbar
+*/
+export default class ButtonToolbar extends PureComponent<HTMLAttributes<HTMLElement>> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+    };
+    render(): JSX.Element;
+}

package/dist/caret/caret.d.ts

@@ -0,0 +1,66 @@
+export interface PositionParams {
+    avoidFocus?: boolean | null | undefined;
+}
+export interface Position {
+    startOffset: number;
+    endOffset: number;
+    position: number;
+}
+/**
+ * @name Caret
+ */
+export default class Caret {
+    /**
+     * Line endings RegExp
+     * @type {RegExp}
+     */
+    static returnRE: RegExp;
+    /**
+     * Line endings normalizer
+     * Borrowed from jQuery
+     * @see https://github.com/jquery/jquery/blob/master/src/attributes/val.js
+     * @param value {*}
+     * @return {*}
+     */
+    static normalizeNewlines(value: string | undefined): string | undefined;
+    target: HTMLElement | HTMLInputElement;
+    constructor(target: HTMLElement);
+    isContentEditable(): boolean;
+    /**
+     * Set focus on target if possible
+     */
+    focus(): void;
+    /**
+     * Get absolute caret position index
+     * @return {number}
+     */
+    getAbsolutePosition(node: Node): number;
+    /**
+     * Get caret position index
+     * @param {Object} [params]
+     * @param {boolean} params.avoidFocus
+     * @return {number}
+     */
+    getPosition(params?: PositionParams): number | Position;
+    /**
+     * Get relative position of query
+     * @param  {Node} curNode
+     * @param {number} position
+     * @return {{_correctedPosition: number, _curNode: Node}}
+     */
+    getRelativePosition(curNode: Node, position: number): {
+        _curNode: Node;
+        _correctedPosition: number;
+    };
+    /**
+     * Set caret position index
+     * @param  {number} position
+     * @return {number}
+     */
+    setPosition(position?: Position | number): number | Range | undefined;
+    /**
+     * Get caret position in pixels
+     * @return {number}
+     */
+    getOffset(): number;
+}

package/dist/caret/caret.js

@@ -23,6 +23,8 @@ class Caret {
   }
 
   constructor(target) {
+    _defineProperty(this, "target", void 0);
+
     this.target = target;
   }
 
@@ -49,9 +51,11 @@ class Caret {
     let _curNode = node;
     let curPos = 0;
 
-    while (_curNode !== this.target) {
+    while (_curNode != null && _curNode !== this.target) {
       while (_curNode.previousSibling) {
-        curPos += _curNode.previousSibling.textContent.length;
+        var _curNode$previousSibl, _curNode$previousSibl2;
+
+        curPos += (_curNode$previousSibl = (_curNode$previousSibl2 = _curNode.previousSibling.textContent) === null || _curNode$previousSibl2 === void 0 ? void 0 : _curNode$previousSibl2.length) !== null && _curNode$previousSibl !== void 0 ? _curNode$previousSibl : 0;
         _curNode = _curNode.previousSibling;
       }
 
@@ -78,7 +82,7 @@ class Caret {
 
       const selection = window.getSelection();
 
-      if (!selection.rangeCount) {
+      if (!(selection !== null && selection !== void 0 && selection.rangeCount)) {
         return 0;
       }
 
@@ -89,11 +93,11 @@ class Caret {
       const _curNode = range1.startContainer;
 
       if (this.target === _curNode) {
-        return range1.startOffset === 0 ? 0 : _curNode.textContent.length;
+        return range1.startOffset === 0 || _curNode.textContent == null ? 0 : _curNode.textContent.length;
       } else if (!this.target.contains(_curNode)) {
         return -1;
       } else if (!_curNode) {
-        return this.target.selectionStart;
+        return 'selectionStart' in this.target && this.target.selectionStart || -1;
       }
 
       const curPos = this.getAbsolutePosition(_curNode);
@@ -120,7 +124,7 @@ class Caret {
       }
     }
 
-    return this.target.selectionStart;
+    return 'selectionStart' in this.target && this.target.selectionStart || -1;
   }
   /**
    * Get relative position of query
@@ -160,12 +164,16 @@ class Caret {
       while (curPos < position && _curNode.nodeType !== nodeTypeText) {
         i++;
 
-        if (_curNode.childNodes[i] !== null && _curNode.childNodes[i]) {
-          curPos += _curNode.childNodes[i].textContent.length;
+        if (_curNode.childNodes[i] != null) {
+          var _curNode$childNodes$i, _curNode$childNodes$i2;
+
+          curPos += (_curNode$childNodes$i = (_curNode$childNodes$i2 = _curNode.childNodes[i].textContent) === null || _curNode$childNodes$i2 === void 0 ? void 0 : _curNode$childNodes$i2.length) !== null && _curNode$childNodes$i !== void 0 ? _curNode$childNodes$i : 0;
 
           if (curPos >= position) {
+            var _curNode$textContent$, _curNode$textContent;
+
             _curNode = _curNode.childNodes[i];
-            curPos -= _curNode.textContent.length;
+            curPos -= (_curNode$textContent$ = (_curNode$textContent = _curNode.textContent) === null || _curNode$textContent === void 0 ? void 0 : _curNode$textContent.length) !== null && _curNode$textContent$ !== void 0 ? _curNode$textContent$ : 0;
             i = -1;
           }
         } else {
@@ -194,7 +202,7 @@ class Caret {
     let curNode = this.target && this.target.childNodes[0];
 
     if (position !== undefined) {
-      if (position.startOffset !== undefined) {
+      if (typeof position === 'object') {
         const range = new Range();
         const start = this.getRelativePosition(curNode, position.startOffset);
         range.setStart(start._curNode, start._correctedPosition);
@@ -202,8 +210,10 @@ class Caret {
         range.setEnd(end._curNode, end._correctedPosition);
         correctedPosition = range;
       } else if (position === -1) {
-        const value = isContentEditable ? this.target.textContent : this.constructor.normalizeNewlines(this.target.value);
-        correctedPosition = value.length;
+        var _value$length;
+
+        const value = isContentEditable ? this.target.textContent : Caret.normalizeNewlines('value' in this.target ? this.target.value : undefined);
+        correctedPosition = (_value$length = value === null || value === void 0 ? void 0 : value.length) !== null && _value$length !== void 0 ? _value$length : 0;
       } else {
         const {
           _curNode,
@@ -219,14 +229,18 @@ class Caret {
 
       try {
         if (correctedPosition instanceof Range) {
-          window.getSelection().removeAllRanges();
-          window.getSelection().addRange(correctedPosition);
+          var _window$getSelection, _window$getSelection2;
+
+          (_window$getSelection = window.getSelection()) === null || _window$getSelection === void 0 ? void 0 : _window$getSelection.removeAllRanges();
+          (_window$getSelection2 = window.getSelection()) === null || _window$getSelection2 === void 0 ? void 0 : _window$getSelection2.addRange(correctedPosition);
         } else {
-          window.getSelection().collapse(curNode || this.target, correctedPosition);
+          var _window$getSelection3;
+
+          (_window$getSelection3 = window.getSelection()) === null || _window$getSelection3 === void 0 ? void 0 : _window$getSelection3.collapse(curNode || this.target, correctedPosition);
         }
       } catch (e) {// Do nothing
       }
-    } else {
+    } else if ('setSelectionRange' in this.target && typeof correctedPosition === 'number') {
       this.target.setSelectionRange(correctedPosition, correctedPosition);
     }
 
@@ -243,15 +257,17 @@ class Caret {
     let range;
 
     try {
+      var _window$getSelection4, _range;
+
       // Both statements may throw
-      range = window.getSelection().getRangeAt(0).cloneRange();
-      range.setStart(range.startContainer, range.startOffset - 1);
+      range = (_window$getSelection4 = window.getSelection()) === null || _window$getSelection4 === void 0 ? void 0 : _window$getSelection4.getRangeAt(0).cloneRange();
+      (_range = range) === null || _range === void 0 ? void 0 : _range.setStart(range.startContainer, range.startOffset - 1);
     } catch (e) {
       return offset;
     }
 
     if (range && range.endOffset !== 0 && range.toString() !== '') {
-      offset = getRect(range).right - getRect(this.target).left - (range.startContainer.offsetLeft || 0);
+      offset = getRect(range).right - getRect(this.target).left - (range.startContainer instanceof HTMLElement && range.startContainer.offsetLeft || 0);
     }
 
     return offset;

package/dist/checkbox/checkbox.d.ts

@@ -0,0 +1,41 @@
+import { PureComponent, InputHTMLAttributes, CSSProperties } from 'react';
+import PropTypes from 'prop-types';
+export interface CheckboxProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: string | null | undefined;
+    containerClassName?: string | null | undefined;
+    containerStyle?: CSSProperties | undefined;
+    cellClassName?: string | null | undefined;
+    labelClassName?: string | null | undefined;
+    indeterminate: boolean;
+}
+/**
+ * @name Checkbox
+ */
+/**
+ * Displays a checkbox.
+ */
+export default class Checkbox extends PureComponent<CheckboxProps> {
+    static propTypes: {
+        name: PropTypes.Requireable<string>;
+        label: PropTypes.Requireable<string>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        containerStyle: PropTypes.Requireable<object>;
+        cellClassName: PropTypes.Requireable<string>;
+        labelClassName: PropTypes.Requireable<string>;
+        defaultChecked: PropTypes.Requireable<boolean>;
+        checked: PropTypes.Requireable<boolean>;
+        indeterminate: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static defaultProps: {
+        indeterminate: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CheckboxProps): void;
+    input?: HTMLInputElement | null;
+    inputRef: (el: HTMLInputElement | null) => void;
+    render(): JSX.Element;
+}

package/dist/checkbox/checkbox.js

@@ -24,6 +24,8 @@ class Checkbox extends PureComponent {
   constructor() {
     super(...arguments);
 
+    _defineProperty(this, "input", void 0);
+
     _defineProperty(this, "inputRef", el => {
       if (el != null) {
         el.indeterminate = this.props.indeterminate;
@@ -105,4 +107,8 @@ _defineProperty(Checkbox, "propTypes", {
   children: PropTypes.node
 });
 
+_defineProperty(Checkbox, "defaultProps", {
+  indeterminate: false
+});
+
 export { Checkbox as default };

package/dist/code/code.d.ts

@@ -0,0 +1,43 @@
+import React, { PureComponent, Ref } from 'react';
+import PropTypes from 'prop-types';
+import highlight from 'highlight.js/lib/core';
+declare function noop(): void;
+export interface CodeProps {
+    code: string;
+    inline: boolean;
+    softWrap: boolean;
+    replacer: ((element: HTMLElement | null) => void);
+    className?: string | null | undefined;
+    language?: string | null | undefined;
+    codeRef?: Ref<HTMLElement> | null | undefined;
+}
+/**
+ * @name Code
+ */
+export default class Code extends PureComponent<CodeProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        code: PropTypes.Validator<string>;
+        inline: PropTypes.Requireable<boolean>;
+        softWrap: PropTypes.Requireable<boolean>;
+        language: PropTypes.Requireable<string>;
+        replacer: PropTypes.Requireable<(...args: any[]) => any>;
+        codeRef: PropTypes.Requireable<((...args: any[]) => any) | PropTypes.InferProps<{
+            current: PropTypes.Requireable<Element>;
+        }>>;
+    };
+    static defaultProps: {
+        inline: boolean;
+        softWrap: boolean;
+        replacer: typeof noop;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    code?: HTMLElement | null;
+    highlight(): Promise<void>;
+    get codeRef(): HTMLElement | null | undefined;
+    get initCodeRef(): React.RefObject<HTMLElement> | ((ref: HTMLElement | null) => void);
+    render(): JSX.Element;
+}
+declare const code: (strings: TemplateStringsArray, ...interpolations: unknown[]) => void;
+export { code, highlight };

package/dist/code/code.js

@@ -25,6 +25,12 @@ const registerLanguage = memoize(async language => {
  */
 
 class Code extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "code", void 0);
+  }
+
   componentDidMount() {
     this.highlight();
   }
@@ -49,7 +55,8 @@ class Code extends PureComponent {
     if (!inline) {
       if (language != null && highlight.getLanguage(language) == null) {
         await registerLanguage(language);
-      }
+      } // @ts-expect-error https://github.com/highlightjs/highlight.js/issues/2945
+
 
       highlight.highlightElement(codeRef);
     }
@@ -61,26 +68,23 @@ class Code extends PureComponent {
     const {
       codeRef
     } = this.props;
-    return !codeRef || this.isFunctionCodeRef ? this.code : codeRef.current;
-  }
-
-  get isFunctionCodeRef() {
-    return typeof this.props.codeRef === 'function';
+    return !codeRef || typeof codeRef === 'function' ? this.code : codeRef.current;
   }
 
   get initCodeRef() {
     const {
       codeRef
     } = this.props;
+    const isFunctionCodeRef = typeof codeRef === 'function';
 
-    if (codeRef && !this.isFunctionCodeRef) {
+    if (codeRef && !isFunctionCodeRef) {
       return codeRef;
     }
 
     return ref => {
       this.code = ref;
 
-      if (this.isFunctionCodeRef) {
+      if (isFunctionCodeRef) {
         codeRef(this.code);
       }
     };

package/dist/confirm/confirm.d.ts

@@ -0,0 +1,48 @@
+import React, { PureComponent, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+export interface ConfirmProps {
+    text: string;
+    description: ReactNode;
+    show: boolean;
+    rejectOnEsc: boolean;
+    inProgress: boolean;
+    cancelIsDefault: boolean;
+    confirmLabel: string;
+    rejectLabel: string;
+    onConfirm: ((event: React.MouseEvent<HTMLButtonElement>) => void);
+    onReject: ((event?: React.MouseEvent<HTMLButtonElement>) => void);
+    className?: string | undefined;
+}
+/**
+ * @name Confirm
+ */
+export default class Confirm extends PureComponent<ConfirmProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        text: PropTypes.Requireable<string>;
+        description: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        show: PropTypes.Requireable<boolean>;
+        rejectOnEsc: PropTypes.Requireable<boolean>;
+        inProgress: PropTypes.Requireable<boolean>;
+        cancelIsDefault: PropTypes.Requireable<boolean>;
+        confirmLabel: PropTypes.Requireable<string>;
+        rejectLabel: PropTypes.Requireable<string>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        onReject: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        text: null;
+        description: null;
+        show: boolean;
+        rejectOnEsc: boolean;
+        inProgress: boolean;
+        cancelIsDefault: boolean;
+        confirmLabel: string;
+        rejectLabel: string;
+        onConfirm: () => void;
+        onReject: () => void;
+    };
+    onEscPress: () => void;
+    render(): JSX.Element;
+}
+export declare type ConfirmAttributes = JSX.LibraryManagedAttributes<typeof Confirm, ConfirmProps>;

package/dist/confirm/confirm.js

@@ -2,7 +2,7 @@ import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
 import React, { PureComponent } from 'react';
 import PropTypes from 'prop-types';
 import Dialog from '../dialog/dialog.js';
-import Button from '../button/button.js';
+import ThemedButton from '../button/button.js';
 import '../island/island.js';
 import Panel from '../panel/panel.js';
 import HeaderWrapper from '../island/header.js';
@@ -71,7 +71,7 @@ class Confirm extends PureComponent {
       onReject
     } = this.props;
     return /*#__PURE__*/React.createElement(Dialog, {
-      label: text || description,
+      label: text || (typeof description === 'string' ? description : undefined),
       className: className,
       onEscPress: this.onEscPress,
       show: show,
@@ -79,13 +79,13 @@ class Confirm extends PureComponent {
       "data-test": "ring-confirm"
     }, text && /*#__PURE__*/React.createElement(HeaderWrapper, null, text), /*#__PURE__*/React.createElement(ContentWrapper, null, description && /*#__PURE__*/React.createElement("div", {
       className: modules_4c9c3a3a.description
-    }, description)), /*#__PURE__*/React.createElement(Panel, null, /*#__PURE__*/React.createElement(Button, {
+    }, description)), /*#__PURE__*/React.createElement(Panel, null, /*#__PURE__*/React.createElement(ThemedButton, {
       "data-test": "confirm-ok-button",
       primary: !cancelIsDefault,
       loader: inProgress,
       disabled: inProgress,
       onClick: onConfirm
-    }, confirmLabel), /*#__PURE__*/React.createElement(Button, {
+    }, confirmLabel), /*#__PURE__*/React.createElement(ThemedButton, {
       "data-test": "confirm-reject-button",
       onClick: onReject,
       disabled: inProgress,

package/dist/confirm-service/confirm-service.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * @name Confirm Service
+ */
+export declare const containerElement: HTMLDivElement;
+export interface ConfirmServiceParams {
+    text?: string | undefined;
+    description?: ReactNode;
+    cancelIsDefault?: boolean | undefined;
+    confirmLabel?: string | undefined;
+    rejectLabel?: string | undefined;
+    onBeforeConfirm?: (() => void) | undefined;
+}
+export default function confirm({ text, description, confirmLabel, rejectLabel, cancelIsDefault, onBeforeConfirm }: ConfirmServiceParams): Promise<void>;
+export declare function hideConfirm(): void;

package/dist/content-layout/content-layout.d.ts

@@ -0,0 +1,26 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ContentLayoutProps extends HTMLAttributes<HTMLElement> {
+    responsive: boolean;
+    contentClassName?: string | null | undefined;
+}
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component<ContentLayoutProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        contentClassName: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        responsive: boolean;
+    };
+    state: {
+        contentNode: null;
+    };
+    saveContentNode: (contentNode: HTMLElement | null) => void;
+    render(): JSX.Element;
+}
+export { default as Sidebar } from './sidebar';

package/dist/content-layout/content-layout.js

@@ -14,7 +14,9 @@ class ContentLayout extends Component {
   constructor() {
     super(...arguments);
 
-    _defineProperty(this, "state", {});
+    _defineProperty(this, "state", {
+      contentNode: null
+    });
 
     _defineProperty(this, "saveContentNode", contentNode => {
       this.setState({
@@ -36,7 +38,7 @@ class ContentLayout extends Component {
     });
     const contentClasses = classNames(modules_b8a9dd4f.contentLayoutContent, contentClassName);
     const childrenArray = React.Children.toArray(children);
-    const sidebarChild = childrenArray.filter(child => child && child.type === Sidebar)[0];
+    const sidebarChild = childrenArray.filter(child => child != null && typeof child === 'object' && 'type' in child && child.type === Sidebar)[0];
     const sidebar = sidebarChild && /*#__PURE__*/cloneElement(sidebarChild, {
       contentNode: this.state.contentNode
     });

package/dist/content-layout/sidebar.d.ts

@@ -0,0 +1,31 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Waypoint } from 'react-waypoint';
+export interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    right?: boolean | null | undefined;
+    containerClassName?: string | null | undefined;
+    fixedClassName?: string | null | undefined;
+    contentNode?: HTMLElement | null | undefined;
+}
+export default class Sidebar extends Component<SidebarProps> {
+    static propTypes: {
+        right: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        fixedClassName: PropTypes.Requireable<string>;
+        contentNode: PropTypes.Requireable<object>;
+    };
+    state: {
+        topIsOutside: boolean;
+        bottomIsOutside: boolean;
+        sidebarVisibleHeight: undefined;
+    };
+    sidebarNode?: HTMLElement | null;
+    handleTopWaypoint: ({ currentPosition }: Waypoint.CallbackArgs) => void;
+    handleBottomWaypoint: ({ currentPosition, waypointTop }: Waypoint.CallbackArgs) => void;
+    shouldUseFixation(): boolean;
+    shouldFixateBottom(): boolean;
+    sidebarRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/dist/contenteditable/contenteditable.d.ts

@@ -0,0 +1,47 @@
+import { Component, HTMLAttributes, Ref } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name ContentEditable
+ */
+declare function noop(): void;
+export interface ContentEditableBaseProps extends HTMLAttributes<HTMLElement> {
+    disabled: boolean;
+    onComponentUpdate: ((prevProps: ContentEditableBaseProps) => void);
+    inputRef?: Ref<HTMLDivElement> | null | undefined;
+    __html: string;
+}
+declare class ContentEditableBase extends Component<ContentEditableBaseProps> {
+    static propTypes: {
+        __html: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        disabled: boolean;
+        tabIndex: number;
+        onInput: typeof noop;
+        onComponentUpdate: typeof noop;
+    };
+    shouldComponentUpdate(nextProps: ContentEditableBaseProps): boolean;
+    componentDidUpdate(prevProps: ContentEditableBaseProps): void;
+    render(): JSX.Element;
+}
+declare type ContentEditableBaseAttrs = JSX.LibraryManagedAttributes<typeof ContentEditableBase, ContentEditableBaseProps>;
+export declare type ContentEditableProps = Omit<ContentEditableBaseAttrs, '__html'>;
+declare const ContentEditable: {
+    ({ children, ...props }: ContentEditableProps): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+};
+export default ContentEditable;

package/dist/contenteditable/contenteditable.js

@@ -23,8 +23,8 @@ class ContentEditableBase extends Component {
     return nextProps.disabled !== this.props.disabled || nextProps.__html !== this.props.__html;
   }
 
-  componentDidUpdate(prevProps, prevState) {
-    this.props.onComponentUpdate(prevProps, prevState);
+  componentDidUpdate(prevProps) {
+    this.props.onComponentUpdate(prevProps);
   }
 
   render() {
@@ -37,10 +37,12 @@ class ContentEditableBase extends Component {
       ...props
     } = this.props;
     return /*#__PURE__*/React.createElement("div", _extends({}, props, {
-      ref: inputRef,
+      ref: inputRef // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      ,
       disabled: disabled,
       role: "textbox",
-      tabIndex: disabled ? null : tabIndex,
+      tabIndex: disabled ? undefined : tabIndex,
       contentEditable: !this.props.disabled,
       dangerouslySetInnerHTML: {
         __html