| import getDirection from 'direction' |
| import React, { useCallback } from 'react' |
| import { JSX } from 'react' |
| import { Editor, Element as SlateElement, Node, DecoratedRange } from 'slate' |
| import { ReactEditor, useReadOnly, useSlateStatic } from '..' |
| import useChildren from '../hooks/use-children' |
| import { isElementDecorationsEqual } from 'slate-dom' |
| import { |
| EDITOR_TO_KEY_TO_ELEMENT, |
| ELEMENT_TO_NODE, |
| NODE_TO_ELEMENT, |
| NODE_TO_INDEX, |
| NODE_TO_PARENT, |
| } from 'slate-dom' |
| import { |
| RenderChunkProps, |
| RenderElementProps, |
| RenderLeafProps, |
| RenderPlaceholderProps, |
| RenderTextProps, |
| } from './editable' |
|
|
| import Text from './text' |
| import { useDecorations } from '../hooks/use-decorations' |
|
|
| const defaultRenderElement = (props: RenderElementProps) => ( |
| <DefaultElement {...props} /> |
| ) |
|
|
| |
| |
| |
|
|
| const Element = (props: { |
| decorations: DecoratedRange[] |
| element: SlateElement |
| renderElement?: (props: RenderElementProps) => JSX.Element |
| renderChunk?: (props: RenderChunkProps) => JSX.Element |
| renderPlaceholder: (props: RenderPlaceholderProps) => JSX.Element |
| renderText?: (props: RenderTextProps) => JSX.Element |
| renderLeaf?: (props: RenderLeafProps) => JSX.Element |
| }) => { |
| const { |
| decorations: parentDecorations, |
| element, |
| renderElement = defaultRenderElement, |
| renderChunk, |
| renderPlaceholder, |
| renderLeaf, |
| renderText, |
| } = props |
| const editor = useSlateStatic() |
| const readOnly = useReadOnly() |
| const isInline = editor.isInline(element) |
| const decorations = useDecorations(element, parentDecorations) |
| const key = ReactEditor.findKey(editor, element) |
| const ref = useCallback( |
| (ref: HTMLElement | null) => { |
| |
| const KEY_TO_ELEMENT = EDITOR_TO_KEY_TO_ELEMENT.get(editor) |
| if (ref) { |
| KEY_TO_ELEMENT?.set(key, ref) |
| NODE_TO_ELEMENT.set(element, ref) |
| ELEMENT_TO_NODE.set(ref, element) |
| } else { |
| KEY_TO_ELEMENT?.delete(key) |
| NODE_TO_ELEMENT.delete(element) |
| } |
| }, |
| [editor, key, element] |
| ) |
| let children: React.ReactNode = useChildren({ |
| decorations, |
| node: element, |
| renderElement, |
| renderChunk, |
| renderPlaceholder, |
| renderLeaf, |
| renderText, |
| }) |
|
|
| |
| |
| const attributes: { |
| 'data-slate-node': 'element' |
| 'data-slate-void'?: true |
| 'data-slate-inline'?: true |
| contentEditable?: false |
| dir?: 'rtl' |
| ref: any |
| } = { |
| 'data-slate-node': 'element', |
| ref, |
| } |
|
|
| if (isInline) { |
| attributes['data-slate-inline'] = true |
| } |
|
|
| |
| |
| if (!isInline && Editor.hasInlines(editor, element)) { |
| const text = Node.string(element) |
| const dir = getDirection(text) |
|
|
| if (dir === 'rtl') { |
| attributes.dir = dir |
| } |
| } |
|
|
| |
| if (Editor.isVoid(editor, element)) { |
| attributes['data-slate-void'] = true |
|
|
| if (!readOnly && isInline) { |
| attributes.contentEditable = false |
| } |
|
|
| const Tag = isInline ? 'span' : 'div' |
| const [[text]] = Node.texts(element) |
|
|
| children = ( |
| <Tag |
| data-slate-spacer |
| style={{ |
| height: '0', |
| color: 'transparent', |
| outline: 'none', |
| position: 'absolute', |
| }} |
| > |
| <Text |
| renderPlaceholder={renderPlaceholder} |
| decorations={[]} |
| isLast={false} |
| parent={element} |
| text={text} |
| /> |
| </Tag> |
| ) |
|
|
| NODE_TO_INDEX.set(text, 0) |
| NODE_TO_PARENT.set(text, element) |
| } |
|
|
| return renderElement({ attributes, children, element }) |
| } |
|
|
| const MemoizedElement = React.memo(Element, (prev, next) => { |
| return ( |
| prev.element === next.element && |
| prev.renderElement === next.renderElement && |
| prev.renderChunk === next.renderChunk && |
| prev.renderText === next.renderText && |
| prev.renderLeaf === next.renderLeaf && |
| prev.renderPlaceholder === next.renderPlaceholder && |
| isElementDecorationsEqual(prev.decorations, next.decorations) |
| ) |
| }) |
|
|
| |
| |
| |
|
|
| export const DefaultElement = (props: RenderElementProps) => { |
| const { attributes, children, element } = props |
| const editor = useSlateStatic() |
| const Tag = editor.isInline(element) ? 'span' : 'div' |
| return ( |
| <Tag {...attributes} style={{ position: 'relative' }}> |
| {children} |
| </Tag> |
| ) |
| } |
|
|
| export default MemoizedElement |
|
|
