Defining Custom Elements

in our previous example, we started with a paragraph, but we never actually told slate anything about the paragraph block type we just let it use its internal default renderer, which uses a plain old \<div> but that's not all you can do slate lets you define any type of custom blocks you want, like block quotes, code blocks, list items, etc we'll show you how let's start with our app from earlier const app = () => { const editor = usememo(() => withreact(createeditor()), \[]) const \[value, setvalue] = usestate(\[ { type 'paragraph', children \[{ text 'a line of text in a paragraph ' }], }, ]) return ( \<slate editor={editor} value={value} onchange={value => setvalue(value)}> \<editable onkeydown={event => { if (event key === '&') { event preventdefault() editor inserttext('and') } }} /> \</slate> ) } now let's add "code blocks" to our editor the problem is, code blocks won't just be rendered as a plain paragraph, they'll need to be rendered differently to make that happen, we need to define a "renderer" for code element nodes element renderers are just simple react components, like so // define a react component renderer for our code blocks const codeelement = props => { return ( \<pre { props attributes}> \<code>{props children}\</code> \</pre> ) } easy enough see the props attributes reference? slate passes attributes that should be rendered on the top most element of your blocks, so that you don't have to build them up yourself you must mix the attributes into your component and see that props children reference? slate will automatically render all of the children of a block for you, and then pass them to you just like any other react component would, via props children that way you don't have to muck around with rendering the proper text nodes or anything like that you must render the children as the lowest leaf in your component and here's a component for the "default" elements const defaultelement = props => { return \<p { props attributes}>{props children}\</p> } now, let's add that renderer to our editor const app = () => { const editor = usememo(() => withreact(createeditor()), \[]) const \[value, setvalue] = usestate(\[ { type 'paragraph', children \[{ text 'a line of text in a paragraph ' }], }, ]) // define a rendering function based on the element passed to `props` we use // `usecallback` here to memoize the function for subsequent renders const renderelement = usecallback(props => { switch (props element type) { case 'code' return \<codeelement { props} /> default return \<defaultelement { props} /> } }, \[]) return ( \<slate editor={editor} value={value} onchange={value => setvalue(value)}> \<editable // pass in the `renderelement` function renderelement={renderelement} onkeydown={event => { if (event key === '&') { event preventdefault() editor inserttext('and') } }} /> \</slate> ) } const codeelement = props => { return ( \<pre { props attributes}> \<code>{props children}\</code> \</pre> ) } const defaultelement = props => { return \<p { props attributes}>{props children}\</p> } okay, but now we'll need a way for the user to actually turn a block into a code block so let's change our onkeydown function to add a ``ctrl ``` shortcut that does just that // import the `editor` and `transforms` helpers from slate import { editor, transforms } from 'slate' const app = () => { const editor = usememo(() => withreact(createeditor()), \[]) const \[value, setvalue] = usestate(\[ { type 'paragraph', children \[{ text 'a line of text in a paragraph ' }], }, ]) const renderelement = usecallback(props => { switch (props element type) { case 'code' return \<codeelement { props} /> default return \<defaultelement { props} /> } }, \[]) return ( \<slate editor={editor} value={value} onchange={value => setvalue(value)}> \<editable renderelement={renderelement} onkeydown={event => { if (event key === '`' && event ctrlkey) { // prevent the "`" from being inserted by default event preventdefault() // otherwise, set the currently selected blocks type to "code" transforms setnodes( editor, { type 'code' }, { match n => editor isblock(editor, n) } ) } }} /> \</slate> ) } const codeelement = props => { return ( \<pre { props attributes}> \<code>{props children}\</code> \</pre> ) } const defaultelement = props => { return \<p { props attributes}>{props children}\</p> } now, if you press ``ctrl ``` the block your cursor is in should turn into a code block! magic! but we forgot one thing when you hit ``ctrl ``` again, it should change the code block back into a paragraph to do that, we'll need to add a bit of logic to change the type we set based on whether any of the currently selected blocks are already a code block const app = () => { const editor = usememo(() => withreact(createeditor()), \[]) const \[value, setvalue] = usestate(\[ { type 'paragraph', children \[{ text 'a line of text in a paragraph ' }], }, ]) const renderelement = usecallback(props => { switch (props element type) { case 'code' return \<codeelement { props} /> default return \<defaultelement { props} /> } }, \[]) return ( \<slate editor={editor} value={value} onchange={value => setvalue(value)}> \<editable renderelement={renderelement} onkeydown={event => { if (event key === '`' && event ctrlkey) { event preventdefault() // determine whether any of the currently selected blocks are code blocks const \[match] = editor nodes(editor, { match n => n type === 'code', }) // toggle the block type depending on whether there's already a match transforms setnodes( editor, { type match ? 'paragraph' 'code' }, { match n => editor isblock(editor, n) } ) } }} /> \</slate> ) } and there you have it! if you press ``ctrl ``` while inside a code block, it should turn back into a paragraph!