carbon-react 118.2.0 → 118.3.0

package/esm/components/text-editor/__internal__/editor-counter/editor-counter.component.js

@@ -10,7 +10,6 @@ const Counter = ({
   warning,
   info
 }) => /*#__PURE__*/React.createElement(StyledCounterWrapper, {
-  hasIcon: !!(error || warning || info),
   "data-component": "text-editor-counter"
 }, !!(error || warning || info) && /*#__PURE__*/React.createElement(ValidationIcon, {
   error: error,
@@ -23,19 +22,10 @@ const Counter = ({
 }, `${limit - count}`));
 
 Counter.propTypes = {
-  /** Sets the current count value */
-  count: PropTypes.number,
-
-  /** Sets the current limit value */
-  limit: PropTypes.number,
-
-  /** Message to be displayed when there is an error */
-  error: PropTypes.string,
-
-  /** Message to be displayed when there is a warning */
-  warning: PropTypes.string,
-
-  /** Message to be displayed when there is an info */
-  info: PropTypes.string
+  "count": PropTypes.number,
+  "error": PropTypes.string,
+  "info": PropTypes.string,
+  "limit": PropTypes.number,
+  "warning": PropTypes.string
 };
 export default Counter;

package/esm/components/text-editor/__internal__/editor-counter/editor-counter.style.d.ts

@@ -0,0 +1,5 @@
+declare const StyledCounter: import("styled-components").StyledComponent<"span", any, {
+    hasError: boolean;
+}, never>;
+declare const StyledCounterWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export { StyledCounter, StyledCounterWrapper };

package/esm/components/text-editor/__internal__/editor-counter/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./editor-counter";
-export * from "./editor-counter";
+export { default } from "./editor-counter.component";
+export type { EditorCounterProps } from "./editor-counter.component";

package/esm/components/text-editor/__internal__/editor-link/editor-link.component.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { ContentState } from "draft-js";
+export interface EditorLinkProps {
+    children: React.ReactElement[];
+    contentState?: ContentState;
+    entityKey?: string;
+}
+declare const EditorLink: ({ children, contentState, entityKey, ...rest }: EditorLinkProps) => JSX.Element;
+export default EditorLink;

package/esm/components/text-editor/__internal__/editor-link/editor-link.component.js

@@ -32,7 +32,6 @@ const EditorLink = ({
   }, [validUrl]);
   return /*#__PURE__*/React.createElement(StyledLink, _extends({
     href: !editMode ? validUrl : undefined,
-    title: validUrl,
     "aria-label": !editMode ? validUrl : undefined,
     target: "_blank",
     rel: "noopener noreferrer"
@@ -40,8 +39,8 @@ const EditorLink = ({
 };
 
 EditorLink.propTypes = {
-  children: PropTypes.node.isRequired,
-  contentState: PropTypes.object,
-  entityKey: PropTypes.string
+  "children": PropTypes.arrayOf(PropTypes.element).isRequired,
+  "contentState": PropTypes.object,
+  "entityKey": PropTypes.string
 };
 export default EditorLink;

package/esm/components/text-editor/__internal__/editor-link/editor-link.style.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const StyledEditorLink: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("../../../link").LinkProps & import("react").RefAttributes<HTMLButtonElement | HTMLLinkElement>>, any, {}, never>;
+export default StyledEditorLink;

package/esm/components/text-editor/__internal__/editor-link/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./editor-link";
-export * from "./editor-link";
+export { default } from "./editor-link.component";
+export type { EditorLinkProps } from "./editor-link.component";

package/esm/components/text-editor/__internal__/label-wrapper/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./label-wrapper";
-export * from "./label-wrapper";
+export { default } from "./label-wrapper.component";
+export type { LabelWrapperProps } from "./label-wrapper.component";

package/esm/components/text-editor/__internal__/label-wrapper/label-wrapper.component.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+/**
+ * TextEditor component is composed with divs and spans.
+ * We have to manually trigger focus on TextEditor by clicking on label component.
+ * This wrapper allows us to trigger focus on TextEditor
+ */
+export interface LabelWrapperProps {
+    children: React.ReactNode;
+    onClick: (event: React.MouseEvent<HTMLSpanElement>) => void;
+}
+declare const LabelWrapper: ({ onClick, children }: LabelWrapperProps) => JSX.Element;
+export default LabelWrapper;

package/esm/components/text-editor/__internal__/label-wrapper/label-wrapper.component.js

@@ -2,13 +2,14 @@
 
 /* eslint-disable jsx-a11y/no-static-element-interactions */
 import React from "react";
-import PropTypes from "prop-types";
 /**
  * TextEditor component is composed with divs and spans.
  * We have to manually trigger focus on TextEditor by clicking on label component.
  * This wrapper allows us to trigger focus on TextEditor
  */
 
+import PropTypes from "prop-types";
+
 const LabelWrapper = ({
   onClick,
   children
@@ -19,7 +20,7 @@ const LabelWrapper = ({
 };
 
 LabelWrapper.propTypes = {
-  onClick: PropTypes.func.isRequired,
-  children: PropTypes.node.isRequired
+  "children": PropTypes.node,
+  "onClick": PropTypes.func.isRequired
 };
 export default LabelWrapper;

package/esm/components/text-editor/__internal__/toolbar/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./toolbar";
-export * from "./toolbar";
+export { default } from "./toolbar.component";
+export type { ToolbarProps } from "./toolbar.component";

package/esm/components/text-editor/__internal__/toolbar/toolbar-button/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./toolbar-button";
-export * from "./toolbar-button";
+export { default } from "./toolbar-button.component";
+export type { ToolbarButtonProps } from "./toolbar-button.component";

package/esm/components/text-editor/__internal__/toolbar/toolbar-button/toolbar-button.component.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+export interface ToolbarButtonProps {
+    /** Accessibility label for a button */
+    ariaLabel: string;
+    /** The children for the button */
+    children: React.ReactNode;
+    /** Used to control the button's active status */
+    activated?: boolean;
+    /** Callback to handle any keydown events on a button */
+    onKeyDown: (ev: React.KeyboardEvent<HTMLButtonElement>) => void;
+    /** Callback to handle any mousedown events on a button */
+    onMouseDown: (ev: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Callback to handle any mouseover events on a button */
+    onMouseOver?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Callback to handle any mouseleave events on a button */
+    onMouseLeave?: (ev: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Callback to handle any focus events on a button */
+    onFocus?: (ev: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Callback to handle any blur events on a button */
+    onBlur?: (ev: React.FocusEvent<HTMLButtonElement>) => void;
+    /** Controls whether the button can be tabbed to */
+    tabbable?: boolean;
+}
+export declare const ToolbarButton: React.ForwardRefExoticComponent<ToolbarButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default ToolbarButton;

package/esm/components/text-editor/__internal__/toolbar/toolbar-button/toolbar-button.component.js

@@ -25,8 +25,6 @@ const ToolbarButton = /*#__PURE__*/React.forwardRef(({
   }, !tabbable && {
     tabIndex: -1
   }, {
-    activated: activated,
-    tabbable: tabbable,
     onMouseOver: onMouseOver,
     onMouseLeave: onMouseLeave,
     onFocus: onFocus,
@@ -34,26 +32,17 @@ const ToolbarButton = /*#__PURE__*/React.forwardRef(({
   }), children);
 });
 ToolbarButton.propTypes = {
-  /** Accessibility label for a button */
-  ariaLabel: PropTypes.string.isRequired,
-
-  /** The children for the button */
-  children: PropTypes.oneOfType([PropTypes.node, PropTypes.array]).isRequired,
-
-  /** Used to control the button's active status */
-  activated: PropTypes.bool,
-
-  /** Callback to handle any keydown events on a button */
-  onKeyDown: PropTypes.func.isRequired,
-
-  /** Callback to handle any mouse down events on a button */
-  onMouseDown: PropTypes.func.isRequired,
-
-  /** Controls whether the button can be tabbed to */
-  tabbable: PropTypes.bool,
-  onMouseOver: PropTypes.func,
-  onMouseLeave: PropTypes.func,
-  onFocus: PropTypes.func,
-  onBlur: PropTypes.func
+  "activated": PropTypes.bool,
+  "ariaLabel": PropTypes.string.isRequired,
+  "children": PropTypes.node,
+  "onBlur": PropTypes.func,
+  "onFocus": PropTypes.func,
+  "onKeyDown": PropTypes.func.isRequired,
+  "onMouseDown": PropTypes.func.isRequired,
+  "onMouseLeave": PropTypes.func,
+  "onMouseOver": PropTypes.func,
+  "tabbable": PropTypes.bool
 };
+export { ToolbarButton };
+ToolbarButton.displayName = "ToolbarButton";
 export default ToolbarButton;

package/esm/components/text-editor/__internal__/toolbar/toolbar-button/toolbar-button.style.d.ts

@@ -0,0 +1,6 @@
+declare const StyledToolbarButton: import("styled-components").StyledComponent<"button", any, {
+    type: "button";
+} & {
+    isActive?: boolean | undefined;
+}, "type">;
+export default StyledToolbarButton;

package/esm/components/text-editor/__internal__/toolbar/toolbar.component.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { InlineStyleType, BlockType } from "../../types";
+export interface ToolbarProps {
+    /** Used to override the active status of the inline controls */
+    activeControls: Record<InlineStyleType | BlockType, boolean>;
+    /** Flag to trigger control focusing */
+    canFocus?: boolean;
+    /** Callback to handle setting the inline styles */
+    setInlineStyle: (ev: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement>, inlineType: InlineStyleType) => void;
+    /** Callback to handle setting the block styles */
+    setBlockStyle: (ev: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement>, blockType: BlockType) => void;
+    /** Additional elements to be rendered in the Toolbar, e.g. Save and Cancel Button */
+    toolbarElements?: React.ReactNode;
+}
+declare const Toolbar: ({ activeControls, canFocus, toolbarElements, setBlockStyle, setInlineStyle, }: ToolbarProps) => JSX.Element;
+export default Toolbar;

package/esm/components/text-editor/__internal__/toolbar/toolbar.component.js

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useRef, useState } from "react";
+import React, { useCallback, useEffect, useState, useRef } from "react";
 import PropTypes from "prop-types";
 import { StyledToolbar, StyledEditorStyleControls, StyledEditorActionControls } from "./toolbar.style";
 import ToolbarButton from "./toolbar-button";
@@ -6,10 +6,7 @@ import Events from "../../../../__internal__/utils/helpers/events";
 import Icon from "../../../icon";
 import Tooltip from "../../../tooltip";
 import useLocale from "../../../../hooks/__internal__/useLocale";
-const BOLD = "BOLD";
-const ITALIC = "ITALIC";
-const UNORDERED_LIST = "unordered-list-item";
-const ORDERED_LIST = "ordered-list-item";
+import { BOLD, ITALIC, UNORDERED_LIST, ORDERED_LIST } from "../../types";
 
 const Toolbar = ({
   activeControls,
@@ -25,8 +22,8 @@ const Toolbar = ({
     tooltipMessages,
     ariaLabels
   } = textEditor;
-  const controlRefs = [useRef(), useRef(), useRef(), useRef()];
-  const [focusIndex, setFocusIndex] = useState(0);
+  const controlRefs = useRef([/*#__PURE__*/React.createRef(), /*#__PURE__*/React.createRef(), /*#__PURE__*/React.createRef(), /*#__PURE__*/React.createRef()]);
+  const [focusIndex, setFocusIndex] = useState(null);
   const [tabbable, setTabbable] = useState(true);
   const [activeTooltip, setActiveTooltip] = useState("");
   const handleInlineStyleChange = useCallback((ev, inlineType) => {
@@ -39,7 +36,7 @@ const Toolbar = ({
     if (Events.isTabKey(ev)) {
       setFocusIndex(null);
     } else if (Events.isSpaceKey(ev) || Events.isEnterKey(ev)) {
-      if ([BOLD, ITALIC].includes(type)) {
+      if (type === BOLD || type === ITALIC) {
         handleInlineStyleChange(ev, type);
       } else {
         handleBlockType(ev, type);
@@ -49,26 +46,35 @@ const Toolbar = ({
       setTabbable(true);
     } else if (Events.isLeftKey(ev)) {
       if (focusIndex === null || focusIndex === 0) {
-        controlRefs[3].current.focus();
+        var _controlRefs$current$;
+
+        (_controlRefs$current$ = controlRefs.current[3].current) === null || _controlRefs$current$ === void 0 ? void 0 : _controlRefs$current$.focus();
         setFocusIndex(3);
       } else {
-        controlRefs[focusIndex - 1].current.focus();
+        var _controlRefs$current$2;
+
+        (_controlRefs$current$2 = controlRefs.current[focusIndex - 1].current) === null || _controlRefs$current$2 === void 0 ? void 0 : _controlRefs$current$2.focus();
         setFocusIndex(focusIndex - 1);
       }
 
       setTabbable(false);
     } else if (Events.isRightKey(ev)) {
       if (focusIndex === 3) {
-        controlRefs[0].current.focus();
+        var _controlRefs$current$3;
+
+        (_controlRefs$current$3 = controlRefs.current[0].current) === null || _controlRefs$current$3 === void 0 ? void 0 : _controlRefs$current$3.focus();
         setFocusIndex(0);
       } else {
-        controlRefs[focusIndex + 1].current.focus();
-        setFocusIndex(focusIndex + 1);
+        var _controlRefs$current$4;
+
+        const currentIndex = focusIndex === null ? 0 : focusIndex;
+        (_controlRefs$current$4 = controlRefs.current[currentIndex + 1].current) === null || _controlRefs$current$4 === void 0 ? void 0 : _controlRefs$current$4.focus();
+        setFocusIndex(currentIndex + 1);
       }
 
       setTabbable(false);
     }
-  }, [controlRefs, focusIndex, handleBlockType, handleInlineStyleChange]);
+  }, [focusIndex, handleBlockType, handleInlineStyleChange]);
   useEffect(() => {
     if (focusIndex === null) {
       setTabbable(true);
@@ -79,13 +85,15 @@ const Toolbar = ({
       setFocusIndex(null);
     }
   }, [canFocus]);
-  const isTabbable = useCallback(index => {
-    if (!controlRefs[index] || !controlRefs[index].current) {
+
+  const isTabbable = index => {
+    if (!controlRefs.current[index] || !controlRefs.current[index].current) {
       return false;
     }
 
-    return controlRefs[index].current === document.activeElement;
-  }, [controlRefs]);
+    return controlRefs.current[index].current === document.activeElement;
+  };
+
   return /*#__PURE__*/React.createElement(StyledToolbar, {
     "data-component": "text-editor-toolbar"
   }, /*#__PURE__*/React.createElement(StyledEditorStyleControls, null, /*#__PURE__*/React.createElement(Tooltip, {
@@ -97,7 +105,7 @@ const Toolbar = ({
     onKeyDown: ev => handleKeyDown(ev, BOLD),
     onMouseDown: ev => handleInlineStyleChange(ev, BOLD),
     activated: activeControls.BOLD,
-    ref: controlRefs[0],
+    ref: controlRefs.current[0],
     tabbable: tabbable,
     onMouseOver: () => setActiveTooltip("Bold"),
     onMouseLeave: () => setActiveTooltip(""),
@@ -114,7 +122,7 @@ const Toolbar = ({
     onKeyDown: ev => handleKeyDown(ev, ITALIC),
     onMouseDown: ev => handleInlineStyleChange(ev, ITALIC),
     activated: activeControls.ITALIC,
-    ref: controlRefs[1],
+    ref: controlRefs.current[1],
     tabbable: isTabbable(1),
     onMouseOver: () => setActiveTooltip("Italic"),
     onMouseLeave: () => setActiveTooltip(""),
@@ -131,7 +139,7 @@ const Toolbar = ({
     onKeyDown: ev => handleKeyDown(ev, UNORDERED_LIST),
     onMouseDown: ev => handleBlockType(ev, UNORDERED_LIST),
     activated: activeControls[UNORDERED_LIST],
-    ref: controlRefs[2],
+    ref: controlRefs.current[2],
     tabbable: isTabbable(2),
     onMouseOver: () => setActiveTooltip("Bulleted List"),
     onMouseLeave: () => setActiveTooltip(""),
@@ -148,7 +156,7 @@ const Toolbar = ({
     onKeyDown: ev => handleKeyDown(ev, ORDERED_LIST),
     onMouseDown: ev => handleBlockType(ev, ORDERED_LIST),
     activated: activeControls[ORDERED_LIST],
-    ref: controlRefs[3],
+    ref: controlRefs.current[3],
     tabbable: isTabbable(3),
     onMouseOver: () => setActiveTooltip("Numbered List"),
     onMouseLeave: () => setActiveTooltip(""),
@@ -160,19 +168,15 @@ const Toolbar = ({
 };
 
 Toolbar.propTypes = {
-  /** Used to override the active status of the inline controls */
-  activeControls: PropTypes.object.isRequired,
-
-  /** Flag to trigger control focusing */
-  canFocus: PropTypes.bool,
-
-  /** Callback to handle setting the inline styles */
-  setInlineStyle: PropTypes.func.isRequired,
-
-  /** Callback to handle setting the block styles */
-  setBlockStyle: PropTypes.func.isRequired,
-
-  /** Additional elements to be rendered in the Toolbar, e.g. Save and Cancel Button */
-  toolbarElements: PropTypes.node
+  "activeControls": PropTypes.shape({
+    "BOLD": PropTypes.bool.isRequired,
+    "ITALIC": PropTypes.bool.isRequired,
+    "ordered-list-item": PropTypes.bool.isRequired,
+    "unordered-list-item": PropTypes.bool.isRequired
+  }).isRequired,
+  "canFocus": PropTypes.bool,
+  "setBlockStyle": PropTypes.func.isRequired,
+  "setInlineStyle": PropTypes.func.isRequired,
+  "toolbarElements": PropTypes.node
 };
 export default Toolbar;

package/esm/components/text-editor/__internal__/toolbar/toolbar.style.d.ts

@@ -0,0 +1,4 @@
+declare const StyledToolbar: import("styled-components").StyledComponent<"div", any, {}, never>;
+declare const StyledEditorStyleControls: import("styled-components").StyledComponent<"div", any, {}, never>;
+declare const StyledEditorActionControls: import("styled-components").StyledComponent<"div", any, {}, never>;
+export { StyledToolbar, StyledEditorActionControls, StyledEditorStyleControls };

package/esm/components/text-editor/__internal__/utils/index.d.ts

@@ -1 +1 @@
-export { computeBlockType, getContent, getContentInfo, getDecoratedValue, getSelection, getSelectionInfo, getSelectedLength, moveSelectionToEnd, resetBlockType, isASCIIChar, replaceText, hasBlockStyle, hasInlineStyle, blockStyleFn } from "./utils";
+export { computeBlockType, getContent, getContentInfo, getDecoratedValue, getSelection, getSelectionInfo, getSelectedLength, moveSelectionToEnd, resetBlockType, isASCIIChar, replaceText, hasBlockStyle, hasInlineStyle, blockStyleFn, } from "./utils";

package/esm/components/text-editor/__internal__/utils/utils.d.ts

@@ -1,28 +1,29 @@
-export function blockStyleFn(block: any): "" | "text-editor-block-unordered" | "text-editor-block-ordered";
-export function hasBlockStyle(value: any, type: any): boolean;
-export function hasInlineStyle(value: any, style: any): any;
-export function isASCIIChar(str: any): boolean;
-export function replaceText(editorState: any, text: any, inlineStyle: any, forceSelection: any): EditorState;
-export function computeBlockType(char: any, type: any): "ordered-list-item" | "unordered-list-item" | "unstyled";
-export function resetBlockType(value: any, newType?: string): EditorState;
-export function getDecoratedValue(value: any): EditorState;
-export function getContent(value: any): any;
-export function getSelection(value: any): any;
-export function getContentInfo(value: any): {
-    content: any;
-    currentBlock: any;
-    blockType: any;
-    blockLength: any;
-    blockText: any;
-    blockMap: any;
+import { EditorState, ContentBlock, DraftInlineStyle, ContentState } from "draft-js";
+import { BlockType, InlineStyleType } from "../../types";
+export declare const computeBlockType: (char: string, type: string) => "unordered-list-item" | "ordered-list-item" | "unstyled";
+export declare const resetBlockType: (value: EditorState, newType?: BlockType | "unstyled") => EditorState;
+export declare function blockStyleFn(block: ContentBlock): "" | "text-editor-block-unordered" | "text-editor-block-ordered";
+export declare const getDecoratedValue: (value: EditorState) => EditorState;
+export declare const getContent: (value: EditorState) => ContentState;
+export declare const getSelection: (value: EditorState) => Draft.Model.ImmutableData.SelectionState;
+export declare const getContentInfo: (value: EditorState) => {
+    content: ContentState;
+    currentBlock: ContentBlock;
+    blockType: string;
+    blockLength: number;
+    blockText: string;
+    blockMap: Draft.Model.ImmutableData.BlockMap;
 };
-export function getSelectionInfo(value: any): {
-    selection: any;
-    startKey: any;
-    endKey: any;
-    startOffset: any;
-    endOffset: any;
+export declare const getSelectionInfo: (value: EditorState) => {
+    selection: Draft.Model.ImmutableData.SelectionState;
+    startKey: string;
+    endKey: string;
+    startOffset: number;
+    endOffset: number;
 };
-export function moveSelectionToEnd(value: any): EditorState;
-export function getSelectedLength(value: any): number;
-import { EditorState } from "draft-js";
+export declare const moveSelectionToEnd: (value: EditorState) => EditorState;
+export declare const getSelectedLength: (value: EditorState) => number;
+export declare function hasBlockStyle(value: EditorState, type: BlockType): boolean;
+export declare function hasInlineStyle(value: EditorState, style: InlineStyleType): boolean;
+export declare function isASCIIChar(str: string): boolean;
+export declare function replaceText(editorState: EditorState, text: string, inlineStyle: DraftInlineStyle): EditorState;

package/esm/components/text-editor/__internal__/utils/utils.js

@@ -1,14 +1,13 @@
 import { EditorState, Modifier } from "draft-js";
 import decorators from "../decorators";
-const ORDERLIST_TYPE = "ordered-list-item";
-const UNORDERLIST_TYPE = "unordered-list-item";
+import { ORDERED_LIST, UNORDERED_LIST } from "../../types";
 export const computeBlockType = (char, type) => {
-  if (char === "." && type !== ORDERLIST_TYPE) {
-    return ORDERLIST_TYPE;
+  if (char === "." && type !== ORDERED_LIST) {
+    return ORDERED_LIST;
   }
 
-  if (char === "*" && type !== UNORDERLIST_TYPE) {
-    return UNORDERLIST_TYPE;
+  if (char === "*" && type !== UNORDERED_LIST) {
+    return UNORDERED_LIST;
   }
 
   return "unstyled";
@@ -19,10 +18,10 @@ Returns default block-level metadata for various block type. Empty object otherw
 
 const getDefaultBlockData = (blockType, initialData = {}) => {
   switch (blockType) {
-    case ORDERLIST_TYPE:
+    case ORDERED_LIST:
       return {};
 
-    case UNORDERLIST_TYPE:
+    case UNORDERED_LIST:
       return {};
 
     default:
@@ -181,7 +180,7 @@ export function hasInlineStyle(value, style) {
 export function isASCIIChar(str) {
   return /^\S+$/.test(str);
 }
-export function replaceText(editorState, text, inlineStyle, forceSelection) {
+export function replaceText(editorState, text, inlineStyle) {
   const contentState = Modifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), text, inlineStyle);
-  return EditorState.push(editorState, contentState, "insert-characters", forceSelection);
+  return EditorState.push(editorState, contentState, "insert-characters");
 }

package/esm/components/text-editor/index.d.ts

@@ -1,2 +1,2 @@
-export { default } from "./text-editor";
-export * from "./text-editor";
+export { default, TextEditorState as EditorState, TextEditorContentState as ContentState, } from "./text-editor.component";
+export type { TextEditorProps } from "./text-editor.component";

package/esm/components/text-editor/text-editor.component.d.ts

@@ -1,8 +1,37 @@
-export const EditorContext: React.Context<{}>;
-export const TextEditorState: typeof EditorState;
-export const TextEditorContentState: typeof ContentState;
-export default TextEditor;
 import React from "react";
-import { EditorState } from "draft-js";
-import { ContentState } from "draft-js";
-declare const TextEditor: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+import { MarginProps } from "styled-system";
+import { ContentState, EditorState, Editor } from "draft-js";
+export declare const EditorContext: React.Context<{
+    onLinkAdded?: ((url: string) => void) | undefined;
+    editMode?: boolean | undefined;
+}>;
+export interface TextEditorProps extends MarginProps {
+    /** The maximum characters that the input will accept */
+    characterLimit?: number;
+    /** The text for the editor's label */
+    labelText: string;
+    /** onChange callback to control value updates */
+    onChange: (event: EditorState) => void;
+    /** Additional elements to be rendered in the Editor Toolbar, e.g. Save and Cancel Button */
+    toolbarElements?: React.ReactNode;
+    /** The value of the input, this is an EditorState immutable object */
+    value: EditorState;
+    /** Flag to configure component as mandatory */
+    required?: boolean;
+    /** Message to be displayed when there is an error */
+    error?: string;
+    /** Message to be displayed when there is a warning */
+    warning?: string;
+    /** Message to be displayed when there is an info */
+    info?: string;
+    /** Number greater than 2 multiplied by line-height (21px) to override the default min-height of the editor */
+    rows?: number;
+    /** The previews to display of any links added to the Editor */
+    previews?: React.ReactNode;
+    /** Callback to report a url when a link is added */
+    onLinkAdded?: (url: string) => void;
+}
+export declare const TextEditor: React.ForwardRefExoticComponent<TextEditorProps & React.RefAttributes<Editor>>;
+export declare const TextEditorState: typeof EditorState;
+export declare const TextEditorContentState: typeof ContentState;
+export default TextEditor;