@portabletext/editor 1.0.18 → 1.1.0

package/src/editor/plugins/createWithSchemaTypes.ts

@@ -6,9 +6,11 @@ import {
   type PortableTextSpan,
   type PortableTextTextBlock,
 } from '@sanity/types'
-import {type Element, Transforms} from 'slate'
-
-import {type PortableTextMemberSchemaTypes, type PortableTextSlateEditor} from '../../types/editor'
+import {Transforms, type Element} from 'slate'
+import {
+  type PortableTextMemberSchemaTypes,
+  type PortableTextSlateEditor,
+} from '../../types/editor'
 import {debugWithName} from '../../utils/debug'
 
 const debug = debugWithName('plugin:withSchemaTypes')
@@ -23,21 +25,31 @@ export function createWithSchemaTypes({
   schemaTypes: PortableTextMemberSchemaTypes
   keyGenerator: () => string
 }) {
-  return function withSchemaTypes(editor: PortableTextSlateEditor): PortableTextSlateEditor {
+  return function withSchemaTypes(
+    editor: PortableTextSlateEditor,
+  ): PortableTextSlateEditor {
     editor.isTextBlock = (value: unknown): value is PortableTextTextBlock => {
-      return isPortableTextTextBlock(value) && value._type === schemaTypes.block.name
+      return (
+        isPortableTextTextBlock(value) && value._type === schemaTypes.block.name
+      )
     }
     editor.isTextSpan = (value: unknown): value is PortableTextSpan => {
       return isPortableTextSpan(value) && value._type == schemaTypes.span.name
     }
     editor.isListBlock = (value: unknown): value is PortableTextListBlock => {
-      return isPortableTextListBlock(value) && value._type === schemaTypes.block.name
+      return (
+        isPortableTextListBlock(value) && value._type === schemaTypes.block.name
+      )
     }
     editor.isVoid = (element: Element): boolean => {
       return (
         schemaTypes.block.name !== element._type &&
-        (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) ||
-          schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type))
+        (schemaTypes.blockObjects
+          .map((obj) => obj.name)
+          .includes(element._type) ||
+          schemaTypes.inlineObjects
+            .map((obj) => obj.name)
+            .includes(element._type))
       )
     }
     editor.isInline = (element: Element): boolean => {
@@ -59,7 +71,11 @@ export function createWithSchemaTypes({
         debug('Setting span type on text node without a type')
         const span = node as PortableTextSpan
         const key = span._key || keyGenerator()
-        Transforms.setNodes(editor, {...span, _type: schemaTypes.span.name, _key: key}, {at: path})
+        Transforms.setNodes(
+          editor,
+          {...span, _type: schemaTypes.span.name, _key: key},
+          {at: path},
+        )
       }
 
       // catches cases when the children are missing keys but excludes it when the normalize is running the node as the editor object

package/src/editor/plugins/createWithUndoRedo.ts

@@ -4,15 +4,34 @@
  */
 
 import {type Patch} from '@portabletext/patches'
-import {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, parsePatch} from '@sanity/diff-match-patch'
+import {
+  DIFF_DELETE,
+  DIFF_EQUAL,
+  DIFF_INSERT,
+  parsePatch,
+} from '@sanity/diff-match-patch'
 import {type ObjectSchemaType, type PortableTextBlock} from '@sanity/types'
 import {flatten, isEqual} from 'lodash'
-import {type Descendant, Editor, Operation, Path, type SelectionOperation, Transforms} from 'slate'
-
-import {type PatchObservable, type PortableTextSlateEditor} from '../../types/editor'
+import {
+  Editor,
+  Operation,
+  Path,
+  Transforms,
+  type Descendant,
+  type SelectionOperation,
+} from 'slate'
+import {
+  type PatchObservable,
+  type PortableTextSlateEditor,
+} from '../../types/editor'
 import {debugWithName} from '../../utils/debug'
 import {fromSlateValue} from '../../utils/values'
-import {setIsRedoing, setIsUndoing, withRedoing, withUndoing} from '../../utils/withUndoRedo'
+import {
+  setIsRedoing,
+  setIsUndoing,
+  withRedoing,
+  withUndoing,
+} from '../../utils/withUndoRedo'
 
 const debug = debugWithName('plugin:withUndoRedo')
 const debugVerbose = debug.enabled && false
@@ -66,14 +85,21 @@ export function createWithUndoRedo(
           patches.forEach((patch) => {
             if (!reset && patch.origin !== 'local' && remotePatches) {
               if (patch.type === 'unset' && patch.path.length === 0) {
-                debug('Someone else cleared the content, resetting undo/redo history')
+                debug(
+                  'Someone else cleared the content, resetting undo/redo history',
+                )
                 editor.history = {undos: [], redos: []}
                 remotePatches.splice(0, remotePatches.length)
                 SAVING.set(editor, true)
                 reset = true
                 return
               }
-              remotePatches.push({patch, time: new Date(), snapshot, previousSnapshot})
+              remotePatches.push({
+                patch,
+                time: new Date(),
+                snapshot,
+                previousSnapshot,
+              })
             }
           })
           previousSnapshot = snapshot
@@ -94,7 +120,8 @@ export function createWithUndoRedo(
       const {operations, history} = editor
       const {undos} = history
       const step = undos[undos.length - 1]
-      const lastOp = step && step.operations && step.operations[step.operations.length - 1]
+      const lastOp =
+        step && step.operations && step.operations[step.operations.length - 1]
       const overwrite = shouldOverwrite(op, lastOp)
       const save = isSaving(editor)
 
@@ -110,7 +137,12 @@ export function createWithUndoRedo(
           step.operations.push(op)
         } else {
           const newStep = {
-            operations: [...(editor.selection === null ? [] : [createSelectOperation(editor)]), op],
+            operations: [
+              ...(editor.selection === null
+                ? []
+                : [createSelectOperation(editor)]),
+              op,
+            ],
             timestamp: new Date(),
           }
           undos.push(newStep)
@@ -137,16 +169,26 @@ export function createWithUndoRedo(
         const step = undos[undos.length - 1]
         debug('Undoing', step)
         if (step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp)
+          const otherPatches = remotePatches.filter(
+            (item) => item.time >= step.timestamp,
+          )
           let transformedOperations = step.operations
           otherPatches.forEach((item) => {
             transformedOperations = flatten(
               transformedOperations.map((op) =>
-                transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot),
+                transformOperation(
+                  editor,
+                  item.patch,
+                  op,
+                  item.snapshot,
+                  item.previousSnapshot,
+                ),
               ),
             )
           })
-          const reversedOperations = transformedOperations.map(Operation.inverse).reverse()
+          const reversedOperations = transformedOperations
+            .map(Operation.inverse)
+            .reverse()
 
           try {
             Editor.withoutNormalizing(editor, () => {
@@ -185,12 +227,20 @@ export function createWithUndoRedo(
         const step = redos[redos.length - 1]
         debug('Redoing', step)
         if (step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp)
+          const otherPatches = remotePatches.filter(
+            (item) => item.time >= step.timestamp,
+          )
           let transformedOperations = step.operations
           otherPatches.forEach((item) => {
             transformedOperations = flatten(
               transformedOperations.map((op) =>
-                transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot),
+                transformOperation(
+                  editor,
+                  item.patch,
+                  op,
+                  item.snapshot,
+                  item.previousSnapshot,
+                ),
               ),
             )
           })
@@ -240,7 +290,9 @@ function transformOperation(
   previousSnapshot: PortableTextBlock[] | undefined,
 ): Operation[] {
   if (debugVerbose) {
-    debug(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`)
+    debug(
+      `Adjusting '${operation.type}' operation paths for '${patch.type}' patch`,
+    )
     debug(`Operation ${JSON.stringify(operation)}`)
     debug(`Patch ${JSON.stringify(patch)}`)
   }
@@ -254,7 +306,13 @@ function transformOperation(
     debug(
       `Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`,
     )
-    return [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)]
+    return [
+      adjustBlockPath(
+        transformedOperation,
+        patch.items.length,
+        insertBlockIndex,
+      ),
+    ]
   }
 
   if (patch.type === 'unset' && patch.path.length === 1) {
@@ -281,13 +339,21 @@ function transformOperation(
 
   // Someone reset the whole value
   if (patch.type === 'unset' && patch.path.length === 0) {
-    debug(`Adjusting selection for unset everything patch and ${operation.type} operation`)
+    debug(
+      `Adjusting selection for unset everything patch and ${operation.type} operation`,
+    )
     return []
   }
 
   if (patch.type === 'diffMatchPatch') {
-    const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation)
-    if (!operationTargetBlock || !isEqual({_key: operationTargetBlock._key}, patch.path[0])) {
+    const operationTargetBlock = findOperationTargetBlock(
+      editor,
+      transformedOperation,
+    )
+    if (
+      !operationTargetBlock ||
+      !isEqual({_key: operationTargetBlock._key}, patch.path[0])
+    ) {
       return [transformedOperation]
     }
     const diffPatches = parsePatch(patch.value)
@@ -318,7 +384,10 @@ function transformOperation(
       }
       // Adjust accordingly if someone removed text in the same node before us
       if (transformedOperation.type === 'remove_text') {
-        if (changedOffset <= transformedOperation.offset - transformedOperation.text.length) {
+        if (
+          changedOffset <=
+          transformedOperation.offset - transformedOperation.text.length
+        ) {
           transformedOperation.offset += adjustOffsetBy
         }
       }
@@ -365,7 +434,11 @@ function transformOperation(
 /**
  * Adjust the block path for a operation
  */
-function adjustBlockPath(operation: Operation, level: number, blockIndex: number): Operation {
+function adjustBlockPath(
+  operation: Operation,
+  level: number,
+  blockIndex: number,
+): Operation {
   const transformedOperation = {...operation}
   if (
     blockIndex >= 0 &&
@@ -374,7 +447,10 @@ function adjustBlockPath(operation: Operation, level: number, blockIndex: number
     transformedOperation.path[0] >= blockIndex + level &&
     transformedOperation.path[0] + level > -1
   ) {
-    const newPath = [transformedOperation.path[0] + level, ...transformedOperation.path.slice(1)]
+    const newPath = [
+      transformedOperation.path[0] + level,
+      ...transformedOperation.path.slice(1),
+    ]
     transformedOperation.path = newPath
   }
   if (transformedOperation.type === 'set_selection') {
@@ -393,7 +469,11 @@ function adjustBlockPath(operation: Operation, level: number, blockIndex: number
     if ((currentFocus && currentAnchor) || (newFocus && newAnchor)) {
       const points = [currentFocus, currentAnchor, newFocus, newAnchor]
       points.forEach((point) => {
-        if (point && point.path[0] >= blockIndex + level && point.path[0] + level > -1) {
+        if (
+          point &&
+          point.path[0] >= blockIndex + level &&
+          point.path[0] + level > -1
+        ) {
           point.path = [point.path[0] + level, ...point.path.slice(1)]
         }
       })
@@ -449,7 +529,10 @@ const shouldMerge = (op: Operation, prev: Operation | undefined): boolean => {
   return false
 }
 
-const shouldOverwrite = (op: Operation, prev: Operation | undefined): boolean => {
+const shouldOverwrite = (
+  op: Operation,
+  prev: Operation | undefined,
+): boolean => {
   if (prev && op.type === 'set_selection' && prev.type === 'set_selection') {
     return true
   }

package/src/editor/plugins/createWithUtils.ts

@@ -1,6 +1,8 @@
 import {Editor, Range, Text, Transforms} from 'slate'
-
-import {type PortableTextMemberSchemaTypes, type PortableTextSlateEditor} from '../../types/editor'
+import {
+  type PortableTextMemberSchemaTypes,
+  type PortableTextSlateEditor,
+} from '../../types/editor'
 import {debugWithName} from '../../utils/debug'
 import {toSlateValue} from '../../utils/values'
 import {type PortableTextEditor} from '../PortableTextEditor'
@@ -16,8 +18,14 @@ interface Options {
  * This plugin makes various util commands available in the editor
  *
  */
-export function createWithUtils({schemaTypes, keyGenerator, portableTextEditor}: Options) {
-  return function withUtils(editor: PortableTextSlateEditor): PortableTextSlateEditor {
+export function createWithUtils({
+  schemaTypes,
+  keyGenerator,
+  portableTextEditor,
+}: Options) {
+  return function withUtils(
+    editor: PortableTextSlateEditor,
+  ): PortableTextSlateEditor {
     // Expands the the selection to wrap around the word the focus is at
     editor.pteExpandToWord = () => {
       const {selection} = editor
@@ -37,12 +45,24 @@ export function createWithUtils({schemaTypes, keyGenerator, portableTextEditor}:
           .reverse()
           .findIndex((str) => isEmpty(str))
         const newStartOffset =
-          whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0
-        const whiteSpaceAfterIndex = charsAfter.split('').findIndex((obj) => isEmpty(obj))
+          whiteSpaceBeforeIndex > -1
+            ? charsBefore.length - whiteSpaceBeforeIndex
+            : 0
+        const whiteSpaceAfterIndex = charsAfter
+          .split('')
+          .findIndex((obj) => isEmpty(obj))
         const newEndOffset =
           charsBefore.length +
-          (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1)
-        if (!(newStartOffset === newEndOffset || isNaN(newStartOffset) || isNaN(newEndOffset))) {
+          (whiteSpaceAfterIndex > -1
+            ? whiteSpaceAfterIndex
+            : charsAfter.length + 1)
+        if (
+          !(
+            newStartOffset === newEndOffset ||
+            isNaN(newStartOffset) ||
+            isNaN(newEndOffset)
+          )
+        ) {
           debug('pteExpandToWord: Expanding to focused word')
           Transforms.setSelection(editor, {
             anchor: {...selection.anchor, offset: newStartOffset},
@@ -54,7 +74,7 @@ export function createWithUtils({schemaTypes, keyGenerator, portableTextEditor}:
       }
     }
 
-    editor.pteCreateEmptyBlock = () => {
+    editor.pteCreateTextBlock = (options: {decorators: Array<string>}) => {
       const block = toSlateValue(
         [
           {
@@ -67,7 +87,9 @@ export function createWithUtils({schemaTypes, keyGenerator, portableTextEditor}:
                 _type: 'span',
                 _key: keyGenerator(),
                 text: '',
-                marks: [],
+                marks: options.decorators.filter((decorator) =>
+                  schemaTypes.decorators.find(({value}) => value === decorator),
+                ),
               },
             ],
           },

package/src/editor/plugins/index.ts

@@ -1,6 +1,5 @@
 import {noop} from 'lodash'
 import {type BaseOperation, type Editor, type Node, type NodeEntry} from 'slate'
-
 import {type PortableTextSlateEditor} from '../../types/editor'
 import {type createEditorOptions} from '../../types/options'
 import {createOperationToPatches} from '../../utils/operationToPatches'
@@ -38,14 +37,18 @@ export interface OriginalEditorFunctions {
   normalizeNode: (entry: NodeEntry<Node>) => void
 }
 
-const originalFnMap = new WeakMap<PortableTextSlateEditor, OriginalEditorFunctions>()
+const originalFnMap = new WeakMap<
+  PortableTextSlateEditor,
+  OriginalEditorFunctions
+>()
 
 export const withPlugins = <T extends Editor>(
   editor: T,
   options: createEditorOptions,
 ): {editor: PortableTextSlateEditor; subscribe: () => () => void} => {
   const e = editor as T & PortableTextSlateEditor
-  const {keyGenerator, portableTextEditor, patches$, readOnly, maxBlocks} = options
+  const {keyGenerator, portableTextEditor, patches$, readOnly, maxBlocks} =
+    options
   const {schemaTypes, change$} = portableTextEditor
   e.subscriptions = []
   if (e.destroy) {
@@ -62,7 +65,11 @@ export const withPlugins = <T extends Editor>(
   const operationToPatches = createOperationToPatches(schemaTypes)
   const withObjectKeys = createWithObjectKeys(schemaTypes, keyGenerator)
   const withSchemaTypes = createWithSchemaTypes({schemaTypes, keyGenerator})
-  const withEditableAPI = createWithEditableAPI(portableTextEditor, schemaTypes, keyGenerator)
+  const withEditableAPI = createWithEditableAPI(
+    portableTextEditor,
+    schemaTypes,
+    keyGenerator,
+  )
   const withPatches = createWithPatches({
     change$,
     keyGenerator,
@@ -83,14 +90,22 @@ export const withPlugins = <T extends Editor>(
     change$,
     keyGenerator,
   )
-  const withPortableTextBlockStyle = createWithPortableTextBlockStyle(schemaTypes)
+  const withPortableTextBlockStyle =
+    createWithPortableTextBlockStyle(schemaTypes)
 
   const withPlaceholderBlock = createWithPlaceholderBlock()
 
-  const withInsertBreak = createWithInsertBreak(schemaTypes)
+  const withInsertBreak = createWithInsertBreak(schemaTypes, keyGenerator)
 
-  const withUtils = createWithUtils({keyGenerator, schemaTypes, portableTextEditor})
-  const withPortableTextSelections = createWithPortableTextSelections(change$, schemaTypes)
+  const withUtils = createWithUtils({
+    keyGenerator,
+    schemaTypes,
+    portableTextEditor,
+  })
+  const withPortableTextSelections = createWithPortableTextSelections(
+    change$,
+    schemaTypes,
+  )
 
   e.destroy = () => {
     const originalFunctions = originalFnMap.get(e)
@@ -111,7 +126,9 @@ export const withPlugins = <T extends Editor>(
               withUtils(
                 withPlaceholderBlock(
                   withPortableTextLists(
-                    withPortableTextSelections(withEditableAPI(withInsertBreak(e))),
+                    withPortableTextSelections(
+                      withEditableAPI(withInsertBreak(e)),
+                    ),
                   ),
                 ),
               ),
@@ -134,7 +151,11 @@ export const withPlugins = <T extends Editor>(
                 withUtils(
                   withMaxBlocks(
                     withUndoRedo(
-                      withPatches(withPortableTextSelections(withEditableAPI(withInsertBreak(e)))),
+                      withPatches(
+                        withPortableTextSelections(
+                          withEditableAPI(withInsertBreak(e)),
+                        ),
+                      ),
                     ),
                   ),
                 ),

package/src/types/editor.ts

@@ -25,10 +25,13 @@ import {
   type RefObject,
 } from 'react'
 import {type Observable, type Subject} from 'rxjs'
-import {type Descendant, type Node as SlateNode, type Operation as SlateOperation} from 'slate'
+import {
+  type Descendant,
+  type Node as SlateNode,
+  type Operation as SlateOperation,
+} from 'slate'
 import {type ReactEditor} from 'slate-react'
 import {type DOMNode} from 'slate-react/dist/utils/dom'
-
 import {type PortableTextEditableProps} from '../editor/Editable'
 import {type PortableTextEditor} from '../editor/PortableTextEditor'
 
@@ -44,11 +47,20 @@ export interface EditableAPI {
   addAnnotation: (
     type: ObjectSchemaType,
     value?: {[prop: string]: unknown},
-  ) => {spanPath: Path; markDefPath: Path} | undefined
+  ) =>
+    | {markDefPath: Path; markDefPaths: Array<Path>; spanPath: Path}
+    | undefined
   blur: () => void
-  delete: (selection: EditorSelection, options?: EditableAPIDeleteOptions) => void
-  findByPath: (path: Path) => [PortableTextBlock | PortableTextChild | undefined, Path | undefined]
-  findDOMNode: (element: PortableTextBlock | PortableTextChild) => DOMNode | undefined
+  delete: (
+    selection: EditorSelection,
+    options?: EditableAPIDeleteOptions,
+  ) => void
+  findByPath: (
+    path: Path,
+  ) => [PortableTextBlock | PortableTextChild | undefined, Path | undefined]
+  findDOMNode: (
+    element: PortableTextBlock | PortableTextChild,
+  ) => DOMNode | undefined
   focus: () => void
   focusBlock: () => PortableTextBlock | undefined
   focusChild: () => PortableTextChild | undefined
@@ -57,13 +69,22 @@ export interface EditableAPI {
   getValue: () => PortableTextBlock[] | undefined
   hasBlockStyle: (style: string) => boolean
   hasListStyle: (listStyle: string) => boolean
-  insertBlock: (type: BlockSchemaType | ObjectSchemaType, value?: {[prop: string]: unknown}) => Path
-  insertChild: (type: SpanSchemaType | ObjectSchemaType, value?: {[prop: string]: unknown}) => Path
+  insertBlock: (
+    type: BlockSchemaType | ObjectSchemaType,
+    value?: {[prop: string]: unknown},
+  ) => Path
+  insertChild: (
+    type: SpanSchemaType | ObjectSchemaType,
+    value?: {[prop: string]: unknown},
+  ) => Path
   insertBreak: () => void
   isCollapsedSelection: () => boolean
   isExpandedSelection: () => boolean
   isMarkActive: (mark: string) => boolean
-  isSelectionsOverlapping: (selectionA: EditorSelection, selectionB: EditorSelection) => boolean
+  isSelectionsOverlapping: (
+    selectionA: EditorSelection,
+    selectionB: EditorSelection,
+  ) => boolean
   isVoid: (element: PortableTextBlock | PortableTextChild) => boolean
   marks: () => string[]
   redo: () => void
@@ -199,9 +220,9 @@ export interface PortableTextSlateEditor extends ReactEditor {
   pteWithHotKeys: (event: KeyboardEvent<HTMLDivElement>) => void
 
   /**
-   * Helper function that creates an empty text block
+   * Helper function that creates a text block
    */
-  pteCreateEmptyBlock: () => Descendant
+  pteCreateTextBlock: (options: {decorators: Array<string>}) => Descendant
 
   /**
    * Undo
@@ -498,10 +519,14 @@ export type RenderBlockFunction = (props: BlockRenderProps) => JSX.Element
 export type RenderChildFunction = (props: BlockChildRenderProps) => JSX.Element
 
 /** @beta */
-export type RenderEditableFunction = (props: PortableTextEditableProps) => JSX.Element
+export type RenderEditableFunction = (
+  props: PortableTextEditableProps,
+) => JSX.Element
 
 /** @beta */
-export type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX.Element
+export type RenderAnnotationFunction = (
+  props: BlockAnnotationRenderProps,
+) => JSX.Element
 
 /** @beta */
 export type RenderPlaceholderFunction = () => React.ReactNode
@@ -522,10 +547,14 @@ export interface BlockStyleRenderProps {
 }
 
 /** @beta */
-export type RenderListItemFunction = (props: BlockListItemRenderProps) => JSX.Element
+export type RenderListItemFunction = (
+  props: BlockListItemRenderProps,
+) => JSX.Element
 
 /** @beta */
-export type RenderDecoratorFunction = (props: BlockDecoratorRenderProps) => JSX.Element
+export type RenderDecoratorFunction = (
+  props: BlockDecoratorRenderProps,
+) => JSX.Element
 
 /** @beta */
 export type ScrollSelectionIntoViewFunction = (

package/src/types/options.ts

@@ -1,5 +1,4 @@
 import {type BaseSyntheticEvent} from 'react'
-
 import {type PortableTextEditor} from '../editor/PortableTextEditor'
 import {type PatchObservable} from './editor'
 
@@ -19,5 +18,8 @@ export type createEditorOptions = {
  */
 export type HotkeyOptions = {
   marks?: Record<string, string>
-  custom?: Record<string, (event: BaseSyntheticEvent, editor: PortableTextEditor) => void>
+  custom?: Record<
+    string,
+    (event: BaseSyntheticEvent, editor: PortableTextEditor) => void
+  >
 }

package/src/types/slate.ts

@@ -1,7 +1,6 @@
 import {type PortableTextSpan, type PortableTextTextBlock} from '@sanity/types'
 import {type BaseEditor, type Descendant} from 'slate'
 import {type ReactEditor} from 'slate-react'
-
 import {type PortableTextSlateEditor} from '..'
 
 export interface VoidElement {
@@ -12,7 +11,8 @@ export interface VoidElement {
   value: Record<string, unknown>
 }
 
-export interface SlateTextBlock extends Omit<PortableTextTextBlock, 'children'> {
+export interface SlateTextBlock
+  extends Omit<PortableTextTextBlock, 'children'> {
   children: Descendant[]
 }