@portabletext/editor 1.0.18 → 1.1.0

package/src/utils/__tests__/dmpToOperations.test.ts

@@ -10,7 +10,6 @@ import {
   type PortableTextTextBlock,
 } from '@sanity/types'
 import {type Descendant, type Operation} from 'slate'
-
 import {type PortableTextSlateEditor} from '../../types/editor'
 import {diffMatchPatch} from '../applyPatch'
 
@@ -23,7 +22,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should apply the most basic additive operation correctly', () => {
     const source = 'Hello'
     const target = 'Hello there'
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -32,7 +33,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should apply the most basic removal operation correctly', () => {
     const source = 'Hello there'
     const target = 'Hello'
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -41,7 +44,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should treat equality as noops', () => {
     const source = 'Hello'
     const target = 'Hello'
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -50,7 +55,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should apply combined add + remove operations', () => {
     const source = 'A quick brown fox jumps over the very lazy dog'
     const target = 'The quick brown fox jumps over the lazy dog'
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -58,8 +65,11 @@ describe('operationToPatches: diffMatchPatch', () => {
 
   test('should apply combined add + remove operations', () => {
     const source = 'Many quick brown fox jumps over the very lazy dog'
-    const target = 'The many, quick, brown, foxes jumps over all of the lazy dogs'
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const target =
+      'The many, quick, brown, foxes jumps over all of the lazy dogs'
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -70,7 +80,9 @@ describe('operationToPatches: diffMatchPatch', () => {
     const line2 = 'But the slow green frog jumps over the wild cat'
     const source = [line1, line2, line1, line2].join('\n')
     const target = [line2, line1, line2, line1].join('\n')
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -79,7 +91,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should apply larger text differences correctly', () => {
     const source = `Portable Text is a agnostic abstraction of "rich text" that can be stringified into any markup language, for instance HTML, Markdown, SSML, XML, etc. It's designed to be efficient for collaboration, and makes it possible to enrich rich text with data structures in depth.\n\nPortable Text is built on the idea of rich text as an array of blocks, themselves arrays of children spans. Each block can have a style and a set of mark dfinitions, which describe data structures distributed on the children spans. Portable Text also allows for inserting arbitrary data objects in the array, only requiring _type-key. Portable Text also allows for custom objects in the root array, enabling rendering environments to mix rich text with custom content types.\n\nPortable Text is a combination of arrays and objects. In its simplest form it's an array of objects with an array of children. Some definitions: \n- Block: Typically recognized as a section of a text, e.g. a paragraph or a heading.\n- Span: Piece of text with a set of marks, e.g. bold or italic.\n- Mark: A mark is a data structure that can be appliad to a span, e.g. a link or a comment.\n- Mark definition: A mark definition is a structure that describes a mark, a link or a comment.`
     const target = `Portable Text is an agnostic abstraction of rich text that can be serialized into pretty much any markup language, be it HTML, Markdown, SSML, XML, etc. It is designed to be efficient for real-time collaborative interfaces, and makes it possible to annotate rich text with additional data structures recursively.\n\nPortable Text is built on the idea of rich text as an array of blocks, themselves arrays of child spans. Each block can have a style and a set of mark definitions, which describe data structures that can be applied on the children spans. Portable Text also allows for inserting arbitrary data objects in the array, only requiring _type-key. Portable Text also allows for custom content objects in the root array, enabling editing- and rendering environments to mix rich text with custom content types.\n\nPortable Text is a recursive composition of arrays and objects. In its simplest form it's an array of objects of a type with an array of children. Some definitions: \n- Block: A block is what's typically recognized as a section of a text, e.g. a paragraph or a heading.\n- Span: A span is a piece of text with a set of marks, e.g. bold or italic.\n- Mark: A mark is a data structure that can be applied to a span, e.g. a link or a comment.\n- Mark definition: A mark definition is a data structure that describes a mark, e.g. a link or a comment.`
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -88,7 +102,9 @@ describe('operationToPatches: diffMatchPatch', () => {
   test('should apply offset text differences correctly', () => {
     const source = `This string has changes, but they occur somewhere near the end. That means we need to use an offset to get at the change, we cannot just rely on equality segaments in the generated diff.`
     const target = `This string has changes, but they occur somewhere near the end. That means we need to use an offset to get at the change, we cannot just rely on equality segments in the generated diff.`
-    const patch = getPteDmpPatch(stringifyPatches(makePatches(makeDiff(source, target))))
+    const patch = getPteDmpPatch(
+      stringifyPatches(makePatches(makeDiff(source, target))),
+    )
     const editor = getMockEditor({text: source})
     expect(diffMatchPatch(editor, patch)).toBe(true)
     expect(editor.getText()).toBe(target)
@@ -115,13 +131,20 @@ function getMockEditor(options: MockEditorOptions): Pick<
 > & {
   getText: () => string
 } {
-  let children: PortableTextBlock[] = 'children' in options ? options.children : []
+  let children: PortableTextBlock[] =
+    'children' in options ? options.children : []
   if (!('children' in options)) {
     children = [
       {
         _type: 'block',
         _key: 'bA',
-        children: [{_type: 'span', _key: 's1', text: 'text' in options ? options.text : ''}],
+        children: [
+          {
+            _type: 'span',
+            _key: 's1',
+            text: 'text' in options ? options.text : '',
+          },
+        ],
         markDefs: [],
       },
     ]
@@ -129,7 +152,9 @@ function getMockEditor(options: MockEditorOptions): Pick<
 
   function getText(blockKey?: string) {
     return children
-      .filter((child): child is PortableTextTextBlock => isPortableTextTextBlock(child))
+      .filter((child): child is PortableTextTextBlock =>
+        isPortableTextTextBlock(child),
+      )
       .filter((child) => (blockKey ? child._key === blockKey : true))
       .flatMap((block) =>
         block.children

package/src/utils/__tests__/operationToPatches.test.ts

@@ -1,7 +1,6 @@
 import {beforeEach, describe, expect, it} from '@jest/globals'
 import {type PortableTextTextBlock} from '@sanity/types'
 import {createEditor, type Descendant} from 'slate'
-
 import {PortableTextEditor, type PortableTextEditorProps} from '../..'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
 import {defaultKeyGenerator} from '../../editor/hooks/usePortableTextEditorKeyGenerator'
@@ -14,7 +13,9 @@ const portableTextFeatures = getPortableTextMemberSchemaTypes(schemaType)
 const operationToPatches = createOperationToPatches(portableTextFeatures)
 
 const {editor} = withPlugins(createEditor(), {
-  portableTextEditor: new PortableTextEditor({schemaType} as PortableTextEditorProps),
+  portableTextEditor: new PortableTextEditor({
+    schemaType,
+  } as PortableTextEditorProps),
   keyGenerator: defaultKeyGenerator,
   readOnly: false,
 })

package/src/utils/__tests__/patchToOperations.test.ts

@@ -2,7 +2,6 @@ import {beforeEach, describe, expect, it} from '@jest/globals'
 import {type Patch} from '@portabletext/patches'
 import {noop} from 'lodash'
 import {createEditor, type Descendant} from 'slate'
-
 import {keyGenerator, PortableTextEditor} from '../..'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
 import {withPlugins} from '../../editor/plugins'
@@ -51,7 +50,11 @@ describe('operationToPatches', () => {
   it('makes the correct operations for block objects', () => {
     editor.children = createDefaultValue()
     const patches = [
-      {type: 'unset', path: [{_key: 'c01739b0d03b'}, 'hotspot'], origin: 'remote'},
+      {
+        type: 'unset',
+        path: [{_key: 'c01739b0d03b'}, 'hotspot'],
+        origin: 'remote',
+      },
       {type: 'unset', path: [{_key: 'c01739b0d03b'}, 'crop'], origin: 'remote'},
       {
         type: 'set',
@@ -114,7 +117,11 @@ describe('operationToPatches', () => {
       },
     ]
     const patches = [
-      {type: 'insert', path: [{_key: 'c01739b0d03b'}, 'nestedArray'], origin: 'remote'},
+      {
+        type: 'insert',
+        path: [{_key: 'c01739b0d03b'}, 'nestedArray'],
+        origin: 'remote',
+      },
     ] as Patch[]
     patches.forEach((p) => {
       patchToOperations(editor, p)
@@ -173,7 +180,11 @@ describe('operationToPatches', () => {
       },
     ]
     const patches = [
-      {type: 'unset', path: [{_key: 'c01739b0d03b'}, 'nestedArray', 0], origin: 'remote'},
+      {
+        type: 'unset',
+        path: [{_key: 'c01739b0d03b'}, 'nestedArray', 0],
+        origin: 'remote',
+      },
     ] as Patch[]
     patches.forEach((p) => {
       patchToOperations(editor, p)

package/src/utils/__tests__/ranges.test.ts

@@ -1,11 +1,13 @@
 import {describe, expect, it} from '@jest/globals'
 import {type InsertTextOperation, type Range} from 'slate'
-
 import {moveRangeByOperation} from '../ranges'
 
 describe('moveRangeByOperation', () => {
   it('should move range when inserting text in front of it', () => {
-    const range: Range = {anchor: {path: [0, 0], offset: 1}, focus: {path: [0, 0], offset: 3}}
+    const range: Range = {
+      anchor: {path: [0, 0], offset: 1},
+      focus: {path: [0, 0], offset: 3},
+    }
     const operation: InsertTextOperation = {
       type: 'insert_text',
       path: [0, 0],
@@ -13,6 +15,9 @@ describe('moveRangeByOperation', () => {
       text: 'foo',
     }
     const newRange = moveRangeByOperation(range, operation)
-    expect(newRange).toEqual({anchor: {path: [0, 0], offset: 4}, focus: {path: [0, 0], offset: 6}})
+    expect(newRange).toEqual({
+      anchor: {path: [0, 0], offset: 4},
+      focus: {path: [0, 0], offset: 6},
+    })
   })
 })

package/src/utils/__tests__/valueNormalization.test.tsx

@@ -1,8 +1,10 @@
 import {describe, expect, it, jest} from '@jest/globals'
 import {render, waitFor} from '@testing-library/react'
 import {createRef, type RefObject} from 'react'
-
-import {PortableTextEditorTester, schemaType} from '../../editor/__tests__/PortableTextEditorTester'
+import {
+  PortableTextEditorTester,
+  schemaType,
+} from '../../editor/__tests__/PortableTextEditorTester'
 import {PortableTextEditor} from '../../editor/PortableTextEditor'
 
 describe('values: normalization', () => {
@@ -36,8 +38,14 @@ describe('values: normalization', () => {
       if (editorRef.current) {
         PortableTextEditor.focus(editorRef.current)
         PortableTextEditor.select(editorRef.current, {
-          focus: {path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}], offset: 0},
-          anchor: {path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}], offset: 5},
+          focus: {
+            path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}],
+            offset: 0,
+          },
+          anchor: {
+            path: [{_key: '5fc57af23597'}, 'children', {_key: 'be1c67c6971a'}],
+            offset: 5,
+          },
         })
         PortableTextEditor.toggleMark(editorRef.current, 'strong')
         expect(PortableTextEditor.getValue(editorRef.current)).toEqual([

package/src/utils/__tests__/values.test.ts

@@ -1,5 +1,4 @@
 import {describe, expect, it} from '@jest/globals'
-
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
 import {getPortableTextMemberSchemaTypes} from '../getPortableTextMemberSchemaTypes'
 import {fromSlateValue, toSlateValue} from '../values'

package/src/utils/applyPatch.ts

@@ -8,11 +8,11 @@ import {
   type UnsetPatch,
 } from '@portabletext/patches'
 import {
-  applyPatches as diffMatchPatchApplyPatches,
   cleanupEfficiency,
   DIFF_DELETE,
   DIFF_EQUAL,
   DIFF_INSERT,
+  applyPatches as diffMatchPatchApplyPatches,
   makeDiff,
   parsePatch,
 } from '@sanity/diff-match-patch'
@@ -23,9 +23,18 @@ import {
   type PortableTextBlock,
   type PortableTextChild,
 } from '@sanity/types'
-import {type Descendant, Element, type Node, type Path as SlatePath, Text, Transforms} from 'slate'
-
-import {type PortableTextMemberSchemaTypes, type PortableTextSlateEditor} from '../types/editor'
+import {
+  Element,
+  Text,
+  Transforms,
+  type Descendant,
+  type Node,
+  type Path as SlatePath,
+} from 'slate'
+import {
+  type PortableTextMemberSchemaTypes,
+  type PortableTextSlateEditor,
+} from '../types/editor'
 import {debugWithName} from './debug'
 import {toSlateValue} from './values'
 import {KEY_TO_SLATE_ELEMENT} from './weakMaps'
@@ -46,7 +55,9 @@ export function createApplyPatch(
 
     // Save some CPU cycles by not stringifying unless enabled
     if (debugVerbose) {
-      debug('\n\nNEW PATCH =============================================================')
+      debug(
+        '\n\nNEW PATCH =============================================================',
+      )
       debug(JSON.stringify(patch, null, 2))
     }
 
@@ -91,7 +102,10 @@ export function diffMatchPatch(
   >,
   patch: DiffMatchPatch,
 ): boolean {
-  const {block, child, childPath} = findBlockAndChildFromPath(editor, patch.path)
+  const {block, child, childPath} = findBlockAndChildFromPath(
+    editor,
+    patch.path,
+  )
   if (!block) {
     debug('Block not found')
     return false
@@ -112,7 +126,9 @@ export function diffMatchPatch(
   }
 
   const patches = parsePatch(patch.value)
-  const [newValue] = diffMatchPatchApplyPatches(patches, child.text, {allowExceedingIndices: true})
+  const [newValue] = diffMatchPatchApplyPatches(patches, child.text, {
+    allowExceedingIndices: true,
+  })
   const diff = cleanupEfficiency(makeDiff(child.text, newValue), 5)
 
   debugState(editor, 'before')
@@ -160,7 +176,8 @@ function insertPatch(
       KEY_TO_SLATE_ELEMENT.get(editor),
     ) as Descendant[]
     const targetBlockIndex = targetBlockPath[0]
-    const normalizedIdx = position === 'after' ? targetBlockIndex + 1 : targetBlockIndex
+    const normalizedIdx =
+      position === 'after' ? targetBlockIndex + 1 : targetBlockIndex
     debug(`Inserting blocks at path [${normalizedIdx}]`)
     debugState(editor, 'before')
     Transforms.insertNodes(editor, blocksToInsert, {at: [normalizedIdx]})
@@ -181,12 +198,15 @@ function insertPatch(
       KEY_TO_SLATE_ELEMENT.get(editor),
     )
   const targetChildIndex = targetChildPath[1]
-  const normalizedIdx = position === 'after' ? targetChildIndex + 1 : targetChildIndex
+  const normalizedIdx =
+    position === 'after' ? targetChildIndex + 1 : targetChildIndex
   const childInsertPath = [targetChildPath[0], normalizedIdx]
   debug(`Inserting children at path ${childInsertPath}`)
   debugState(editor, 'before')
   if (childrenToInsert && Element.isElement(childrenToInsert[0])) {
-    Transforms.insertNodes(editor, childrenToInsert[0].children, {at: childInsertPath})
+    Transforms.insertNodes(editor, childrenToInsert[0].children, {
+      at: childInsertPath,
+    })
   }
   debugState(editor, 'after')
   return true
@@ -198,7 +218,10 @@ function setPatch(editor: PortableTextSlateEditor, patch: SetPatch) {
     value = {}
     value[patch.path[3]] = patch.value
   }
-  const {block, blockPath, child, childPath} = findBlockAndChildFromPath(editor, patch.path)
+  const {block, blockPath, child, childPath} = findBlockAndChildFromPath(
+    editor,
+    patch.path,
+  )
 
   if (!block) {
     debug('Block not found')
@@ -287,7 +310,11 @@ function setPatch(editor: PortableTextSlateEditor, patch: SetPatch) {
   return true
 }
 
-function unsetPatch(editor: PortableTextSlateEditor, patch: UnsetPatch, previousPatch?: Patch) {
+function unsetPatch(
+  editor: PortableTextSlateEditor,
+  patch: UnsetPatch,
+  previousPatch?: Patch,
+) {
   // Value
   if (patch.path.length === 0) {
     debug('Removing everything')
@@ -297,7 +324,7 @@ function unsetPatch(editor: PortableTextSlateEditor, patch: UnsetPatch, previous
     editor.children.forEach((c, i) => {
       Transforms.removeNodes(editor, {at: [i]})
     })
-    Transforms.insertNodes(editor, editor.pteCreateEmptyBlock())
+    Transforms.insertNodes(editor, editor.pteCreateTextBlock({decorators: []}))
     if (previousSelection) {
       Transforms.select(editor, {
         anchor: {path: [0, 0], offset: 0},
@@ -309,7 +336,10 @@ function unsetPatch(editor: PortableTextSlateEditor, patch: UnsetPatch, previous
     debugState(editor, 'after')
     return true
   }
-  const {block, blockPath, child, childPath} = findBlockAndChildFromPath(editor, patch.path)
+  const {block, blockPath, child, childPath} = findBlockAndChildFromPath(
+    editor,
+    patch.path,
+  )
 
   // Single blocks
   if (patch.path.length === 1) {
@@ -327,7 +357,11 @@ function unsetPatch(editor: PortableTextSlateEditor, patch: UnsetPatch, previous
   }
 
   // Unset on text block children
-  if (editor.isTextBlock(block) && patch.path[1] === 'children' && patch.path.length === 3) {
+  if (
+    editor.isTextBlock(block) &&
+    patch.path[1] === 'children' &&
+    patch.path.length === 3
+  ) {
     if (!child || !childPath) {
       debug('Child not found')
       return false
@@ -349,7 +383,10 @@ function isKeyedSegment(segment: PathSegment): segment is KeyedSegment {
 }
 
 function debugState(
-  editor: Pick<PortableTextSlateEditor, 'children' | 'isTextBlock' | 'apply' | 'selection'>,
+  editor: Pick<
+    PortableTextSlateEditor,
+    'children' | 'isTextBlock' | 'apply' | 'selection'
+  >,
   stateName: string,
 ) {
   if (!debugVerbose) {
@@ -369,7 +406,9 @@ function findBlockFromPath(
 ): {block?: Descendant; path?: SlatePath} {
   let blockIndex = -1
   const block = editor.children.find((node: Descendant, index: number) => {
-    const isMatch = isKeyedSegment(path[0]) ? node._key === path[0]._key : index === path[0]
+    const isMatch = isKeyedSegment(path[0])
+      ? node._key === path[0]._key
+      : index === path[0]
     if (isMatch) {
       blockIndex = index
     }
@@ -387,14 +426,21 @@ function findBlockAndChildFromPath(
     'children' | 'isTextBlock' | 'apply' | 'selection' | 'onChange'
   >,
   path: Path,
-): {child?: Descendant; childPath?: SlatePath; block?: Descendant; blockPath?: SlatePath} {
+): {
+  child?: Descendant
+  childPath?: SlatePath
+  block?: Descendant
+  blockPath?: SlatePath
+} {
   const {block, path: blockPath} = findBlockFromPath(editor, path)
   if (!(Element.isElement(block) && path[1] === 'children')) {
     return {block, blockPath, child: undefined, childPath: undefined}
   }
   let childIndex = -1
   const child = block.children.find((node, index: number) => {
-    const isMatch = isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2]
+    const isMatch = isKeyedSegment(path[2])
+      ? node._key === path[2]._key
+      : index === path[2]
     if (isMatch) {
       childIndex = index
     }
@@ -403,5 +449,10 @@ function findBlockAndChildFromPath(
   if (!child) {
     return {block, blockPath, child: undefined, childPath: undefined}
   }
-  return {block, child, blockPath, childPath: blockPath?.concat(childIndex) as SlatePath}
+  return {
+    block,
+    child,
+    blockPath,
+    childPath: blockPath?.concat(childIndex) as SlatePath,
+  }
 }

package/src/utils/getPortableTextMemberSchemaTypes.ts

@@ -6,7 +6,6 @@ import {
   type SchemaType,
   type SpanSchemaType,
 } from '@sanity/types'
-
 import {type PortableTextMemberSchemaTypes} from '../types/editor'
 
 export function getPortableTextMemberSchemaTypes(
@@ -15,19 +14,23 @@ export function getPortableTextMemberSchemaTypes(
   if (!portableTextType) {
     throw new Error("Parameter 'portabletextType' missing (required)")
   }
-  const blockType = portableTextType.of?.find(findBlockType) as BlockSchemaType | undefined
+  const blockType = portableTextType.of?.find(findBlockType) as
+    | BlockSchemaType
+    | undefined
   if (!blockType) {
     throw new Error('Block type is not defined in this schema (required)')
   }
-  const childrenField = blockType.fields?.find((field) => field.name === 'children') as
-    | {type: ArraySchemaType}
-    | undefined
+  const childrenField = blockType.fields?.find(
+    (field) => field.name === 'children',
+  ) as {type: ArraySchemaType} | undefined
   if (!childrenField) {
     throw new Error('Children field for block type found in schema (required)')
   }
   const ofType = childrenField.type.of
   if (!ofType) {
-    throw new Error('Valid types for block children not found in schema (required)')
+    throw new Error(
+      'Valid types for block children not found in schema (required)',
+    )
   }
   const spanType = ofType.find((memberType) => memberType.name === 'span') as
     | ObjectSchemaType
@@ -35,10 +38,12 @@ export function getPortableTextMemberSchemaTypes(
   if (!spanType) {
     throw new Error('Span type not found in schema (required)')
   }
-  const inlineObjectTypes = (ofType.filter((memberType) => memberType.name !== 'span') ||
-    []) as ObjectSchemaType[]
-  const blockObjectTypes = (portableTextType.of?.filter((field) => field.name !== blockType.name) ||
-    []) as ObjectSchemaType[]
+  const inlineObjectTypes = (ofType.filter(
+    (memberType) => memberType.name !== 'span',
+  ) || []) as ObjectSchemaType[]
+  const blockObjectTypes = (portableTextType.of?.filter(
+    (field) => field.name !== blockType.name,
+  ) || []) as ObjectSchemaType[]
   return {
     styles: resolveEnabledStyles(blockType),
     decorators: resolveEnabledDecorators(spanType),
@@ -53,13 +58,19 @@ export function getPortableTextMemberSchemaTypes(
 }
 
 function resolveEnabledStyles(blockType: ObjectSchemaType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === 'style')
+  const styleField = blockType.fields?.find(
+    (btField) => btField.name === 'style',
+  )
   if (!styleField) {
-    throw new Error("A field with name 'style' is not defined in the block type (required).")
+    throw new Error(
+      "A field with name 'style' is not defined in the block type (required).",
+    )
   }
   const textStyles =
     styleField.type.options?.list &&
-    styleField.type.options.list?.filter((style: {value: string}) => style.value)
+    styleField.type.options.list?.filter(
+      (style: {value: string}) => style.value,
+    )
   if (!textStyles || textStyles.length === 0) {
     throw new Error(
       'The style fields need at least one style ' +
@@ -74,9 +85,13 @@ function resolveEnabledDecorators(spanType: ObjectSchemaType) {
 }
 
 function resolveEnabledListItems(blockType: ObjectSchemaType) {
-  const listField = blockType.fields?.find((btField) => btField.name === 'listItem')
+  const listField = blockType.fields?.find(
+    (btField) => btField.name === 'listItem',
+  )
   if (!listField) {
-    throw new Error("A field with name 'listItem' is not defined in the block type (required).")
+    throw new Error(
+      "A field with name 'listItem' is not defined in the block type (required).",
+    )
   }
   const listItems =
     listField.type.options?.list &&